@playcraft/cli 0.1.59-beta → 0.1.61-beta

package/dist/workspace-runtime/codex/production-skill-tools.js

@@ -0,0 +1,95 @@
+import { rejectTool, toolContent } from './tool-response.js';
+export const PROCEDURAL_3D_TOOL = {
+    type: 'function',
+    name: 'playcraft_procedural_3d',
+    description: 'Run the enabled, explicitly selected procedural 3D skill using its locked tools. Read that skill for action inputs. prepare freezes a local reference; adapter actions operate in the returned run directory; capture freezes and renders a candidate; review records observations against that candidate; adopt copies only the reviewed bytes. Calls require an exclusive execution turn. A requires_exclusive_turn result requires selecting the skill in a new turn.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: [
+                    'describe',
+                    'preflight',
+                    'prepare',
+                    'status',
+                    'recover',
+                    'next',
+                    'run-step',
+                    'request-correction',
+                    'capture',
+                    'review',
+                    'adopt',
+                ],
+            },
+            runId: { type: 'string' },
+            expectedRevision: { type: 'integer', minimum: 0 },
+            input: { type: 'object' },
+        },
+        required: ['action'],
+        additionalProperties: false,
+    },
+};
+/** Only the host may attach a validated workspace-relative diagnostic report. */
+export class ProductionSkillFailure extends Error {
+    reportPath;
+    constructor(reason, reportPath) {
+        super(reason);
+        this.reportPath = reportPath;
+    }
+}
+/** Native turn identity is supplied by the app-server adapter, never by tool arguments. */
+export class ProductionSkillTools {
+    handler;
+    active = new Map();
+    constructor(handler) {
+        this.handler = handler;
+    }
+    hasActive(threadId, turnId) {
+        return [...this.active.values()].some((item) => (!threadId || item.context.nativeThreadId === threadId) &&
+            (!turnId || item.context.nativeTurnId === turnId));
+    }
+    async request(id, payload, client, context) {
+        if (!context)
+            return rejectTool(client, id, 'procedural_skill_inactive_turn');
+        const key = `${context.nativeThreadId}:${context.nativeTurnId}`;
+        if (this.active.has(key))
+            return rejectTool(client, id, 'procedural_skill_busy');
+        const abort = new AbortController();
+        let finish;
+        const done = new Promise((resolve) => {
+            finish = resolve;
+        });
+        this.active.set(key, { context, abort, done });
+        try {
+            const result = await this.handler(payload.arguments, context, abort.signal);
+            await client.respond(id, { success: true, contentItems: toolContent(result) });
+        }
+        catch (error) {
+            const reason = error instanceof Error && /^[a-z][a-z0-9_:\-]{0,160}$/.test(error.message)
+                ? error.message
+                : 'procedural_skill_failed';
+            if (error instanceof ProductionSkillFailure) {
+                await client
+                    .respond(id, {
+                    success: false,
+                    contentItems: toolContent({ status: 'failed', reason, reportPath: error.reportPath }),
+                })
+                    .catch(() => undefined);
+                return;
+            }
+            await rejectTool(client, id, reason);
+        }
+        finally {
+            this.active.delete(key);
+            finish();
+        }
+    }
+    async cancel(threadId, turnId) {
+        const pending = [...this.active.values()].filter((item) => (!threadId || item.context.nativeThreadId === threadId) &&
+            (!turnId || item.context.nativeTurnId === turnId));
+        for (const item of pending)
+            item.abort.abort();
+        await Promise.allSettled(pending.map((item) => item.done));
+    }
+}

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/processes/skill-command.js

