@playcraft/cli 0.1.69 → 0.1.71

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

@@ -348,7 +348,7 @@ export function createCodexAppServerAdapter(options) {
                 'skills.include_instructions': false,
                 'skills.config': listing.skills.map(skill => ({ path: skill.path, enabled: false })) };
             const developerInstructions = [
-                `Available workspace skills are fixed by lock ${frozen.declarationHash}.`,
+                `Available workspace skills are fixed by lock ${frozen.lockHash}.`,
                 'Use only the following locked skills. Read its SKILL.md when a skill applies, and resolve supporting files relative to that file. Disabled and unlisted skill directories are not available.',
                 ...frozen.skills.map(skill => JSON.stringify(skill)),
                 ...(frozen.skills.length ? [] : ['(No workspace skills are enabled.)']),
@@ -414,6 +414,26 @@ export function createCodexAppServerAdapter(options) {
             throw new NativePreparationError(unavailable);
         }
     }
+    async function injectPreparedSkillContext(threadId, prepared) {
+        const instructions = asRecord(prepared.params).developerInstructions;
+        if (!prepared.skillsHash || typeof instructions !== 'string')
+            return;
+        if (threads.get(threadId)?.turnActive || [...approvals.values()].some(pending => owningThreadId(pending.threadId) === threadId))
+            throw new NativePreparationError('skills_reload_pending');
+        // Resume configuration does not replace developer messages already in native history.
+        // Keep built-in collaboration policies and update only the platform-owned workspace context.
+        try {
+            await rpc.request('thread/inject_items', { threadId, items: [{ type: 'message', role: 'developer', content: [{
+                                type: 'input_text', text: [
+                                    `Current platform workspace skill lock: ${prepared.skillsHash}. This replaces only earlier platform workspace skill lock and allowlist declarations. Keep all other instructions and permissions in force.`,
+                                    instructions,
+                                ].join('\n\n'),
+                            }] }] }, 30_000);
+        }
+        catch {
+            throw new NativePreparationError('workspace_skills_unavailable');
+        }
+    }
     async function resumePreparedThread(threadId, thread, prepared) {
         const resumed = await rpc.request('thread/resume', {
             threadId, ...prepared.params,
@@ -421,6 +441,7 @@ export function createCodexAppServerAdapter(options) {
         }, 30_000);
         if (resumed.thread?.id !== threadId)
             throw new NativePreparationError('workspace_skills_unavailable');
+        await injectPreparedSkillContext(threadId, prepared);
         thread.loaded = true;
         thread.readOnlyConfirmed = isReadOnlySnapshot(resumed);
         thread.skillsHash = prepared.skillsHash;
@@ -938,6 +959,7 @@ export function createCodexAppServerAdapter(options) {
                 }
                 if (resumedId !== input.threadId)
                     return undefined;
+                await injectPreparedSkillContext(input.threadId, prepared);
                 prepared.activate();
                 threads.set(input.threadId, { sessionId: input.sessionId, cwd: input.cwd, skillsHash: prepared.skillsHash,
                     discoveryHash: prepared.discoveryHash, mcpHash: prepared.mcpHash, contextHash: nativeContextHash(prepared.params), resolvedModel: 'model' in prepared.params ? prepared.params.model : model, modelConfigId: prepared.modelConfigId, reasoningEffort: input.reasoningEffort, permissionMode: input.permissionMode ?? 'auto', canEscalate: sessionCanEscalate(Boolean(options.trustedExecution?.(input.sessionId)), prepared.execution, Boolean(options.fixedExecution)), hasNativeHistory: true, loaded: true });
@@ -1024,6 +1046,8 @@ export function createCodexAppServerAdapter(options) {
                     thread.turnActive = true;
                     thread.scheduledTaskProposalBridge = input.scheduledTaskProposalBridge;
                     thread.uiSnapshot = options.workspaceUi && input.uiSnapshot?.sessionId === input.sessionId ? input.uiSnapshot : undefined;
+                    if (thread.cwd)
+                        options.modelBroker?.markCodexDispatched?.(thread.cwd, input.sessionId, input.clientRequestId);
                     const started = await rpc.sendReserved(requestId, 'turn/start', { threadId: input.threadId, input: [
                             { type: 'text', text: input.text },
                             ...(input.images ?? []).map((path) => ({ type: 'localImage', path })),

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

@@ -1,14 +1,15 @@
 import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
 import { createServer } from 'node:http';
-import { Readable } from 'node:stream';
+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 } 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';
 const credentialSchema = z.object({
     token: z.string().min(1), expiresAt: z.string().datetime(),
     configId: z.string().uuid(), model: z.string().min(1).max(128),
@@ -16,6 +17,7 @@ const credentialSchema = z.object({
     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(),
     }),
 });
 const MAX_MODEL_REQUEST_BYTES = 128 * 1024 * 1024;
@@ -32,11 +34,13 @@ export class WorkspaceModelBroker {
     generation;
     references;
     executionContext;
+    skills;
     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);
     }
     async start() {
         if (this.server)
@@ -81,7 +85,8 @@ 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'), referencesCapability: 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.
@@ -123,6 +128,8 @@ export class WorkspaceModelBroker {
                         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}`,
@@ -137,6 +144,16 @@ export class WorkspaceModelBroker {
             && 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 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)
+            return;
+        entry.codexDispatchedAt = new Date().toISOString();
+        entry.codexDispatchMark = performance.now();
+    }
     async credential(entry, refresh = false) {
         if (!this.valid(entry))
             throw new Error('model_access_denied');
@@ -179,13 +196,16 @@ export class WorkspaceModelBroker {
         return credential;
     }
     async forward(request, response) {
+        const receivedMark = performance.now();
+        const receivedAt = new Date().toISOString();
+        const elapsed = (start) => Math.max(0, Math.round(performance.now() - start));
         const abort = new AbortController();
         this.requests.add(abort);
         let activeRoute;
         const cancel = () => abort.abort();
         response.once('close', cancel);
         try {
-            const match = /^\/([0-9a-f-]{36}(?:\/[0-9a-f]{32})?)\/(responses|generation-provenance|remix-references|execution-context)$/.exec(request.url ?? '');
+            const match = /^\/([0-9a-f-]{36}(?:\/[0-9a-f]{32})?)\/(responses|generation-provenance|remix-references|execution-context|skill-discovery\/(?:match|selection|artifact|activate))$/.exec(request.url ?? '');
             const route = match ? this.routes.get(match[1]) : undefined;
             const selected = route?.selected;
             const entry = selected?.entry;
@@ -193,8 +213,9 @@ export class WorkspaceModelBroker {
             const generationRequest = match?.[2] === 'generation-provenance';
             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 : route.capability}` : '');
+                : 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);
@@ -228,6 +249,16 @@ export class WorkspaceModelBroker {
                 await this.references.forward(request, response, selected.feedback, () => this.valid(entry) && route?.selected === selected);
                 return;
             }
+            if (skillsRequest) {
+                if (!selected?.feedback) {
+                    response.writeHead(403);
+                    response.end();
+                    return;
+                }
+                const action = match[2].slice('skill-discovery/'.length);
+                await this.skills.forward(request, response, selected.feedback, () => this.valid(entry) && route?.selected === selected, action);
+                return;
+            }
             const rejectOversizedBody = () => {
                 response.writeHead(413, { 'content-type': 'application/json', 'cache-control': 'no-store' });
                 response.end(JSON.stringify({ error: { message: 'model_request_too_large',
@@ -242,7 +273,10 @@ export class WorkspaceModelBroker {
             const active = this.sessionRequests.get(route) ?? new Set();
             active.add(abort);
             this.sessionRequests.set(route, active);
+            const credentialMark = performance.now();
             const credential = await this.credential(entry);
+            const credentialWaitMs = elapsed(credentialMark);
+            const requestReadMark = performance.now();
             const chunks = [];
             let size = 0;
             for await (const chunk of request) {
@@ -253,6 +287,7 @@ export class WorkspaceModelBroker {
                 }
                 chunks.push(Buffer.from(chunk));
             }
+            const requestReadMs = elapsed(requestReadMark);
             if (!this.valid(entry))
                 throw new Error('model_access_denied');
             const body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
@@ -280,16 +315,37 @@ export class WorkspaceModelBroker {
                 };
             }
             const expires = setTimeout(cancel, Math.max(0, Date.parse(credential.expiresAt) - Date.now()));
+            const dispatchedAt = new Date().toISOString();
+            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 };
+            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,
                         } : {}) },
                     body: JSON.stringify(body),
                 });
+                broker.responseHeadersAt = new Date().toISOString();
+                broker.proxyResponseHeadersMs = elapsed(dispatchedMark);
+                const reference = upstream.headers.get('x-model-attempt-id');
+                if (reference && z.string().uuid().safeParse(reference).success)
+                    attemptId = reference;
                 if (upstream.status === 401 || upstream.status === 403)
                     entry.credential = undefined;
                 const admissionReason = upstream.headers.get('x-model-admission-reason')?.trim();
@@ -305,12 +361,33 @@ export class WorkspaceModelBroker {
                     ...(retryAfter ? { 'retry-after': retryAfter } : {}),
                 });
                 if (upstream.body)
-                    await pipeline(Readable.fromWeb(upstream.body), response);
+                    await pipeline(Readable.fromWeb(upstream.body), new Transform({
+                        transform(chunk, _encoding, callback) {
+                            if (chunk.length && broker.firstBodyByteAt === undefined) {
+                                broker.firstBodyByteAt = new Date().toISOString();
+                                broker.proxyFirstBodyByteMs = elapsed(dispatchedMark);
+                            }
+                            callback(null, chunk);
+                        },
+                    }), response);
                 else
                     response.end();
+                outcome = 'completed';
+            }
+            catch (error) {
+                outcome = abort.signal.aborted ? 'interrupted' : 'error';
+                throw error;
             }
             finally {
                 clearTimeout(expires);
+                broker.completedAt = new Date().toISOString();
+                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 });
+                }
             }
         }
         catch {
@@ -332,6 +409,16 @@ 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),
+            });
+            await response.body?.cancel();
+        }
+        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)}`;
         const route = this.routes.get(routeKey);

package/dist/workspace-runtime/codex/skill-discovery-broker.js

@@ -0,0 +1,174 @@
+import { realpath } from 'node:fs/promises';
+import { isAbsolute, relative } from 'node:path';
+import { createHash } from 'node:crypto';
+import { z } from 'zod';
+import { remoteSkillMatchRequestSchema, remoteSkillMatchResultSchema, remoteSkillSelectionRequestSchema, remoteSkillArtifactRequestSchema, remoteSkillActivationRequestSchema, parseRemoteSkillSelectionResult, } from '@playcraft/common/project-skills';
+import { platformEndpoint, skillActivationRegistrationSchema } from '@playcraft/common/cloud-workspace/runtime';
+import { workspaceContextFromRoot } from '../workspaces/registry.js';
+import { loadWorkspaceSkillArtifact } from '../workspaces/skill-artifact-loader.js';
+import { verifyLauncherOrigin } from './launcher-client.js';
+import { registerSkillActivationRequest } from '../workspaces/skill-activation-requests.js';
+const requestSchema = z.object({ cwd: z.string().min(1).max(4096), input: z.unknown() }).strict();
+const MAX_METADATA_BYTES = 4 * 1024 * 1024;
+const SELECTION_TTL_MS = 15 * 60_000;
+/** Resolves candidates with control identity; shell capability never authorizes changing the active lock. */
+export class WorkspaceSkillDiscoveryBroker {
+    state;
+    selections = new Map();
+    constructor(state) {
+        this.state = state;
+    }
+    operation(context, valid) {
+        const state = this.state, session = state.journal.getSession(context.sessionId);
+        const operations = state.journal.listOperations().map(item => item.operation).filter(operation => operation.kind === 'session.turn' && operation.sessionId === context.sessionId && operation.clientRequestId === context.clientRequestId
+            && operation.generation === state.config.generation && operation.runtimeEpoch === state.runtimeEpoch
+            && ['dispatched', 'accepted'].includes(operation.status));
+        const operation = operations.length === 1 ? operations[0] : undefined;
+        if (!valid() || context.refsBlocked || state.journal.destroyed() || !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
+            || !['running', 'waiting_for_user'].includes(session.turnStatus ?? ''))
+            throw new Error('skill_discovery_turn_unavailable');
+        return operation;
+    }
+    async current(context, valid) {
+        const operation = this.operation(context, valid);
+        const scope = await workspaceContextFromRoot(this.state, context.cwd);
+        if (scope.workspaceId !== operation.workspaceId || scope.directoryName !== operation.directoryName)
+            throw new Error('skill_discovery_scope_mismatch');
+        this.operation(context, valid);
+        return scope;
+    }
+    selectionKey(context, selectionId) {
+        return JSON.stringify([this.state.config.runtimeId, this.state.config.generation, this.state.runtimeEpoch,
+            context.cwd, context.sessionId, context.clientRequestId, selectionId]);
+    }
+    async forward(request, response, context, valid, action) {
+        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 Error('skill_discovery_turn_unavailable');
+            let text = '';
+            for await (const chunk of request) {
+                text += chunk.toString();
+                if (Buffer.byteLength(text) > 32 * 1024)
+                    throw new Error('skill_discovery_invalid_request');
+            }
+            const parsed = requestSchema.safeParse(JSON.parse(text));
+            if (!parsed.success)
+                throw new Error('skill_discovery_invalid_request');
+            const scope = await this.current(context, valid);
+            const callerCwd = await realpath(parsed.data.cwd);
+            const childPath = relative(context.cwd, callerCwd);
+            if (isAbsolute(childPath) || childPath === '..' || childPath.startsWith('../'))
+                throw new Error('skill_discovery_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 Error('skill_discovery_turn_unavailable');
+            await this.current(context, valid);
+            if (action === 'activate') {
+                const input = remoteSkillActivationRequestSchema.safeParse(parsed.data.input);
+                if (!input.success)
+                    throw new Error('skill_discovery_invalid_request');
+                const operation = this.operation(context, valid);
+                if (context.readOnly || operation.workMode === 'plan' || operation.permissionMode === 'read-only'
+                    || this.state.journal.getSession(context.sessionId)?.permissionMode === 'read-only')
+                    throw new Error('skill_discovery_readonly');
+                const selected = this.selections.get(this.selectionKey(context, input.data.selectionId));
+                if (!selected || selected.expiresAt <= Date.now())
+                    throw new Error('skill_discovery_selection_unavailable');
+                const result = await registerSkillActivationRequest(this.state, {
+                    cwd: context.cwd, sessionId: context.sessionId, clientRequestId: context.clientRequestId, requestedSkillRefs: selected.requestedSkillRefs,
+                }, selected.selection);
+                await this.current(context, valid);
+                return reply(200, skillActivationRegistrationSchema.parse(result));
+            }
+            if (action === 'artifact') {
+                const input = remoteSkillArtifactRequestSchema.safeParse(parsed.data.input);
+                if (!input.success)
+                    throw new Error('skill_discovery_invalid_request');
+                const selection = this.selections.get(this.selectionKey(context, input.data.selectionId));
+                const entry = selection && selection.expiresAt > Date.now() ? selection.entries.find(item => item.entryKey === input.data.entryKey) : undefined;
+                if (!entry)
+                    throw new Error('skill_discovery_selection_unavailable');
+                const archive = await loadWorkspaceSkillArtifact(this.state, scope.workspaceId, entry, scope.directoryName);
+                await this.current(context, valid);
+                selection.expiresAt = Date.now() + SELECTION_TTL_MS;
+                return reply(200, { content: archive.toString('base64'), artifactHash: createHash('sha256').update(archive).digest('hex') });
+            }
+            const query = action === 'match' ? remoteSkillMatchRequestSchema.safeParse(parsed.data.input)
+                : remoteSkillSelectionRequestSchema.safeParse(parsed.data.input);
+            if (!query.success)
+                throw new Error('skill_discovery_invalid_request');
+            const raw = await this.upstream(scope, action, query.data);
+            await this.current(context, valid);
+            if (action === 'match')
+                return reply(200, remoteSkillMatchResultSchema.parse(raw));
+            const value = parseRemoteSkillSelectionResult(raw);
+            const selection = remoteSkillSelectionRequestSchema.parse(query.data);
+            for (const requested of selection.skills) {
+                if (!value.lock.entries.some(entry => entry.revision.kind === 'release' && entry.revision.skillRef === requested.skillRef
+                    && entry.revision.version === requested.version && entry.revision.artifactHash === requested.artifactHash)
+                    || !value.skills.some(item => item.skillVersionId === requested.skillVersionId && item.skillRef === requested.skillRef
+                        && item.version === requested.version && item.artifactHash === requested.artifactHash))
+                    throw new Error('skill_discovery_invalid_response');
+            }
+            for (const [key, cached] of this.selections)
+                if (cached.expiresAt <= Date.now())
+                    this.selections.delete(key);
+            if (this.selections.size >= 64)
+                this.selections.delete(this.selections.keys().next().value);
+            this.selections.set(this.selectionKey(context, value.selectionId), { expiresAt: Date.now() + SELECTION_TTL_MS, entries: value.lock.entries,
+                selection: value, requestedSkillRefs: selection.skills.map(skill => skill.skillRef) });
+            return reply(200, value);
+        }
+        catch (error) {
+            if (response.headersSent) {
+                response.destroy();
+                return;
+            }
+            const code = error instanceof SyntaxError ? 'skill_discovery_invalid_request'
+                : error instanceof Error && /^(?:skill_discovery_|workspace_skills_)[a-z_]+$/.test(error.message)
+                    ? error.message : 'skill_discovery_unavailable';
+            reply(code === 'skill_discovery_invalid_request' ? 400 : code === 'skill_discovery_unavailable' ? 503 : 403, { error: { code } });
+        }
+    }
+    async upstream(scope, action, input) {
+        const config = this.state.config;
+        const response = await fetch(platformEndpoint(config.publicBaseUrl, `/runtime/internal/skill-discovery/${action}`), {
+            method: 'POST', redirect: 'error', signal: AbortSignal.timeout(45_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 }),
+        });
+        if (!response.ok || !response.body) {
+            await response.body?.cancel().catch(() => undefined);
+            throw new Error('skill_discovery_unavailable');
+        }
+        const chunks = [];
+        let bytes = 0;
+        const reader = response.body.getReader();
+        try {
+            while (true) {
+                const chunk = await reader.read();
+                if (chunk.done)
+                    break;
+                bytes += chunk.value.byteLength;
+                if (bytes > MAX_METADATA_BYTES)
+                    throw new Error('skill_discovery_invalid_response');
+                chunks.push(Buffer.from(chunk.value));
+            }
+        }
+        finally {
+            await reader.cancel().catch(() => undefined);
+        }
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+}

package/dist/workspace-runtime/serve.js

@@ -37,6 +37,8 @@ import { platformExportTarget, readPlatformExport, startPlatformExport } from '.
 import { scheduledTaskProposalHandler } from './workspaces/scheduled-task-proposals.js';
 import { executionContextToolHandler } from './workspaces/execution-context.js';
 import { registerLevelEditorRequest, startLevelEditorRequestQueue, stopLevelEditorRequestQueue } from './workspaces/level-editor-requests.js';
+import { startSkillActivationRequestQueue, stopSkillActivationRequestQueue } from './workspaces/skill-activation-requests.js';
+import { recoverInterruptedSkillActivations } from './workspaces/skill-activation-recovery.js';
 import { proceduralSkillHandler } from './workspaces/procedural-3d/host.js';
 import { recoverModelPreviewOperations } from './workspaces/procedural-3d/model-preview-recovery.js';
 import { recoverModelPreparationOperations, stopModelPreparations } from './workspaces/model-preparation.js';
@@ -83,6 +85,7 @@ export async function startWorkspaceRuntime(config, options = {}) {
             executionQueue: Promise.resolve(),
             instanceToken: randomUUID(),
         };
+        await recoverInterruptedSkillActivations(state);
         const recoveredImports = new Map();
         await recoverModelPreviewOperations(state, { identityMatches: previousIdentityMatches,
             runtimeEpoch: config.runtimeEpoch, previousRuntimeEpoch: previousEpoch,
@@ -348,12 +351,14 @@ export async function startWorkspaceRuntime(config, options = {}) {
         });
         const port = await listenOn(server, config.listen.host, config.listen.port);
         startLevelEditorRequestQueue(state);
+        startSkillActivationRequestQueue(state);
         return {
             config: state.config,
             state,
             url: `http://${formatHost(config.listen.host)}:${port}`,
             async close() {
                 stopLevelEditorRequestQueue(state);
+                await stopSkillActivationRequestQueue(state);
                 const serverClosed = closeServer(server);
                 await stopParameterVerifications(state);
                 await stopModelPreparations(state);