@playcraft/cli 0.1.16 → 0.1.17

package/dist/utils/environment-endpoints.js

@@ -9,15 +9,6 @@ function publicBase(value) {
 function append(base, path) {
     return new URL(`${base.toString().replace(/\/+$/, '')}/${path.replace(/^\/+/, '')}`);
 }
-/** Keep the deployment prefix when deriving a control endpoint from its callback address. */
-export function runtimeCallbackEndpoint(callbackUrl, path) {
-    const base = publicBase(callbackUrl);
-    base.pathname = base.pathname.replace(/\/runtime\/(?:callbacks|internal\/events)$/, '');
-    // Older local runtimes used a root-level events callback.
-    if (base.pathname === '/events')
-        base.pathname = '';
-    return append(base, path);
-}
 /** Accept either a public deployment base or its /api endpoint, without duplicating /api. */
 export function businessEndpoint(apiUrl, path) {
     const base = publicBase(apiUrl);

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

@@ -1,9 +1,10 @@
 import { spawn } from 'node:child_process';
 import { createHash, randomUUID } from 'node:crypto';
 import { startLauncherProcess } from './launcher-client.js';
-import { readFile } from 'node:fs/promises';
+import { chmod, mkdtemp, rm } from 'node:fs/promises';
 import { join } from 'node:path';
-import { writePlaycraftCodexConfig } from './config-toml.js';
+import { tmpdir } from 'node:os';
+import { portableCodexConfig, writePortableCodexCatalog } from './config-toml.js';
 import { createJsonRpcStdioClient } from './jsonrpc-stdio.js';
 import { projectNativeThread } from '@playcraft/common/cloud-workspace/runtime';
 import { collectedEvent, NativePreparationError } from './native-adapter.js';
@@ -38,18 +39,6 @@ function spawnCommand(bin) {
     }
     return { command: bin, prefix: [] };
 }
-async function readToken(options) {
-    if (options.token?.trim())
-        return options.token.trim();
-    const fromEnv = process.env.PLAYCRAFT_MODEL_PROXY_TOKEN?.trim() || process.env.OPENAI_API_KEY?.trim() || '';
-    if (fromEnv)
-        return fromEnv;
-    const tokenFile = options.tokenFile || process.env.PLAYCRAFT_MODEL_PROXY_TOKEN_FILE;
-    if (tokenFile) {
-        return (await readFile(tokenFile, 'utf8')).trim();
-    }
-    throw new Error('model_proxy_token_missing');
-}
 export function createCodexAppServerAdapter(options) {
     const launcherSocket = options.launcherSocket || process.env.PLAYCRAFT_LAUNCHER_SOCKET;
     const homeDir = options.homeDir || process.env.PLAYCRAFT_CODEX_HOME ||
@@ -64,6 +53,7 @@ export function createCodexAppServerAdapter(options) {
     let readyFlag = false;
     let closed = false;
     let startPromise;
+    let catalogDirectory;
     let skillsRestartFailed = false;
     let preparationQueue = Promise.resolve();
     let live;
@@ -107,24 +97,25 @@ export function createCodexAppServerAdapter(options) {
         startPromise ??= start();
         await startPromise;
     }
-    async function threadConfig(cwd) {
+    async function threadConfig(cwd, modelConfigId, sessionId) {
         try {
-            return await options.modelBroker?.threadConfig(cwd) ?? {};
+            return await options.modelBroker?.prepareThreadConfig(cwd, modelConfigId, sessionId)
+                ?? { modelConfigId: undefined, activate: () => { } };
         }
         catch (error) {
             const reason = error instanceof Error ? error.message : '';
-            throw new NativePreparationError(['model_config_required', 'model_callback_insecure',
-                'model_credential_scope_mismatch', 'workspace_not_registered'].includes(reason)
+            throw new NativePreparationError(['model_config_required',
+                'model_credential_scope_mismatch', 'model_config_denied', 'workspace_not_registered'].includes(reason)
                 ? reason : 'model_credential_unavailable');
         }
     }
-    async function lockedThreadConfig(cwd) {
-        const modelConfig = await threadConfig(cwd);
+    async function lockedThreadConfig(cwd, selectedConfigId, sessionId) {
+        const { modelConfigId, activate, ...modelConfig } = await threadConfig(cwd, selectedConfigId, sessionId);
         // Single-workspace legacy runners retain their prior behaviour until explicitly adopted.
         if (await readProjectSkillsLockFile(cwd) === null) {
             if (options.config.workspaceMode === 'multi')
                 throw new NativePreparationError('workspace_skills_unavailable');
-            return { params: modelConfig, skillsHash: undefined, discoveryHash: undefined };
+            return { params: modelConfig, modelConfigId, activate, skillsHash: undefined, discoveryHash: undefined };
         }
         try {
             const frozen = await freezeWorkspaceSkills(cwd, join(options.config.stateDir, 'skill-artifacts'), options.loadSkillArtifact ? entry => options.loadSkillArtifact(cwd, entry) : undefined);
@@ -145,13 +136,13 @@ export function createCodexAppServerAdapter(options) {
                 ...(frozen.skills.length ? [] : ['(No workspace skills are enabled.)']),
             ].join('\n');
             const discoveryHash = createHash('sha256').update(JSON.stringify(listing.skills.map(skill => skill.path).sort())).digest('hex');
-            return { params: { ...modelConfig, config, developerInstructions }, skillsHash: frozen.lockHash, discoveryHash };
+            return { params: { ...modelConfig, config, developerInstructions }, modelConfigId, activate, skillsHash: frozen.lockHash, discoveryHash };
         }
         catch {
             throw new NativePreparationError('workspace_skills_unavailable');
         }
     }
-    async function restartForSkills(threadId) {
+    async function restartForSkills(threadId, selectedConfigId) {
         if ([...threads.values()].some(thread => thread.turnActive) || approvals.size)
             throw new NativePreparationError('skills_reload_pending');
         const previous = live;
@@ -182,7 +173,7 @@ export function createCodexAppServerAdapter(options) {
             // Other workspaces resume lazily, so a damaged unrelated lock cannot block this workspace.
             const thread = threads.get(threadId);
             if (thread?.hasNativeHistory && thread.cwd)
-                await resumePreparedThread(threadId, thread, await lockedThreadConfig(thread.cwd));
+                await resumePreparedThread(threadId, thread, await lockedThreadConfig(thread.cwd, selectedConfigId ?? thread.modelConfigId, thread.sessionId));
         }
         catch {
             readyFlag = false;
@@ -209,24 +200,33 @@ export function createCodexAppServerAdapter(options) {
         if (closed)
             throw new Error('codex_not_started');
         await options.modelBroker?.start();
-        const token = options.modelBroker ? 'workspace-broker-managed' : await readToken(options);
         if (closed)
             throw new Error('codex_not_started');
         const bin = options.command || process.env.PLAYCRAFT_CODEX_BIN || (launcherSocket ? '/usr/local/bin/codex' : 'codex');
         const { command, prefix } = spawnCommand(bin);
+        const launchArgs = [...prefix, ...(options.args ?? ['app-server'])];
+        const catalogArgs = launchArgs.at(-1) === 'app-server' ? launchArgs.slice(0, -1) : launchArgs;
+        let catalogPath;
+        try {
+            // Only public model metadata is shared with the development identity.
+            // A private, control-owned directory keeps it outside writable project files.
+            catalogDirectory ??= await mkdtemp(join(tmpdir(), 'playcraft-codex-catalog-'));
+            await chmod(catalogDirectory, 0o755);
+            catalogPath = await writePortableCodexCatalog({ directory: catalogDirectory, command, args: catalogArgs });
+        }
+        catch {
+            throw new NativePreparationError('codex_model_catalog_unavailable');
+        }
+        if (closed)
+            throw new Error('codex_not_started');
         const args = [...prefix, ...(options.args ?? ['app-server'])];
         if (launcherSocket) {
-            // Configuration travels as non-secret overrides: control cannot write dev's home.
+            // Thread model access comes from the broker. These overrides carry no proxy address or token.
             for (const [key, value] of Object.entries({
                 model,
-                model_provider: 'playcraft',
                 approval_policy: 'never',
                 sandbox_mode: 'danger-full-access',
-                'model_providers.playcraft.name': 'PlayCraft Model Proxy',
-                'model_providers.playcraft.base_url': options.config.modelProxyUrl.replace(/\/+$/, ''),
-                'model_providers.playcraft.env_key': 'OPENAI_API_KEY',
-                'model_providers.playcraft.wire_api': 'responses',
-                'model_providers.playcraft.requires_openai_auth': false,
+                ...portableCodexConfig(catalogPath),
             }))
                 args.push('-c', `${key}=${JSON.stringify(value)}`);
             child = await startLauncherProcess({
@@ -237,16 +237,15 @@ export function createCodexAppServerAdapter(options) {
                 // The launcher admits the dev home, not the shared /workspaces root.
                 // Each thread supplies its registered workspace separately.
                 cwd: options.config.workspaceMode === 'multi' ? '/home/playcraft-dev' : options.config.workspaceRoot,
-                env: { CODEX_HOME: homeDir, OPENAI_API_KEY: token },
+                env: { CODEX_HOME: homeDir },
             });
         }
         else {
-            await writePlaycraftCodexConfig({ homeDir, modelProxyUrl: options.config.modelProxyUrl, model });
             if (closed)
                 throw new Error('codex_not_started');
             const local = spawn(command, args, {
                 cwd: options.config.workspaceRoot,
-                env: { ...process.env, ...options.env, CODEX_HOME: homeDir, OPENAI_API_KEY: token, PLAYCRAFT_SKIP_UPDATE_CHECK: '1' },
+                env: { ...process.env, ...options.env, CODEX_HOME: homeDir, PLAYCRAFT_SKIP_UPDATE_CHECK: '1' },
                 stdio: ['pipe', 'pipe', 'pipe'],
             });
             await new Promise((resolve, reject) => { local.once('spawn', resolve); local.once('error', reject); });
@@ -389,18 +388,21 @@ export function createCodexAppServerAdapter(options) {
                 if (!rpc)
                     return false;
                 try {
-                    const prepared = await lockedThreadConfig(input.cwd ?? '');
                     const existing = threads.get(input.threadId);
                     if (existing && existing.sessionId !== input.sessionId)
                         return false;
+                    if (existing?.turnActive)
+                        return false;
+                    const prepared = await lockedThreadConfig(input.cwd ?? '', input.modelConfigId, input.sessionId);
                     if (existing?.needsRecreate)
                         return false;
                     if (existing?.loaded) {
                         if (existing.skillsHash !== prepared.skillsHash || existing.discoveryHash !== prepared.discoveryHash) {
                             if (!existing.hasNativeHistory)
                                 return false;
-                            await restartForSkills(input.threadId);
+                            await restartForSkills(input.threadId, prepared.modelConfigId);
                         }
+                        prepared.activate();
                         return threads.get(input.threadId)?.sessionId === input.sessionId;
                     }
                     const result = await rpc.request('thread/resume', { threadId: input.threadId, cwd: input.cwd,
@@ -408,8 +410,9 @@ export function createCodexAppServerAdapter(options) {
                     const resumedId = result.thread?.id ?? result.threadId;
                     if (resumedId !== input.threadId)
                         return false;
+                    prepared.activate();
                     threads.set(input.threadId, { sessionId: input.sessionId, cwd: input.cwd, skillsHash: prepared.skillsHash,
-                        discoveryHash: prepared.discoveryHash, hasNativeHistory: true, loaded: true });
+                        discoveryHash: prepared.discoveryHash, modelConfigId: prepared.modelConfigId, hasNativeHistory: true, loaded: true });
                     return true;
                 }
                 catch {
@@ -452,7 +455,7 @@ export function createCodexAppServerAdapter(options) {
                 await ensureStarted();
                 if (!rpc)
                     throw new Error('codex_not_started');
-                const prepared = await lockedThreadConfig(input.cwd);
+                const prepared = await lockedThreadConfig(input.cwd, input.modelConfigId, input.sessionId);
                 const result = await rpc.request('thread/start', {
                     cwd: input.cwd,
                     model,
@@ -461,9 +464,10 @@ export function createCodexAppServerAdapter(options) {
                 const threadId = result.thread?.id;
                 if (!threadId)
                     throw new Error('native_receipt_lost');
+                prepared.activate();
                 threads.set(threadId, { sessionId: input.sessionId, cwd: input.cwd, skillsHash: prepared.skillsHash,
-                    discoveryHash: prepared.discoveryHash, hasNativeHistory: false, loaded: true });
-                return { threadId };
+                    discoveryHash: prepared.discoveryHash, modelConfigId: prepared.modelConfigId, hasNativeHistory: false, loaded: true });
+                return { threadId, modelConfigId: prepared.modelConfigId };
             });
         },
         async startTurn(input) {
@@ -475,18 +479,26 @@ export function createCodexAppServerAdapter(options) {
                     return { outcome: 'failed', error: 'unknown_thread' };
                 }
                 const thread = threads.get(input.threadId);
+                if (thread.turnActive)
+                    return { outcome: 'failed', error: 'turn_already_active' };
                 if (thread.needsRecreate)
                     return { outcome: 'failed', error: 'workspace_skills_changed' };
-                if (thread.skillsHash && thread.cwd) {
+                let selectedModel;
+                let modelConfigId = thread.modelConfigId;
+                let activateModel = () => { };
+                if (thread.cwd) {
                     try {
-                        const prepared = await lockedThreadConfig(thread.cwd);
+                        const prepared = await lockedThreadConfig(thread.cwd, input.modelConfigId ?? thread.modelConfigId, input.sessionId);
+                        selectedModel = 'model' in prepared.params ? prepared.params.model : undefined;
+                        modelConfigId = prepared.modelConfigId;
+                        activateModel = prepared.activate;
                         // Codex does not persist an empty thread rollout until its first turn.
-                        if (!thread.hasNativeHistory) {
+                        if (thread.skillsHash && !thread.hasNativeHistory) {
                             if (prepared.skillsHash !== thread.skillsHash || prepared.discoveryHash !== thread.discoveryHash)
                                 return { outcome: 'failed', error: 'workspace_skills_changed' };
                         }
-                        else if (prepared.skillsHash !== thread.skillsHash || prepared.discoveryHash !== thread.discoveryHash) {
-                            await restartForSkills(input.threadId);
+                        else if (thread.skillsHash && (prepared.skillsHash !== thread.skillsHash || prepared.discoveryHash !== thread.discoveryHash)) {
+                            await restartForSkills(input.threadId, prepared.modelConfigId);
                         }
                         if (!thread.loaded)
                             await resumePreparedThread(input.threadId, thread, prepared);
@@ -498,7 +510,9 @@ export function createCodexAppServerAdapter(options) {
                     }
                 }
                 const requestId = rpc.reserveRequest();
-                await input.persistReservation({ nativeRequestId: String(requestId) });
+                await input.persistReservation({ nativeRequestId: String(requestId), modelConfigId });
+                activateModel();
+                thread.modelConfigId = modelConfigId;
                 if (input.simulateLostReceipt)
                     return { outcome: 'uncertain', threadId: input.threadId };
                 try {
@@ -506,7 +520,7 @@ export function createCodexAppServerAdapter(options) {
                     const started = await rpc.sendReserved(requestId, 'turn/start', { threadId: input.threadId, input: [
                             { type: 'text', text: input.text },
                             ...(input.images ?? []).map((path) => ({ type: 'localImage', path })),
-                        ] }, turnTimeoutMs);
+                        ], ...(selectedModel ? { model: selectedModel } : {}) }, turnTimeoutMs);
                     const turnId = started.turn?.id;
                     if (!turnId)
                         return { outcome: 'uncertain', threadId: input.threadId };
@@ -514,9 +528,10 @@ export function createCodexAppServerAdapter(options) {
                     if (acceptedThread) {
                         acceptedThread.lastTurnId = turnId;
                         acceptedThread.hasNativeHistory = true;
+                        acceptedThread.modelConfigId = modelConfigId;
                         acceptedThread.turnActive = acceptedThread.lastCompletedTurnId !== turnId;
                     }
-                    return { outcome: 'accepted', threadId: input.threadId, turnId };
+                    return { outcome: 'accepted', threadId: input.threadId, turnId, modelConfigId };
                 }
                 catch {
                     return { outcome: 'uncertain', threadId: input.threadId };
@@ -534,6 +549,9 @@ export function createCodexAppServerAdapter(options) {
                 return { outcome: 'uncertain' };
             try {
                 await rpc.request('turn/interrupt', { threadId: input.threadId, turnId });
+                const cwd = threads.get(input.threadId)?.cwd;
+                if (cwd)
+                    options.modelBroker?.cancelSession(cwd, input.sessionId);
             }
             catch {
                 return { outcome: 'uncertain', turnId };
@@ -573,6 +591,8 @@ export function createCodexAppServerAdapter(options) {
             child = undefined;
             live = undefined;
             await options.modelBroker?.close();
+            if (catalogDirectory)
+                await rm(catalogDirectory, { recursive: true, force: true });
         },
     };
 }

package/dist/workspace-runtime/codex/config-toml.js

@@ -1,8 +1,90 @@
+import { execFile } from 'node:child_process';
+import { createHash } from 'node:crypto';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { promisify } from 'node:util';
+const exec = promisify(execFile);
 function tomlString(value) {
     return JSON.stringify(value);
 }
+/** Keep workspace turns portable between native Responses and function-tool conversion. */
+export function portableCodexConfig(catalogPath) {
+    return {
+        web_search: 'disabled',
+        'features.multi_agent': false,
+        'features.goals': false,
+        'features.apps': false,
+        'features.plugins': false,
+        'features.code_mode': false,
+        'features.code_mode_host': false,
+        'features.code_mode_only': false,
+        model_reasoning_summary: 'none',
+        ...(catalogPath ? { model_catalog_json: catalogPath } : {}),
+    };
+}
+/** Retain real model identities and limits while declaring this gateway's portable tools. */
+export function portableCodexCatalog(raw) {
+    if (!raw ||
+        typeof raw !== 'object' ||
+        Array.isArray(raw) ||
+        !Array.isArray(raw.models)) {
+        throw new Error('codex_model_catalog_invalid');
+    }
+    const catalog = raw;
+    const models = catalog.models.map((value) => {
+        if (!value ||
+            typeof value !== 'object' ||
+            Array.isArray(value) ||
+            typeof value.slug !== 'string') {
+            throw new Error('codex_model_catalog_invalid');
+        }
+        return {
+            ...value,
+            tool_mode: null,
+            use_responses_lite: false,
+            apply_patch_tool_type: null,
+            multi_agent_version: null,
+            supports_search_tool: false,
+            experimental_supported_tools: [],
+            default_reasoning_level: null,
+            supported_reasoning_levels: [],
+        };
+    });
+    return { ...catalog, models };
+}
+/** The installed binary supplies its own schema; unsupported binaries fail before inference. */
+export async function writePortableCodexCatalog(input) {
+    const command = input.command || process.env.PLAYCRAFT_CODEX_BIN || 'codex';
+    const prefix = input.args ?? [];
+    let body;
+    let version;
+    try {
+        const bundled = await exec(command, [...prefix, 'debug', 'models', '--bundled'], {
+            encoding: 'utf8',
+            timeout: 10_000,
+            maxBuffer: 16 * 1024 * 1024,
+        });
+        const metadata = await exec(command, [...prefix, '--version'], {
+            encoding: 'utf8',
+            timeout: 10_000,
+            maxBuffer: 64 * 1024,
+        });
+        version = metadata.stdout.trim();
+        body = JSON.stringify(portableCodexCatalog(JSON.parse(bundled.stdout)));
+    }
+    catch {
+        // Continuing with an unverified catalog can silently remove every coding tool.
+        throw new Error('codex_model_catalog_unavailable');
+    }
+    await mkdir(input.directory, { recursive: true });
+    const path = join(input.directory, 'portable-models.json');
+    await writeFile(path, body, { encoding: 'utf8', mode: 0o644 });
+    await writeFile(join(input.directory, 'portable-models.version.json'), JSON.stringify({
+        version,
+        sha256: createHash('sha256').update(body).digest('hex'),
+    }), { encoding: 'utf8', mode: 0o644 });
+    return path;
+}
 export async function writePlaycraftCodexConfig(input) {
     await mkdir(input.homeDir, { recursive: true, mode: 0o700 });
     const path = join(input.homeDir, 'config.toml');
@@ -11,6 +93,7 @@ export async function writePlaycraftCodexConfig(input) {
         'model_provider = "playcraft"',
         'approval_policy = "never"',
         'sandbox_mode = "danger-full-access"',
+        ...Object.entries(portableCodexConfig(input.catalogPath)).map(([key, value]) => `${key} = ${JSON.stringify(value)}`),
         '',
         '[model_providers.playcraft]',
         'name = "PlayCraft Model Proxy"',

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

@@ -1,11 +1,11 @@
-import { randomBytes, timingSafeEqual } from 'node:crypto';
+import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
 import { createServer } from 'node:http';
 import { Readable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
 import { basename } from 'node:path';
 import { z } from 'zod';
 import { workspaceRoot } from '../workspaces/registry.js';
-import { runtimeCallbackEndpoint } from '../../utils/environment-endpoints.js';
+import { PLATFORM_ROUTES, modelResponsesPath, platformEndpoint } from '@playcraft/common/cloud-workspace/runtime';
 const credentialSchema = z.object({
     token: z.string().min(1), expiresAt: z.string().datetime(),
     configId: z.string().uuid(), model: z.string().min(1).max(128),
@@ -20,8 +20,10 @@ export class WorkspaceModelBroker {
     server;
     baseUrl = '';
     entries = new Map();
+    routes = new Map();
     pending = new Map();
     requests = new Set();
+    sessionRequests = new Map();
     constructor(state) {
         this.state = state;
     }
@@ -41,24 +43,47 @@ export class WorkspaceModelBroker {
             throw new Error('model_broker_unavailable');
         this.baseUrl = `http://127.0.0.1:${address.port}`;
     }
-    async threadConfig(cwd) {
+    async threadConfig(cwd, modelConfigId, sessionId) {
+        const { activate, ...settings } = await this.prepareThreadConfig(cwd, modelConfigId, sessionId);
+        activate();
+        return settings;
+    }
+    async prepareThreadConfig(cwd, modelConfigId, sessionId) {
         const workspaceId = basename(cwd);
         if (!this.server || await workspaceRoot(this.state, workspaceId) !== cwd)
             throw new Error('workspace_not_registered');
-        let entry = this.entries.get(workspaceId);
+        if (modelConfigId !== undefined && !z.string().uuid().safeParse(modelConfigId).success)
+            throw new Error('model_config_denied');
+        const routeKey = sessionId ? `${workspaceId}/${createHash('sha256').update(sessionId).digest('hex').slice(0, 32)}` : workspaceId;
+        let route = this.routes.get(routeKey);
+        const selected = modelConfigId ?? (route?.epoch === this.state.runtimeEpoch ? route.selected?.entry.modelConfigId : undefined);
+        const cacheKey = `${workspaceId}:${selected ?? 'default'}`;
+        let entry = this.entries.get(cacheKey) ?? [...this.entries.values()].find(item => item.workspaceId === workspaceId && item.epoch === this.state.runtimeEpoch && item.modelConfigId === selected);
         if (!entry || entry.epoch !== this.state.runtimeEpoch) {
-            entry = { workspaceId, epoch: this.state.runtimeEpoch, capability: randomBytes(32).toString('base64url') };
-            this.entries.set(workspaceId, entry);
+            entry = { workspaceId, epoch: this.state.runtimeEpoch, cacheKey, modelConfigId: selected };
+            this.entries.set(cacheKey, entry);
+        }
+        // Resolve current model metadata and permission at every native turn boundary.
+        const credential = await this.credential(entry, true);
+        if (!route || route.epoch !== this.state.runtimeEpoch) {
+            route = { workspaceId, epoch: this.state.runtimeEpoch, capability: randomBytes(32).toString('base64url') };
+            this.routes.set(routeKey, route);
         }
-        const credential = await this.credential(entry);
+        // Each session pins its prepared model; shared credential renewal cannot change an active turn.
         return {
+            activate: () => {
+                if (!this.valid(entry) || this.routes.get(routeKey) !== route)
+                    throw new Error('model_access_denied');
+                route.selected = { entry, model: credential.model };
+            },
             model: credential.model,
+            modelConfigId: credential.configId,
             modelProvider: 'playcraft_workspace',
             config: {
                 'model_providers.playcraft_workspace': {
-                    name: 'PlayCraft Workspace', base_url: `${this.baseUrl}/${workspaceId}`,
+                    name: 'PlayCraft Workspace', base_url: `${this.baseUrl}/${routeKey}`,
                     wire_api: 'responses', requires_openai_auth: false,
-                    http_headers: { Authorization: `Bearer ${entry.capability}` },
+                    http_headers: { Authorization: `Bearer ${route.capability}` },
                 },
             },
         };
@@ -66,12 +91,12 @@ export class WorkspaceModelBroker {
     valid(entry) {
         return Boolean(this.server && !this.state.journal.destroyed()
             && this.state.runtimeEpoch === entry.epoch && this.state.journal.getWorkspace(entry.workspaceId)
-            && this.entries.get(entry.workspaceId) === entry);
+            && this.entries.get(entry.cacheKey) === entry);
     }
-    async credential(entry) {
+    async credential(entry, refresh = false) {
         if (!this.valid(entry))
             throw new Error('model_access_denied');
-        if (entry.credential && Date.parse(entry.credential.expiresAt) > Date.now() + 60_000)
+        if (!refresh && entry.credential && Date.parse(entry.credential.expiresAt) > Date.now() + 60_000)
             return entry.credential;
         let pending = this.pending.get(entry);
         if (!pending) {
@@ -82,46 +107,54 @@ export class WorkspaceModelBroker {
     }
     async renew(entry) {
         const config = this.state.config;
-        const endpoint = runtimeCallbackEndpoint(config.callbackUrl, '/runtime/internal/model-credentials');
-        if (endpoint.protocol !== 'https:' && !(endpoint.protocol === 'http:'
-            && ['127.0.0.1', 'localhost', '[::1]'].includes(endpoint.hostname)))
-            throw new Error('model_callback_insecure');
+        const endpoint = platformEndpoint(config.publicBaseUrl, PLATFORM_ROUTES.modelCredentials);
         const response = await fetch(endpoint, {
             method: 'POST', redirect: 'error', signal: AbortSignal.timeout(10_000),
             headers: { authorization: `Bearer ${config.controlToken}`, 'content-type': 'application/json', 'playcraft-env': config.environment },
             body: JSON.stringify({ runtimeId: config.runtimeId, generation: config.generation,
-                runtimeEpoch: entry.epoch, workspaceId: entry.workspaceId }),
+                runtimeEpoch: entry.epoch, workspaceId: entry.workspaceId,
+                ...(entry.modelConfigId ? { modelConfigId: entry.modelConfigId } : {}) }),
         });
         if (!response.ok) {
             const error = await response.json().catch(() => ({}));
-            throw new Error(error.reason === 'model_config_required' ? 'model_config_required' : 'model_credential_unavailable');
+            throw new Error(['model_config_required', 'model_config_denied'].includes(error.reason ?? '') ? error.reason : 'model_credential_unavailable');
         }
         const credential = credentialSchema.parse(await response.json());
         const claims = credential.claims;
         if (!this.valid(entry) || claims.workspaceId !== entry.workspaceId || claims.runtimeId !== config.runtimeId
             || claims.userId !== config.userId || claims.environment !== config.environment
             || claims.generation !== config.generation || claims.runtimeEpoch !== entry.epoch
+            || (entry.modelConfigId !== undefined && credential.configId !== entry.modelConfigId)
             || Date.parse(credential.expiresAt) <= Date.now() + 1000)
             throw new Error('model_credential_scope_mismatch');
+        entry.modelConfigId = credential.configId;
         entry.credential = credential;
         return credential;
     }
     async forward(request, response) {
         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})\/responses$/.exec(request.url ?? '');
-            const entry = match && this.entries.get(match[1]);
+            const match = /^\/([0-9a-f-]{36}(?:\/[0-9a-f]{32})?)\/responses$/.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 expected = Buffer.from(entry ? `Bearer ${entry.capability}` : '');
+            const expected = Buffer.from(route ? `Bearer ${route.capability}` : '');
             if (request.method !== 'POST' || !entry || !expected.length || presented.length !== expected.length
                 || !timingSafeEqual(presented, expected) || !this.valid(entry)) {
                 response.writeHead(403);
                 response.end();
                 return;
             }
+            activeRoute = route;
+            const active = this.sessionRequests.get(route) ?? new Set();
+            active.add(abort);
+            this.sessionRequests.set(route, active);
+            const credential = await this.credential(entry);
             const chunks = [];
             let size = 0;
             for await (const chunk of request) {
@@ -133,15 +166,22 @@ export class WorkspaceModelBroker {
                 }
                 chunks.push(Buffer.from(chunk));
             }
-            const credential = await this.credential(entry);
             if (!this.valid(entry))
                 throw new Error('model_access_denied');
+            const body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+            if (!body || typeof body !== 'object' || Array.isArray(body)) {
+                response.writeHead(400);
+                response.end();
+                return;
+            }
+            // The browser selects a configuration, never an arbitrary billable upstream model.
+            body.model = selected.model;
             const expires = setTimeout(cancel, Math.max(0, Date.parse(credential.expiresAt) - Date.now()));
             try {
-                const upstream = await fetch(`${this.state.config.modelProxyUrl.replace(/\/+$/, '')}/v1/${credential.configId}/responses`, {
+                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' },
-                    body: Buffer.concat(chunks),
+                    body: JSON.stringify(body),
                 });
                 if (upstream.status === 401 || upstream.status === 403)
                     entry.credential = undefined;
@@ -168,12 +208,27 @@ export class WorkspaceModelBroker {
         finally {
             response.off('close', cancel);
             this.requests.delete(abort);
+            if (activeRoute) {
+                const active = this.sessionRequests.get(activeRoute);
+                active?.delete(abort);
+                if (!active?.size)
+                    this.sessionRequests.delete(activeRoute);
+            }
         }
     }
+    cancelSession(cwd, sessionId) {
+        const routeKey = `${basename(cwd)}/${createHash('sha256').update(sessionId).digest('hex').slice(0, 32)}`;
+        const route = this.routes.get(routeKey);
+        if (route)
+            for (const request of this.sessionRequests.get(route) ?? [])
+                request.abort();
+    }
     async close() {
         const server = this.server;
         this.server = undefined;
         this.entries.clear();
+        this.routes.clear();
+        this.sessionRequests.clear();
         for (const request of this.requests)
             request.abort();
         if (server) {

package/dist/workspace-runtime/previews/publish.js

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 import { spawn } from 'node:child_process';
-import { runtimeCallbackEndpoint } from '../../utils/environment-endpoints.js';
+import { platformEndpoint } from '@playcraft/common/cloud-workspace/runtime';
 import { constants } from 'node:fs';
 import { lstat, open, readdir, rm } from 'node:fs/promises';
 import { join } from 'node:path';
@@ -223,10 +223,7 @@ function git(cwd, args) {
     });
 }
 async function postControl(state, path, body) {
-    const endpoint = runtimeCallbackEndpoint(state.config.callbackUrl, path);
-    const local = endpoint.protocol === 'http:' && ['127.0.0.1', 'localhost', '[::1]'].includes(endpoint.hostname);
-    if (endpoint.protocol !== 'https:' && !local)
-        throw new PreviewFailure('preview_upload_failed');
+    const endpoint = platformEndpoint(state.config.publicBaseUrl, path);
     const response = await fetch(endpoint, {
         method: 'POST',
         redirect: 'error',

package/dist/workspace-runtime/serve.js

@@ -96,7 +96,7 @@ export async function startWorkspaceRuntime(config, options = {}) {
         }
         catch (error) {
             const code = error instanceof Error ? error.message : '';
-            state.nativeError = code === 'model_proxy_token_missing' ? code : 'codex_start_failed';
+            state.nativeError = code === 'codex_model_catalog_unavailable' ? code : 'codex_start_failed';
             console.error(`[workspace-runtime] ${state.nativeError}`);
         }
         const server = createServer((request, response) => {
@@ -180,11 +180,15 @@ function defaultNativeAdapter(state) {
     const config = state.config;
     if (process.env.PLAYCRAFT_NATIVE_ADAPTER === 'loopback')
         return createLoopbackNativeAdapter();
-    const managed = config.workspaceMode === 'multi' && Boolean(process.env.PLAYCRAFT_LAUNCHER_SOCKET);
-    if (process.env.PLAYCRAFT_NATIVE_ADAPTER === 'codex'
-        || (!process.env.PLAYCRAFT_NATIVE_ADAPTER && managed)) {
-        return createCodexAppServerAdapter({ config,
-            ...(managed ? { modelBroker: new WorkspaceModelBroker(state) } : {}),
+    const hasLauncher = Boolean(process.env.PLAYCRAFT_LAUNCHER_SOCKET);
+    const multi = config.workspaceMode === 'multi';
+    if (process.env.PLAYCRAFT_NATIVE_ADAPTER === 'codex' && !multi && !hasLauncher) {
+        throw new Error('codex_requires_managed_launcher');
+    }
+    if (process.env.PLAYCRAFT_NATIVE_ADAPTER === 'codex' || (multi && hasLauncher)) {
+        return createCodexAppServerAdapter({
+            config,
+            ...(multi ? { modelBroker: new WorkspaceModelBroker(state) } : {}),
             loadSkillArtifact: async (cwd, entry) => {
                 const id = basename(cwd);
                 if (await workspaceRoot(state, id) !== cwd)

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

@@ -0,0 +1,201 @@
+import { randomUUID } from 'node:crypto';
+import { z } from 'zod';
+import { PLATFORM_ROUTES, modelConnectivityPath, platformEndpoint, } from '@playcraft/common/cloud-workspace/runtime';
+const PROBE_TIMEOUT_MS = 4_000;
+const CACHE_MS = 15_000;
+const CREDENTIAL_RENEW_BEFORE_MS = 30_000;
+const MAX_RESPONSE_BYTES = 16 * 1024;
+const credentialSchema = z.object({
+    token: z.string().min(1), expiresAt: z.string().datetime(),
+    configId: z.string().uuid(), model: z.string().min(1).max(128),
+    claims: z.object({
+        environment: z.string(), userId: z.string(), workspaceId: z.string(), runtimeId: z.string(),
+        generation: z.number().int(), runtimeEpoch: z.number().int(),
+    }),
+});
+const caches = new WeakMap();
+const ready = () => ({ status: 'ready' });
+const unavailable = (reason) => ({ status: 'unavailable', reason });
+function snapshot(state, workspaceId) {
+    let nativeReady = false;
+    try {
+        nativeReady = Boolean(state.native?.ready());
+    }
+    catch { /* A failed adapter stays unavailable. */ }
+    const { publicBaseUrl, controlToken, environment, userId, runtimeId, generation } = state.config;
+    return { publicBaseUrl, controlToken, environment, userId, runtimeId, generation,
+        runtimeEpoch: state.runtimeEpoch, workspaceId, nativeReady, destroyed: state.journal.destroyed(),
+        registered: state.config.workspaceMode !== 'multi' || Boolean(state.journal.getWorkspace(workspaceId)) };
+}
+function safeEndpoint(value) {
+    const url = new URL(value);
+    if (url.username || url.password || url.search || url.hash || /[%\\]/.test(url.pathname)
+        || (url.protocol !== 'https:' && !(url.protocol === 'http:' && ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname)))) {
+        throw new Error('insecure_endpoint');
+    }
+    return url;
+}
+async function responseJson(response) {
+    const reader = response.body?.getReader();
+    if (!reader)
+        throw new Error('invalid_probe_response');
+    const chunks = [];
+    let size = 0;
+    try {
+        while (true) {
+            const item = await reader.read();
+            if (item.done)
+                break;
+            size += item.value.byteLength;
+            if (size > MAX_RESPONSE_BYTES)
+                throw new Error('invalid_probe_response');
+            chunks.push(item.value);
+        }
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+    finally {
+        await reader.cancel().catch(() => undefined);
+        reader.releaseLock();
+    }
+}
+async function requestProbe(target, init, credentials = false) {
+    const signal = AbortSignal.timeout(PROBE_TIMEOUT_MS);
+    try {
+        const response = await fetch(target, { ...init, redirect: 'error', signal });
+        if (!response.ok) {
+            const offline = response.headers.has('ngrok-error-code');
+            const rejected = response.status === 401 || response.status === 403;
+            let reason = rejected ? 'endpoint_rejected' : offline ? 'endpoint_offline' : 'endpoint_unreachable';
+            if (credentials && !offline && !rejected) {
+                const body = await responseJson(response).catch(() => undefined);
+                if (signal.aborted)
+                    return { state: unavailable('endpoint_timeout') };
+                if (body && typeof body === 'object' && 'reason' in body && body.reason === 'model_config_required')
+                    reason = 'model_config_required';
+            }
+            else
+                await response.body?.cancel().catch(() => undefined);
+            return { state: unavailable(reason) };
+        }
+        let body;
+        try {
+            body = await responseJson(response);
+        }
+        catch {
+            return { state: unavailable(signal.aborted ? 'endpoint_timeout' : 'invalid_probe_response') };
+        }
+        return { state: ready(), body };
+    }
+    catch {
+        return { state: unavailable(signal.aborted ? 'endpoint_timeout' : 'endpoint_unreachable') };
+    }
+}
+function echoMatches(body, expected) {
+    return Boolean(body && typeof body === 'object' && !Array.isArray(body)
+        && Object.entries(expected).every(([key, value]) => body[key] === value));
+}
+function scope(config) {
+    return { runtimeId: config.runtimeId, environment: config.environment, workspaceId: config.workspaceId,
+        generation: config.generation, runtimeEpoch: config.runtimeEpoch };
+}
+function entrance(config, route) {
+    return safeEndpoint(platformEndpoint(config.publicBaseUrl, route));
+}
+async function callbackProbe(config) {
+    if (!config.publicBaseUrl)
+        return unavailable('endpoint_not_configured');
+    let endpoint;
+    try {
+        endpoint = entrance(config, PLATFORM_ROUTES.eventsProbe);
+    }
+    catch {
+        return unavailable('insecure_endpoint');
+    }
+    const nonce = randomUUID();
+    const response = await requestProbe(endpoint, {
+        method: 'POST', headers: { authorization: `Bearer ${config.controlToken}`, 'content-type': 'application/json', 'playcraft-env': config.environment },
+        body: JSON.stringify({ runtimeId: config.runtimeId, generation: config.generation,
+            runtimeEpoch: config.runtimeEpoch, workspaceId: config.workspaceId, nonce }),
+    });
+    if (response.state.status !== 'ready')
+        return response.state;
+    return echoMatches(response.body, { service: 'playcraft-runtime', ...scope(config), nonce }) ? ready() : unavailable('invalid_probe_response');
+}
+async function modelProxyProbe(config, entry) {
+    if (!config.publicBaseUrl)
+        return unavailable('endpoint_not_configured');
+    let credentialEndpoint;
+    try {
+        credentialEndpoint = entrance(config, PLATFORM_ROUTES.modelCredentials);
+        entrance(config, PLATFORM_ROUTES.modelProxy);
+    }
+    catch {
+        return unavailable('insecure_endpoint');
+    }
+    if (entry.credential && Date.parse(entry.credential.expiresAt) <= Date.now() + CREDENTIAL_RENEW_BEFORE_MS)
+        entry.credential = undefined;
+    if (!entry.credential) {
+        const response = await requestProbe(credentialEndpoint, {
+            method: 'POST', headers: { authorization: `Bearer ${config.controlToken}`, 'content-type': 'application/json', 'playcraft-env': config.environment },
+            body: JSON.stringify({ runtimeId: config.runtimeId, generation: config.generation, runtimeEpoch: config.runtimeEpoch, workspaceId: config.workspaceId }),
+        }, true);
+        if (response.state.status !== 'ready')
+            return response.state;
+        const parsed = credentialSchema.safeParse(response.body);
+        if (!parsed.success || !echoMatches(parsed.data.claims, { ...scope(config), userId: config.userId })
+            || Date.parse(parsed.data.expiresAt) <= Date.now() + 1_000)
+            return unavailable('invalid_probe_response');
+        entry.credential = parsed.data;
+    }
+    const credential = entry.credential;
+    const nonce = randomUUID();
+    const target = new URL(platformEndpoint(config.publicBaseUrl, modelConnectivityPath(credential.configId)));
+    target.searchParams.set('nonce', nonce);
+    const result = await requestProbe(target, { method: 'GET', headers: { authorization: `Bearer ${credential.token}`, 'playcraft-env': config.environment } });
+    if (result.state.reason === 'endpoint_rejected')
+        entry.credential = undefined;
+    if (result.state.status !== 'ready')
+        return result.state;
+    return echoMatches(result.body, { service: 'playcraft-model-proxy', ...scope(config), configId: credential.configId, nonce })
+        ? ready() : unavailable('invalid_probe_response');
+}
+async function probe(config, entry) {
+    if (config.destroyed || !config.registered) {
+        const state = unavailable(config.destroyed ? 'runtime_destroyed' : 'workspace_not_registered');
+        return { ...scope(config), checkedAt: new Date().toISOString(), callback: state, modelProxy: state, conversation: state };
+    }
+    const [callback, modelProxy] = await Promise.all([callbackProbe(config), modelProxyProbe(config, entry)]);
+    const conversation = !config.nativeReady ? unavailable('adapter_not_started')
+        : callback.status !== 'ready' ? unavailable('callback_unavailable')
+            : modelProxy.status !== 'ready' ? unavailable('model_proxy_unavailable') : ready();
+    return { ...scope(config), checkedAt: new Date().toISOString(), callback, modelProxy, conversation };
+}
+/** Check the configured services without starting a thread or generating a model response. */
+export function probeRuntimeConnectivity(state, workspaceId) {
+    const config = snapshot(state, workspaceId);
+    const key = JSON.stringify(config);
+    let cache = caches.get(state);
+    if (!cache) {
+        cache = new Map();
+        caches.set(state, cache);
+    }
+    const previous = cache.get(workspaceId);
+    if (previous?.key === key) {
+        if (previous.pending)
+            return previous.pending;
+        if (previous.value && previous.expiresAt > Date.now())
+            return Promise.resolve(previous.value);
+    }
+    const entry = previous?.key === key ? previous : { key, expiresAt: 0 };
+    cache.set(workspaceId, entry);
+    if (cache.size > 256)
+        cache.delete(cache.keys().next().value);
+    entry.pending = probe(config, entry).then((value) => {
+        if (JSON.stringify(snapshot(state, workspaceId)) !== key)
+            return probeRuntimeConnectivity(state, workspaceId);
+        entry.value = value;
+        entry.expiresAt = Date.now() + CACHE_MS;
+        return value;
+    }).finally(() => { entry.pending = undefined; });
+    return entry.pending;
+}

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

@@ -2,7 +2,8 @@ import { withObservedFile } from '../workspaces/revisions.js';
 import { revisionScope, workspaceRoot, workspaceSessions } from '../workspaces/registry.js';
 import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { checkpointRecordSchema, fileWritePayloadSchema, gitCommitPayloadSchema, gitPathsPayloadSchema, gitPushPayloadSchema, parameterPatchPayloadSchema, terminalCreatePayloadSchema, terminalProcessIdentity, transitionOperation, workspaceSkillsUpdatePayloadSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { z } from 'zod';
+import { PLATFORM_ROUTES, platformEndpoint, checkpointRecordSchema, fileWritePayloadSchema, gitCommitPayloadSchema, gitPathsPayloadSchema, gitPushPayloadSchema, parameterPatchPayloadSchema, terminalCreatePayloadSchema, terminalProcessIdentity, transitionOperation, workspaceSkillsUpdatePayloadSchema, } from '@playcraft/common/cloud-workspace/runtime';
 import { closeCliCredentials } from '../workspaces/cli-credentials.js';
 import { resolveWorkspaceAttachments } from '../workspaces/attachments.js';
 import { readWorkspaceSkillSnapshot, readWorkspaceSkills } from '../workspaces/skills.js';
@@ -123,7 +124,7 @@ async function executeScopedOperation(state, scopeKey, operation, payload) {
     }
     try {
         if (operation.kind === 'session.create') {
-            return executeCreate(state, scopeKey, current);
+            return executeCreate(state, scopeKey, current, payload);
         }
         if (operation.kind === 'session.turn') {
             return executeTurn(state, scopeKey, current, payload);
@@ -171,13 +172,17 @@ async function executeSkillsUpdate(state, scopeKey, operation, payload) {
         }));
     }
 }
-async function executeCreate(state, scopeKey, operation) {
+async function executeCreate(state, scopeKey, operation, payload) {
     const sessionId = required(operation.sessionId, 'sessionId');
+    const selected = z.string().uuid().optional().safeParse(asRecord(payload).modelConfigId);
+    if (!selected.success)
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'model_config_denied' }));
     let started;
     try {
         started = await native(state).startThread({
             sessionId,
             cwd: await workspaceRoot(state, operation.workspaceId),
+            modelConfigId: selected.data,
         });
     }
     catch (error) {
@@ -195,10 +200,12 @@ async function executeCreate(state, scopeKey, operation) {
         threadId: started.threadId,
         cwd: await workspaceRoot(state, operation.workspaceId),
         recoverability: 'native',
+        modelConfigId: started.modelConfigId,
     });
     const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted', {
         nativeRequestId: `thread/start:${sessionId}`,
         nativeThreadId: started.threadId,
+        modelConfigId: started.modelConfigId,
     }));
     await recordNativeEvents(state, accepted, [
         { type: 'session.created', payload: { sessionId, threadId: started.threadId }, occurredAt: new Date().toISOString() },
@@ -218,6 +225,9 @@ async function executeTurn(state, scopeKey, operation, payload) {
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'turn_already_active' }));
     }
     const body = asRecord(payload);
+    const selected = z.string().uuid().optional().safeParse(body.modelConfigId);
+    if (!selected.success)
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'model_config_denied' }));
     let attachments;
     try {
         attachments = await resolveWorkspaceAttachments(await workspaceRoot(state, operation.workspaceId), body.attachmentIds);
@@ -233,15 +243,17 @@ async function executeTurn(state, scopeKey, operation, payload) {
         text: String(body.text ?? '') + attachmentText,
         images: attachments.filter((file) => file.mimeType.startsWith('image/')).map((file) => file.path),
         clientRequestId: operation.clientRequestId,
+        modelConfigId: selected.data ?? binding.modelConfigId,
         simulateLostReceipt: body.simulateLostReceipt === true,
-        persistReservation: async ({ nativeRequestId }) => {
+        persistReservation: async ({ nativeRequestId, modelConfigId }) => {
             await persist(state, scopeKey, {
                 ...operation,
                 nativeRequestId,
                 nativeThreadId: binding.threadId,
+                modelConfigId,
                 updatedAt: new Date().toISOString(),
             });
-            await state.journal.putSession({ ...binding, turnStatus: 'starting' });
+            await state.journal.putSession({ ...binding, modelConfigId, turnStatus: 'starting' });
         },
     });
     const reserved = state.journal.getOperation(scopeKey) ?? operation;
@@ -354,6 +366,7 @@ async function executeCheckpoint(state, scopeKey, operation, payload) {
         const sessions = workspaceSessions(state, operation.workspaceId).map((item) => ({
             sessionId: item.sessionId,
             nativeThreadId: item.threadId,
+            modelConfigId: item.modelConfigId,
             recoverability: 'history_only',
         }));
         const checkpoint = checkpointRecordSchema.parse({
@@ -385,7 +398,7 @@ async function executeCheckpoint(state, scopeKey, operation, payload) {
         git: standalone ? 'full' : 'local',
     });
     // Transcripts only matter where another instance can read them back.
-    const transcripts = state.config.fileObjectStoreUrl ? await captureTranscripts(state, operation.workspaceId) : [];
+    const transcripts = state.config.checkpointObjects ? await captureTranscripts(state, operation.workspaceId) : [];
     const digest = liveTreeDigest(tree, transcripts);
     if (!requested && tree.status === 'complete') {
         const stillActive = await activeManagedWrites(state, workspaceId);
@@ -396,14 +409,14 @@ async function executeCheckpoint(state, scopeKey, operation, payload) {
                 return finishUnchanged(state, scopeKey, operation, previous);
         }
     }
-    if (state.config.fileObjectStoreUrl) {
+    if (state.config.checkpointObjects) {
         const stillActive = await activeManagedWrites(state, workspaceId);
         if (stillActive.length > 0) {
             return finishBestEffort(state, scopeKey, operation, checkpointId, workspaceId, createdAt, stillActive.map((item) => item.source));
         }
         try {
             published = await publishFileSnapshot({
-                baseUrl: state.config.fileObjectStoreUrl,
+                baseUrl: platformEndpoint(state.config.publicBaseUrl, PLATFORM_ROUTES.checkpointStore),
                 snapshotId: checkpointId,
                 workspaceId,
                 generation: state.config.generation,
@@ -411,7 +424,7 @@ async function executeCheckpoint(state, scopeKey, operation, payload) {
                 native: transcripts,
                 uploaded: workspaceSaves(state, workspaceId).uploaded,
                 uploadedTranscripts: workspaceSaves(state, workspaceId).transcripts,
-                headers: objectStoreHeaders(state, state.config.fileObjectStoreUrl),
+                headers: objectStoreHeaders(state),
             });
         }
         catch {
@@ -421,6 +434,7 @@ async function executeCheckpoint(state, scopeKey, operation, payload) {
             const sessions = workspaceSessions(state, operation.workspaceId).map((item) => ({
                 sessionId: item.sessionId,
                 nativeThreadId: item.threadId,
+                modelConfigId: item.modelConfigId,
                 recoverability: 'history_only',
             }));
             const checkpoint = checkpointRecordSchema.parse({
@@ -513,13 +527,14 @@ async function executeRestore(state, scopeKey, operation, payload) {
         if (!checkpoint.nativeRecoverable || threadReplaced) {
             return {
                 ...item,
+                modelConfigId: snap.modelConfigId ?? item.modelConfigId,
                 threadId,
                 recoverability: restarted ? 'history_only' : item.recoverability,
             };
         }
         if (restarted)
-            return { ...item, threadId, recoverability: 'history_only' };
-        return { ...item, threadId: snap.nativeThreadId ?? item.threadId, recoverability: 'native' };
+            return { ...item, modelConfigId: snap.modelConfigId ?? item.modelConfigId, threadId, recoverability: 'history_only' };
+        return { ...item, modelConfigId: snap.modelConfigId ?? item.modelConfigId, threadId: snap.nativeThreadId ?? item.threadId, recoverability: 'native' };
     });
     for (const snap of checkpoint.sessions) {
         if (!next.some((item) => item.sessionId === snap.sessionId)) {
@@ -527,6 +542,7 @@ async function executeRestore(state, scopeKey, operation, payload) {
                 sessionId: snap.sessionId,
                 workspaceId: operation.workspaceId,
                 threadId: snap.nativeThreadId ?? `thread_${snap.sessionId}`,
+                modelConfigId: snap.modelConfigId,
                 cwd,
                 recoverability: checkpoint.nativeRecoverable && !restarted ? 'native' : 'history_only',
             });
@@ -545,6 +561,7 @@ async function executeRestore(state, scopeKey, operation, payload) {
                 threadId,
                 sessionId: snap.sessionId,
                 cwd: found.cwd,
+                modelConfigId: found.modelConfigId,
             });
             if (!continued || found.threadId !== threadId)
                 continue;
@@ -944,12 +961,14 @@ async function captureNativeSessions(state, workspaceId) {
             ? {
                 sessionId: item.sessionId,
                 nativeThreadId: item.threadId,
+                modelConfigId: item.modelConfigId,
                 nativeDurableTurnId: durable,
                 recoverability: 'native',
             }
             : {
                 sessionId: item.sessionId,
                 nativeThreadId: item.threadId,
+                modelConfigId: item.modelConfigId,
                 recoverability: 'history_only',
             });
     }
@@ -984,6 +1003,7 @@ async function finishBestEffort(state, scopeKey, operation, checkpointId, worksp
     const sessions = workspaceSessions(state, operation.workspaceId).map((item) => ({
         sessionId: item.sessionId,
         nativeThreadId: item.threadId,
+        modelConfigId: item.modelConfigId,
         recoverability: 'history_only',
     }));
     const checkpoint = checkpointRecordSchema.parse({
@@ -1074,7 +1094,7 @@ function nativeIds(params) {
     };
 }
 async function notifyCallback(state, events) {
-    await fetch(state.config.callbackUrl, {
+    await fetch(platformEndpoint(state.config.publicBaseUrl, PLATFORM_ROUTES.events), {
         method: 'POST',
         headers: {
             authorization: `Bearer ${state.config.controlToken}`,

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

@@ -1,10 +1,10 @@
 import { chmod, rename, writeFile } from 'node:fs/promises';
 import { applySandboxEndpointPatch } from '@playcraft/common/cloud-workspace/runtime';
-/** Persist the new addresses, then publish them to the running process. A restart is not required. */
+/** Persist the new public entrance, then publish it to the running process. A restart is not required. */
 export async function applyRuntimeEndpointPatch(state, patch) {
     const next = applySandboxEndpointPatch(state.config, patch);
-    const changed = next.callbackUrl !== state.config.callbackUrl || next.modelProxyUrl !== state.config.modelProxyUrl;
-    const result = { changed, callbackUrl: next.callbackUrl, modelProxyUrl: next.modelProxyUrl };
+    const changed = next.publicBaseUrl !== state.config.publicBaseUrl;
+    const result = { changed, publicBaseUrl: next.publicBaseUrl };
     if (!changed)
         return result;
     if (!state.configPath) {

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

@@ -1,7 +1,7 @@
 import { readObservedFile, withObservedFile } from '../workspaces/revisions.js';
 import { registerWorkspace, revisionScope, workspaceRoot, WorkspaceContextError } from '../workspaces/registry.js';
 import { randomUUID } from 'node:crypto';
-import { workspaceRegistrationRequestSchema, HTTP_STATUS_BY_ERROR, assertLeaseFence, buildHandshakeDocument, capability, findUntrustedRuntimeFields, gitFileRefSchema, hashOperationPayload, instanceRebuildRequestSchema, sourceAckSchema, operationAcceptRequestSchema, operationKindSchema, operationScopeKey, resolveIdempotentAccept, nativeHistoryReadSchema, runtimeError, unavailableRuntimeCapabilities, } from '@playcraft/common/cloud-workspace/runtime';
+import { workspaceRegistrationRequestSchema, HTTP_STATUS_BY_ERROR, assertLeaseFence, buildHandshakeDocument, capability, findUntrustedRuntimeFields, gitFileRefSchema, hashOperationPayload, instanceRebuildRequestSchema, sourceAckSchema, operationAcceptRequestSchema, operationKindSchema, operationScopeKey, resolveIdempotentAccept, nativeHistoryReadSchema, runtimeError, runtimeConnectivityDocumentSchema, unavailableRuntimeCapabilities, } from '@playcraft/common/cloud-workspace/runtime';
 import { controlTokenMatches, extractControlToken } from './auth.js';
 import { applyRuntimeEndpointPatch } from './endpoints.js';
 import { canExecuteKind, executeOperation } from './dispatch.js';
@@ -17,6 +17,7 @@ import { readWorkspaceSkills } from '../workspaces/skills.js';
 import { loadWorkspaceSkillArtifact } from '../workspaces/skill-artifact-loader.js';
 import { join } from 'node:path';
 import { terminalHost } from './terminal-host.js';
+import { probeRuntimeConnectivity } from './connectivity.js';
 export async function handleRuntimeRequest(state, request, response) {
     const url = new URL(request.url ?? '/', 'http://127.0.0.1');
     const access = authorizeRuntime(state, request);
@@ -33,6 +34,19 @@ export async function handleRuntimeRequest(state, request, response) {
             writeJson(response, 200, { status: 'ok', handshake: handshake(state) });
             return;
         }
+        if (request.method === 'GET' && url.pathname === '/runtime/connectivity') {
+            if (writeDestroyed(state, response))
+                return;
+            const parsed = runtimeConnectivityDocumentSchema.shape.workspaceId.safeParse(url.searchParams.get('workspaceId'));
+            if (!parsed.success) {
+                writeJson(response, 400, { error: 'invalid_workspace' });
+                return;
+            }
+            const workspaceId = parsed.data;
+            await workspaceRoot(state, workspaceId);
+            writeJson(response, 200, await probeRuntimeConnectivity(state, workspaceId));
+            return;
+        }
         if (request.method === 'GET' && url.pathname === '/runtime/identity') {
             const { runtimeId, userId, environment, generation } = state.config;
             writeJson(response, 200, {

package/dist/workspace-runtime/workspaces/checkpoint-saves.js

@@ -58,17 +58,8 @@ export async function rememberFileCheckpoint(state, workspaceId, saved) {
         await rm(join(state.config.stateDir, 'file-checkpoints', checkpointId), { recursive: true, force: true }).catch(() => undefined);
     }
 }
-/**
- * The control credential goes only to Runtime's own object endpoint, never to another store.
- */
-export function objectStoreHeaders(state, storeUrl) {
-    try {
-        if (new URL(storeUrl).origin !== new URL(state.config.callbackUrl).origin)
-            return {};
-    }
-    catch {
-        return {};
-    }
+/** Checkpoint uploads always go to this deployment, so they always carry the control credential. */
+export function objectStoreHeaders(state) {
     return {
         authorization: `Bearer ${state.config.controlToken}`,
         'playcraft-env': state.config.environment,

package/dist/workspace-runtime/workspaces/cli-credentials.js

@@ -2,7 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { mkdir, rename, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { z } from 'zod';
-import { runtimeCallbackEndpoint } from '../../utils/environment-endpoints.js';
+import { PLATFORM_ROUTES, platformEndpoint } from '@playcraft/common/cloud-workspace/runtime';
 const responseSchema = z.object({
     token: z.string().min(1),
     apiUrl: z.string().url(),
@@ -37,11 +37,7 @@ export async function ensureCliCredentials(state) {
 async function renew(state, entry) {
     const config = state.config;
     const epoch = state.runtimeEpoch;
-    const endpoint = runtimeCallbackEndpoint(config.callbackUrl, '/runtime/internal/cli-credentials');
-    if (endpoint.protocol !== 'https:' &&
-        !(endpoint.protocol === 'http:' &&
-            ['127.0.0.1', 'localhost', '[::1]'].includes(endpoint.hostname)))
-        throw new Error('cli_callback_insecure');
+    const endpoint = platformEndpoint(config.publicBaseUrl, PLATFORM_ROUTES.cliCredentials);
     try {
         const response = await fetch(endpoint, {
             method: 'POST',

package/dist/workspace-runtime/workspaces/git-credential-broker.js

@@ -8,7 +8,7 @@ import { fileURLToPath } from 'node:url';
 import { promisify } from 'node:util';
 import { isLocalWorkspaceGitAuthMode, isLocalWorkspaceGitEnvironment, matchWorkspaceGitGatewayCloneUrl, workspacePreparationSchema } from '@playcraft/common/cloud-workspace/runtime';
 import { WorkspaceGitDirectStore } from './git-direct-store.js';
-import { runtimeCallbackEndpoint } from '../../utils/environment-endpoints.js';
+import { PLATFORM_ROUTES, platformEndpoint } from '@playcraft/common/cloud-workspace/runtime';
 const exec = promisify(execFile);
 /** Only this control process sees the callback credential. Development processes use the local socket. */
 export class WorkspaceGitCredentialBroker {
@@ -165,9 +165,7 @@ export class WorkspaceGitCredentialBroker {
         await this.direct.sweep(true);
     }
     async refresh(binding, key) {
-        const endpoint = runtimeCallbackEndpoint(this.state.config.callbackUrl, '/runtime/internal/git-credentials');
-        if (endpoint.protocol !== 'https:' && !(endpoint.protocol === 'http:' && ['127.0.0.1', 'localhost', '[::1]'].includes(endpoint.hostname)))
-            throw new Error('git_broker_unavailable');
+        const endpoint = platformEndpoint(this.state.config.publicBaseUrl, PLATFORM_ROUTES.gitCredentials);
         const epoch = this.state.runtimeEpoch;
         const response = await fetch(endpoint, {
             method: 'POST', redirect: 'error', signal: AbortSignal.timeout(10_000),

package/dist/workspace-runtime/workspaces/skill-artifact-loader.js

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 import { workspaceRoot } from './registry.js';
-import { runtimeCallbackEndpoint } from '../../utils/environment-endpoints.js';
+import { PLATFORM_ROUTES, platformEndpoint } from '@playcraft/common/cloud-workspace/runtime';
 const MAX_ARTIFACT_BYTES = 80 * 1024 * 1024;
 /** Requests an exact locked artifact using control identity; no storage credentials reach Codex. */
 export async function loadWorkspaceSkillArtifact(state, workspaceId, entry) {
@@ -8,9 +8,7 @@ export async function loadWorkspaceSkillArtifact(state, workspaceId, entry) {
     const epoch = state.runtimeEpoch;
     if (state.journal.destroyed())
         throw new Error('workspace_skills_unavailable');
-    const endpoint = runtimeCallbackEndpoint(state.config.callbackUrl, '/runtime/internal/skill-artifacts');
-    if (endpoint.protocol !== 'https:' && !(endpoint.protocol === 'http:' && ['127.0.0.1', 'localhost', '[::1]'].includes(endpoint.hostname)))
-        throw new Error('workspace_skills_callback_insecure');
+    const endpoint = platformEndpoint(state.config.publicBaseUrl, PLATFORM_ROUTES.skillArtifacts);
     const response = await fetch(endpoint, {
         method: 'POST', redirect: 'error', signal: AbortSignal.timeout(30_000),
         headers: { authorization: `Bearer ${state.config.controlToken}`, 'content-type': 'application/json', 'playcraft-env': state.config.environment },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playcraft/cli",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "private": false,
   "type": "module",
   "engines": {
@@ -48,8 +48,8 @@
     "@gltf-transform/core": "^4.3.0",
     "@gltf-transform/extensions": "^4.3.0",
     "@gltf-transform/functions": "^4.3.0",
-    "@playcraft/build": "^0.1.16",
-    "@playcraft/common": "^0.1.16",
+    "@playcraft/build": "^0.1.17",
+    "@playcraft/common": "^0.1.17",
     "better-sqlite3-pinned": "npm:better-sqlite3@13.0.3",
     "chokidar": "^4.0.3",
     "commander": "^13.1.0",