@@ -0,0 +1,130 @@
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { startLauncherProcess } from '../codex/launcher-client.js';
+import { launcherSocket } from '../workspaces/developer-command.js';
+import { holdDirectoryAccess } from '../server/directory-access.js';
+import { stopBackgroundWriter } from './managed-writes.js';
+/** Structured process invocation under the caller's exclusive directory owner. */
+export async function runSkillCommand(state, input) {
+    if (input.signal.aborted)
+        throw new Error('procedural_skill_cancelled');
+    const writeId = `skill-${randomUUID()}`;
+    const release = await holdDirectoryAccess(state, input.scope, `managed:${writeId}`, 'exclusive');
+    const record = {
+        writeId,
+        workspaceId: state.config.workspaceMode === 'multi'
+            ? `${input.scope.workspaceId}:${input.scope.directoryName ?? 'basic'}`
+            : 'basic',
+        source: 'agent',
+        directoryAccessMode: 'exclusive',
+        startedAt: new Date().toISOString(),
+    };
+    let child;
+    let stopped = true;
+    let timeout = false;
+    let oversized = false;
+    let timer;
+    const abort = () => {
+        void child?.stop().catch(() => undefined);
+    };
+    try {
+        await state.journal.putManagedWrite(record);
+        if (input.signal.aborted)
+            throw new Error('procedural_skill_cancelled');
+        const socketPath = launcherSocket(state);
+        if (socketPath) {
+            stopped = false;
+            child = await startLauncherProcess({
+                socketPath,
+                processId: writeId,
+                runtimeEpoch: state.runtimeEpoch,
+                // Development outputs must remain readable by the workspace control group even when
+                // the private launcher starts with umask 077. Keep arguments literal and this mask local.
+                argv: ['/usr/bin/bash', '-c', 'umask 007; exec "$@"', 'playcraft-skill', ...input.argv],
+                cwd: input.cwd,
+                env: { PYTHONDONTWRITEBYTECODE: '1' },
+            });
+        }
+        else {
+            const local = spawn(input.argv[0], input.argv.slice(1), {
+                cwd: input.cwd,
+                detached: true,
+                stdio: ['pipe', 'pipe', 'pipe'],
+                env: { ...process.env, PYTHONDONTWRITEBYTECODE: '1' },
+            });
+            stopped = !local.pid;
+            child = {
+                pid: local.pid,
+                stdin: local.stdin,
+                stdout: local.stdout,
+                stderr: local.stderr,
+                onExit(listener) {
+                    local.once('error', () => listener(null));
+                    local.once('close', listener);
+                },
+                async stop() {
+                    if (local.pid && !(await stopBackgroundWriter(local.pid)))
+                        throw new Error('procedural_skill_stop_unconfirmed');
+                },
+            };
+        }
+        // Attach exit listeners before asynchronous persistence: short commands can finish immediately.
+        const exit = new Promise((resolve) => child.onExit(resolve));
+        let stdout = '', stderr = '';
+        const collect = (stream, chunk) => {
+            if (stream === 'stdout')
+                stdout += chunk.toString();
+            else
+                stderr += chunk.toString();
+            if (stdout.length > 4 * 1024 * 1024 || stderr.length > 1024 * 1024) {
+                oversized = true;
+                abort();
+            }
+        };
+        child.stdout?.on('data', (chunk) => collect('stdout', chunk));
+        child.stderr?.on('data', (chunk) => collect('stderr', chunk));
+        child.stdin?.on('error', () => undefined);
+        await state.journal.putManagedWrite({ ...record, pid: child.pid });
+        input.signal.addEventListener('abort', abort, { once: true });
+        timer = setTimeout(() => {
+            timeout = true;
+            abort();
+        }, input.timeoutMs ?? 120_000);
+        if (input.signal.aborted)
+            abort();
+        else
+            child.stdin?.end(JSON.stringify(input.input));
+        const code = await exit;
+        await child.stop();
+        stopped = true;
+        if (input.signal.aborted)
+            throw new Error('procedural_skill_cancelled');
+        if (timeout)
+            throw new Error('procedural_skill_timeout');
+        if (oversized)
+            throw new Error('procedural_skill_output_limit');
+        return { stdout, stderr, code };
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        input.signal.removeEventListener('abort', abort);
+        if (child && !stopped) {
+            try {
+                await child.stop();
+                stopped = true;
+            }
+            catch {
+                /* retain the writer claim */
+            }
+        }
+        if (stopped) {
+            await state.journal.putManagedWrite({
+                ...record,
+                pid: child?.pid,
+                stoppedAt: new Date().toISOString(),
+            });
+            release();
+        }
+    }
+}

package/dist/workspace-runtime/serve.js

@@ -33,6 +33,8 @@ 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';
+import { proceduralSkillHandler } from './workspaces/procedural-3d/host.js';
 export async function startWorkspaceRuntime(config, options = {}) {
     process.env.PLAYCRAFT_SKIP_UPDATE_CHECK = '1';
     const negotiated = negotiateProtocol(config);
@@ -54,7 +56,11 @@ export async function startWorkspaceRuntime(config, options = {}) {
         const previousEpoch = journal.storedRuntimeEpoch();
         const previousGroup = journal.executionGroup();
         const previousIdentityMatches = journal.epochsSnapshot().some((epoch) => epoch.runtime_id === config.runtimeId && epoch.generation === config.generation && epoch.runtime_epoch === previousEpoch);
-        await recoverInterruptedInstalls(journal);
+        await recoverInterruptedInstalls(journal, {
+            runtimeEpoch: config.runtimeEpoch, previousRuntimeEpoch: previousEpoch, identityMatches: previousIdentityMatches,
+            ...(config.workspaceMode === 'multi' && process.env.PLAYCRAFT_LAUNCHER_SOCKET
+                ? { launcherSocket: process.env.PLAYCRAFT_LAUNCHER_SOCKET } : {}),
+        });
         await recoverInterruptedPreviews(journal);
         await recoverInterruptedParameterVerifications(journal);
         await recoverInterruptedDeliveries(config.stateDir);
@@ -412,6 +418,8 @@ function defaultNativeAdapter(state) {
             config,
             workspaceUi: true,
             deliveryTools: deliveryToolHandlers(state),
+            scheduledTaskProposals: scheduledTaskProposalHandler(state),
+            productionSkill: proceduralSkillHandler(state),
             ...(multi ? { modelBroker: new WorkspaceModelBroker(state) } : {}),
             ...(multi ? { loadMcpConfig: async (cwd) => {
                     const { workspaceId } = await workspaceContextFromRoot(state, cwd);

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

@@ -1,6 +1,7 @@
 import { assertLeaseFence, hashOperationPayload, isLostThreadError, operationScopeKey, resolveIdempotentAccept, runtimeError, takesWorkspaceDirectory, isTurnControl, } from '@playcraft/common/cloud-workspace/runtime';
 import { canExecuteKind, executeOperation } from './dispatch.js';
 import { buildOperationRecord } from './operation-record.js';
+import { preflightSkillExecution } from '../workspaces/skill-execution-context.js';
 /**
  * Shared operation acceptance: lease fence, idempotency, capability, record creation and
  * execution. HTTP supplies its transport/session checks through `validate`; in-sandbox Agent
@@ -62,7 +63,15 @@ export async function acceptOperationCore(state, parsed, options) {
         if (validation)
             return { rejected: true, refusal: validation };
         const executable = canExecuteKind(state, parsed.kind);
-        const operation = buildOperationRecord(state, parsed, payloadHash, options.leaseFence, executable);
+        let policy;
+        try {
+            policy = await preflightSkillExecution(state, parsed);
+        }
+        catch (error) {
+            return rejected(409, { error: error instanceof Error && /^(?:context_|invalid_composer_context|untrusted_runtime_field)/.test(error.message)
+                    ? error.message : 'context_skill_unavailable' });
+        }
+        const operation = buildOperationRecord(state, parsed, payloadHash, options.leaseFence, executable, policy);
         if (!executable) {
             const saved = await state.journal.putOperation(scopeKey, operation);
             return rejected(409, runtimeError('capability_unavailable', state.journal.destroyed() ? 'runtime_destroyed' : state.nativeError ?? 'adapter_not_started', { operationId: saved.operationId }));

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

@@ -152,7 +152,7 @@ async function gateFor(state) {
                     gate.restore({ ...terminal, owner: `terminal:${terminal.terminalId}`, mode: 'shared' });
             for (const writer of state.journal.listManagedWrites())
                 if (!writer.stoppedAt) {
-                    gate.restore({ ...managedDirectoryScope(state, writer.workspaceId), owner: `managed:${writer.writeId}`, mode: 'shared' });
+                    gate.restore({ ...managedDirectoryScope(state, writer.workspaceId), owner: `managed:${writer.writeId}`, mode: writer.directoryAccessMode ?? 'shared' });
                 }
             const waiting = [];
             for (const barrier of state.journal.directoryBarriers()) {
@@ -237,6 +237,11 @@ export async function withDirectoryOwner(state, scope, owner, action) {
         throw new Error('directory_owner_not_held');
     return context.run({ state, claim: { ...scope, owner, mode: 'exclusive' } }, action);
 }
+/** Verify the existing claim without acquiring or upgrading a lease from a tool callback. */
+export async function assertOperationDirectoryAccess(state, operation, mode) {
+    if (!(await gateFor(state)).permits(`operation:${operation.operationId}`, operation, mode))
+        throw new Error('requires-exclusive-turn');
+}
 export async function withDirectoryWrite(state, scope, action) {
     const inherited = context.getStore();
     const gate = await gateFor(state);
@@ -314,9 +319,11 @@ export async function withOperationDirectoryAccess(state, operation, action, def
         const current = state.journal.getOperationById(operation.operationId);
         if (!current || TERMINAL.has(current.status))
             return;
-        await state.journal.putOperation(deferred.scopeKey, transitionOperation(current, 'uncertain', {
-            error: error instanceof Error && error.message === 'directory_access_cancelled' ? 'cancelled' : 'native_receipt_lost',
+        const cancelled = current.status === 'queued' && error instanceof Error && error.message === 'directory_access_cancelled';
+        await state.journal.putOperation(deferred.scopeKey, transitionOperation(current, cancelled ? 'interrupted' : 'uncertain', {
+            error: cancelled ? 'cancelled' : 'native_receipt_lost',
         }));
+        await state.journal.deleteDeferredDirectoryOperation(operation.operationId);
     }).catch(() => undefined);
     return state.journal.getOperationById(operation.operationId) ?? operation;
 }