@mindexec/cli 0.2.465 → 0.2.467

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.465",
+  "version": "0.2.467",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",
   "files": [
     "start-bridge.bat",
     "start-bridge.sh",
-    "launch-bridge.cjs",
-    "desktop-workspace-state.cjs",
-    "server.js",
+    "launch-bridge.cjs",
+    "desktop-workspace-state.cjs",
+    "server.js",
     "remote-hub.js",
     "lzo1x.js",
     "mode4-atlas.js",
@@ -27,17 +27,21 @@
   "scripts": {
     "start": "node launch-bridge.cjs",
     "dev": "node launch-bridge.cjs --watch",
-    "desktop:start": "electron electron/main.cjs",
-    "desktop:build:win": "electron-builder --win --x64 --publish never",
-    "desktop:inspect:update:dev": "node scripts/publish-mindexec-desktop-updates.mjs --channel dev --platform windows-x64 --dir ../artifacts/electron --allow-unsigned",
-    "desktop:publish:update:dev": "node scripts/publish-mindexec-desktop-updates.mjs --channel dev --platform windows-x64 --dir ../artifacts/electron --allow-unsigned --publish",
-    "desktop:deploy:update-worker": "node ../r2-auth-proxy/node_modules/wrangler/wrangler-dist/cli.js deploy --config ../workers/mindexec-desktop-updates/wrangler.jsonc",
-    "desktop:check:update-worker": "node ../r2-auth-proxy/node_modules/wrangler/wrangler-dist/cli.js deploy --dry-run --config ../workers/mindexec-desktop-updates/wrangler.jsonc",
-    "test:desktop:update": "node --test electron/update-manager-smoke.mjs electron/recurring-update-owner-smoke.mjs scripts/desktop-update-worker-smoke.mjs scripts/desktop-update-publisher-smoke.mjs",
-    "test:desktop": "node electron/source-smoke.mjs && node scripts/desktop-workspace-state-smoke.mjs && npm run test:desktop:update",
+    "desktop:start": "electron electron/main.cjs",
+    "desktop:build:win": "electron-builder --win --x64 --publish never",
+    "desktop:inspect:update:dev": "node scripts/publish-mindexec-desktop-updates.mjs --channel dev --platform windows-x64 --dir ../artifacts/electron --allow-unsigned",
+    "desktop:publish:update:dev": "node scripts/publish-mindexec-desktop-updates.mjs --channel dev --platform windows-x64 --dir ../artifacts/electron --allow-unsigned --publish",
+    "desktop:deploy:update-worker": "node ../r2-auth-proxy/node_modules/wrangler/wrangler-dist/cli.js deploy --config ../workers/mindexec-desktop-updates/wrangler.jsonc",
+    "desktop:check:update-worker": "node ../r2-auth-proxy/node_modules/wrangler/wrangler-dist/cli.js deploy --dry-run --config ../workers/mindexec-desktop-updates/wrangler.jsonc",
+    "test:desktop:update": "node --test electron/update-manager-smoke.mjs electron/recurring-update-owner-smoke.mjs scripts/desktop-update-worker-smoke.mjs scripts/desktop-update-publisher-smoke.mjs",
+    "test:desktop": "node electron/source-smoke.mjs && node scripts/desktop-workspace-state-smoke.mjs && npm run test:desktop:update",
     "test:desktop:win": "node electron/windows-package-smoke.mjs",
-    "test:syntax": "node --check server.js && node --check remote-hub.js && node --check lzo1x.js && node --check mode4-atlas.js && node --check mode4-atlas-worker.js && node --check codex-runtime.js && node --check codex-model-catalog.js && node --check launch-bridge.cjs && node --check port-guard.cjs && node --check desktop-workspace-state.cjs && node --check electron/main.cjs && node --check electron/preload.cjs && node --check electron/update-manager.cjs && node --check electron/update-feed-resolver.cjs && node --check electron/recurring-update-owner.cjs && node --check electron/source-smoke.mjs && node --check electron/windows-package-smoke.mjs && node --check electron/update-manager-smoke.mjs && node --check electron/recurring-update-owner-smoke.mjs && node --check scripts/desktop-workspace-state-smoke.mjs && node --check scripts/desktop-update-worker-smoke.mjs && node --check scripts/desktop-update-publisher-smoke.mjs && node --check scripts/publish-mindexec-desktop-updates.mjs && node --check ../workers/mindexec-desktop-updates/src/index.mjs && node --check scripts/setup-tree-sitter-grammars.mjs && node --check scripts/npm-fresh-install-smoke.mjs && node --check scripts/auth-session-smoke.mjs && node --check scripts/codex-model-catalog-smoke.mjs && node --check scripts/codex-sdk-runtime-smoke.mjs && node --check scripts/remote-hub-smoke.mjs && node --check scripts/remote-hub-scale-smoke.mjs && node --check scripts/remote-fleet-render-smoke.mjs && node --check scripts/remote-http-smoke.mjs && node --check scripts/remote-frame-ws-smoke.mjs && node --check scripts/remote-input-ws-smoke.mjs && node --check scripts/remote-agent-ws-smoke.mjs && node --check scripts/remote-agent-managed-smoke.mjs && node --check scripts/remote-registry-follower-smoke.mjs && node --check scripts/remote-agent-package-smoke.mjs && node --check scripts/remote-fast-live-rate-smoke.mjs && node --check scripts/remote-fast-mdm-browser-smoke.mjs",
-    "test:codex-sdk": "node scripts/codex-sdk-runtime-smoke.mjs",
+    "test:syntax": "node --check server.js && node --check remote-hub.js && node --check lzo1x.js && node --check mode4-atlas.js && node --check mode4-atlas-worker.js && node --check codex-runtime.js && node --check codex-model-catalog.js && node --check launch-bridge.cjs && node --check port-guard.cjs && node --check desktop-workspace-state.cjs && node --check electron/main.cjs && node --check electron/preload.cjs && node --check electron/update-manager.cjs && node --check electron/update-feed-resolver.cjs && node --check electron/recurring-update-owner.cjs && node --check electron/source-smoke.mjs && node --check electron/windows-package-smoke.mjs && node --check electron/update-manager-smoke.mjs && node --check electron/recurring-update-owner-smoke.mjs && node --check scripts/desktop-workspace-state-smoke.mjs && node --check scripts/desktop-update-worker-smoke.mjs && node --check scripts/desktop-update-publisher-smoke.mjs && node --check scripts/board-render-ownership-smoke.mjs && node --check ../workers/mindexec-desktop-updates/src/index.mjs && node --check scripts/setup-tree-sitter-grammars.mjs && node --check scripts/npm-fresh-install-smoke.mjs && node --check scripts/auth-session-smoke.mjs && node --check scripts/codex-model-catalog-smoke.mjs && node --check scripts/codex-sdk-runtime-smoke.mjs && node --check scripts/codex-sdk-image-runtime-smoke.mjs && node --check scripts/codex-sdk-image-live-smoke.mjs && node --check scripts/codex-runtime-home-smoke.mjs && node --check scripts/remote-hub-smoke.mjs && node --check scripts/remote-hub-scale-smoke.mjs && node --check scripts/remote-fleet-render-smoke.mjs && node --check scripts/remote-http-smoke.mjs && node --check scripts/remote-frame-ws-smoke.mjs && node --check scripts/remote-input-ws-smoke.mjs && node --check scripts/remote-agent-ws-smoke.mjs && node --check scripts/remote-agent-managed-smoke.mjs && node --check scripts/remote-registry-follower-smoke.mjs && node --check scripts/remote-agent-package-smoke.mjs && node --check scripts/remote-fast-live-rate-smoke.mjs && node --check scripts/remote-fast-mdm-browser-smoke.mjs",
+    "test:canvas:board-owner": "node scripts/board-render-ownership-smoke.mjs",
+    "test:codex-sdk": "node scripts/codex-sdk-runtime-smoke.mjs",
+    "test:codex-sdk:image": "node scripts/codex-sdk-image-runtime-smoke.mjs",
+    "test:codex-sdk:image:live": "node scripts/codex-sdk-image-live-smoke.mjs --live",
+    "test:codex-sdk:home": "node scripts/codex-runtime-home-smoke.mjs",
     "test:codex-sdk:live": "node scripts/codex-sdk-runtime-smoke.mjs --live",
     "test:codex-sdk:live-tools": "node scripts/codex-sdk-runtime-smoke.mjs --live-tools",
     "test:codex-model-catalog": "node scripts/codex-model-catalog-smoke.mjs",
@@ -83,17 +87,17 @@
     "cors": "^2.8.5",
     "express": "^4.18.2",
     "ffmpeg-static": "^5.3.0",
-    "multer": "^2.2.0",
-    "electron-updater": "^6.8.9",
-    "playwright-core": "^1.53.0",
+    "multer": "^2.2.0",
+    "electron-updater": "^6.8.9",
+    "playwright-core": "^1.53.0",
     "sharp": "^0.35.3",
     "web-tree-sitter": "^0.22.6",
     "ws": "^8.16.0"
   },
-  "overrides": {
-    "body-parser": "1.20.6",
-    "js-yaml": "4.3.1"
-  },
+  "overrides": {
+    "body-parser": "1.20.6",
+    "js-yaml": "4.3.1"
+  },
   "bin": {
     "mindexec": "launch-bridge.cjs",
     "mind-bridge": "launch-bridge.cjs"
@@ -108,9 +112,9 @@
     "productName": "MindExec",
     "copyright": "Copyright © 2026 lovecrdm77",
     "asar": false,
-    "extraMetadata": {
-      "main": "electron/main.cjs",
-      "desktopUpdateChannel": "dev"
+    "extraMetadata": {
+      "main": "electron/main.cjs",
+      "desktopUpdateChannel": "dev"
     },
     "directories": {
       "output": "../artifacts/electron"
@@ -119,7 +123,7 @@
       "*.js",
       "*.cjs",
       "*.json",
-      "electron/**/*",
+      "electron/**/*",
       "remote-fast/**/*",
       "scripts/**/*",
       "tree-sitter-grammars/**/*",
@@ -144,8 +148,8 @@
         }
       ]
     },
-    "nsis": {
-      "artifactName": "MindExec-${version}-dev-${arch}.${ext}",
+    "nsis": {
+      "artifactName": "MindExec-${version}-dev-${arch}.${ext}",
       "oneClick": false,
       "perMachine": false,
       "allowToChangeInstallationDirectory": true,
@@ -153,12 +157,12 @@
       "createStartMenuShortcut": true,
       "shortcutName": "MindExec"
     },
-    "portable": {
-      "artifactName": "MindExec-Portable-${version}-${arch}.${ext}"
-    },
-    "publish": {
-      "provider": "generic",
-      "url": "https://mindexec.lovecrdm.workers.dev/dev/windows/x64"
-    }
+    "portable": {
+      "artifactName": "MindExec-Portable-${version}-${arch}.${ext}"
+    },
+    "publish": {
+      "provider": "generic",
+      "url": "https://mindexec.lovecrdm.workers.dev/dev/windows/x64"
+    }
   }
 }

package/scripts/board-render-ownership-smoke.mjs

@@ -0,0 +1,85 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const sourcePath = path.resolve(
+    scriptDir,
+    '..',
+    '..',
+    'MindExecution.Shared',
+    'wwwroot',
+    'js',
+    'mind-map-board-render-ownership.js');
+const source = fs.readFileSync(sourcePath, 'utf8');
+const traces = [];
+const window = {
+    MindCanvasTrace: { emit: (type, data) => traces.push({ type, data }) },
+    MindCanvasBuildInfo: { registerPart: () => { } }
+};
+
+vm.runInNewContext(source, { window, Map, Object, Number, String, Math });
+
+const makeMesh = (count = 8) => ({
+    visible: true,
+    geometry: {
+        instanceCount: count,
+        drawRange: { start: 0, count: count },
+        setDrawRange(start, nextCount) {
+            this.drawRange = { start, count: nextCount };
+        }
+    }
+});
+const renderer = {
+    resetCalls: 0,
+    resetState() { this.resetCalls++; },
+    pendingNodes: new Map([['stale-node', {}]]),
+    instancedHaloMesh: makeMesh(),
+    instancedMesh: makeMesh(),
+    instancedLineMesh: makeMesh(),
+    instancedBorderLineMesh: makeMesh(),
+    instancedConsoleMesh: makeMesh(),
+    instancedImageMesh: makeMesh(),
+    requestResidentPatch(reason) { this.patchReason = reason; }
+};
+const module = { _forceUpdateFrames: 0 };
+
+assert.equal(window.MindMapBoardRenderOwnership.retireResidentBoard(renderer, module, {
+    fromBoardId: 'BOARD-B',
+    toBoardId: 'BOARD-A'
+}), true);
+assert.equal(renderer.resetCalls, 1);
+assert.equal(renderer.pendingNodes.size, 0);
+assert.equal(renderer._activeBoardRenderId, 'board-a');
+assert.equal(renderer._residentBuilt, false);
+assert.equal(renderer._residentBuildPhase, 'board-switch');
+for (const mesh of [
+    renderer.instancedHaloMesh,
+    renderer.instancedMesh,
+    renderer.instancedLineMesh,
+    renderer.instancedBorderLineMesh,
+    renderer.instancedConsoleMesh,
+    renderer.instancedImageMesh
+]) {
+    assert.equal(mesh.visible, false);
+    assert.equal(mesh.geometry.instanceCount, 0);
+}
+assert.equal(renderer.instancedBorderLineMesh.geometry.drawRange.count, 0);
+assert.equal(traces.at(-1)?.type, 'board.resident.retired');
+
+const lineDataCache = new Map([['node-a', [1, 2, 3]]]);
+assert.equal(window.MindMapBoardRenderOwnership.prepareCachedBoard(renderer, module, {
+    boardId: 'BOARD-A',
+    lineDataCache
+}), true);
+assert.equal(renderer.lineDataCache, lineDataCache);
+assert.equal(renderer.patchReason, 'board-reload');
+
+console.log(JSON.stringify({
+    ok: true,
+    retiredResidentCount: 0,
+    activeBoardRenderId: renderer._activeBoardRenderId,
+    patchReason: renderer.patchReason
+}));

package/scripts/codex-runtime-home-smoke.mjs

@@ -0,0 +1,58 @@
+import assert from 'node:assert/strict';
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {
+    buildCodexChildEnv,
+    ensureCodexRuntimeHome,
+    resolveCodexRuntimeHome
+} from '../codex-runtime.js';
+
+const previousCodexHome = process.env.CODEX_HOME;
+const previousMindExecCodexHome = process.env.MINDEXEC_CODEX_HOME;
+const sharedHome = await fs.mkdtemp(path.join(os.tmpdir(), 'mindexec-codex-shared-home-'));
+const isolatedHome = await fs.mkdtemp(path.join(os.tmpdir(), 'mindexec-codex-isolated-home-'));
+
+try {
+    process.env.CODEX_HOME = sharedHome;
+    delete process.env.MINDEXEC_CODEX_HOME;
+
+    assert.equal(resolveCodexRuntimeHome(), path.resolve(sharedHome));
+    assert.equal(await ensureCodexRuntimeHome(), path.resolve(sharedHome));
+    assert.equal(await fs.stat(path.join(sharedHome, 'sessions')).then(() => true), true);
+    assert.equal(await fs.stat(path.join(sharedHome, 'generated_images')).then(() => true), true);
+    assert.equal(await fs.stat(path.join(sharedHome, 'config.toml')).then(() => true).catch(() => false), false);
+
+    const sharedEnv = buildCodexChildEnv();
+    assert.equal(sharedEnv.CODEX_HOME, path.resolve(sharedHome));
+    assert.equal(sharedEnv.MINDEXEC_CODEX_ISOLATED_HOME, undefined);
+
+    process.env.MINDEXEC_CODEX_HOME = isolatedHome;
+    assert.equal(resolveCodexRuntimeHome(), path.resolve(isolatedHome));
+    assert.equal(await ensureCodexRuntimeHome(), path.resolve(isolatedHome));
+    const isolatedConfig = await fs.readFile(path.join(isolatedHome, 'config.toml'), 'utf8');
+    assert.match(isolatedConfig, /Generated by MindExec LocalBridge for isolated AI node runs/);
+
+    const isolatedEnv = buildCodexChildEnv();
+    assert.equal(isolatedEnv.CODEX_HOME, path.resolve(isolatedHome));
+    assert.equal(isolatedEnv.MINDEXEC_CODEX_ISOLATED_HOME, '1');
+
+    console.log(JSON.stringify({
+        ok: true,
+        sharedCodexLoginHome: true,
+        explicitIsolationOnly: true
+    }));
+} finally {
+    if (previousCodexHome === undefined) {
+        delete process.env.CODEX_HOME;
+    } else {
+        process.env.CODEX_HOME = previousCodexHome;
+    }
+    if (previousMindExecCodexHome === undefined) {
+        delete process.env.MINDEXEC_CODEX_HOME;
+    } else {
+        process.env.MINDEXEC_CODEX_HOME = previousMindExecCodexHome;
+    }
+    await fs.rm(sharedHome, { recursive: true, force: true });
+    await fs.rm(isolatedHome, { recursive: true, force: true });
+}

package/scripts/codex-sdk-image-live-smoke.mjs

@@ -0,0 +1,43 @@
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createCodexRuntime, resolveCodexRuntimeHome } from '../codex-runtime.js';
+
+if (!process.argv.includes('--live')) {
+    console.log(JSON.stringify({ ok: true, liveImage: false }));
+    process.exit(0);
+}
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = path.resolve(scriptDir, '..');
+const workspaceRoot = path.resolve(packageRoot, '..');
+const runtime = createCodexRuntime({
+    packageRoot,
+    resolveWorkingDirectory: async () => workspaceRoot,
+    getCurrentRuntime: () => ({}),
+    getModelCatalog: async () => ({ models: [], source: 'live-smoke', updatedAt: new Date().toISOString() }),
+    log: () => {}
+});
+
+const result = await runtime.runImage({
+    prompt: 'Create a clean square test image with one solid blue circle centered on a white background. No text.',
+    size: '1024x1024',
+    quality: 'low'
+});
+
+assert.equal(result.success, true, result.error);
+assert.equal(result.providerKind, 'TypeScriptSdk');
+assert.equal(result.authenticationRequired, false);
+assert.equal(result.loginOpened, false, 'The existing Codex login should be reused without opening sign-in.');
+assert.ok(result.imageBase64.length > 1000, 'The live SDK image result was unexpectedly small.');
+assert.match(result.mimeType, /^image\//);
+
+console.log(JSON.stringify({
+    ok: true,
+    liveImage: true,
+    providerKind: result.providerKind,
+    sharedCodexHome: resolveCodexRuntimeHome(),
+    loginOpened: result.loginOpened,
+    mimeType: result.mimeType,
+    imageBytesApprox: Math.floor(result.imageBase64.length * 0.75)
+}));

package/scripts/codex-sdk-image-runtime-smoke.mjs

@@ -0,0 +1,122 @@
+import assert from 'node:assert/strict';
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createCodexRuntime } from '../codex-runtime.js';
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = path.resolve(scriptDir, '..');
+const workspaceRoot = path.resolve(packageRoot, '..');
+const runtimeHome = await fs.mkdtemp(path.join(os.tmpdir(), 'mindexec-codex-sdk-image-'));
+const tinyPngBase64 = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+jX8kAAAAASUVORK5CYII=';
+
+function imageEvents() {
+    return (async function* generateEvents() {
+        yield { type: 'thread.started', thread_id: 'thread-image-smoke' };
+        yield {
+            type: 'event_msg',
+            payload: {
+                type: 'image_generation_end',
+                result: `data:image/png;base64,${tinyPngBase64}`
+            }
+        };
+        yield { type: 'turn.completed' };
+    })();
+}
+
+function createFakeSdk(runStreamed, captures) {
+    return {
+        Codex: class FakeCodex {
+            constructor(options) {
+                captures.codexOptions.push(options);
+            }
+
+            startThread(options) {
+                captures.threadOptions.push(options);
+                return {
+                    runStreamed: async input => {
+                        captures.inputs.push(input);
+                        return { events: runStreamed() };
+                    }
+                };
+            }
+        }
+    };
+}
+
+function createRuntime(fakeSdk, loginCodex) {
+    return createCodexRuntime({
+        packageRoot,
+        resolveWorkingDirectory: async () => workspaceRoot,
+        getCurrentRuntime: () => ({}),
+        getModelCatalog: async () => ({ models: [], source: 'smoke', updatedAt: new Date().toISOString() }),
+        loadCodexSdk: async () => fakeSdk,
+        ensureCodexRuntimeHome: async () => {
+            await fs.mkdir(path.join(runtimeHome, 'generated_images'), { recursive: true });
+            return runtimeHome;
+        },
+        buildCodexChildEnv: () => ({ CODEX_HOME: runtimeHome }),
+        loginCodex,
+        log: () => {}
+    });
+}
+
+try {
+    const captures = { codexOptions: [], threadOptions: [], inputs: [] };
+    const runtime = createRuntime(createFakeSdk(imageEvents, captures), async () => {
+        throw new Error('Login must not run for an authenticated image request.');
+    });
+    const generated = await runtime.runImage({
+        prompt: 'Create a blue product icon.',
+        model: 'gpt-5.5',
+        size: '1024x1024',
+        quality: 'high',
+        referenceImages: [{ base64: tinyPngBase64, mimeType: 'image/png', fileName: 'source.png' }]
+    });
+
+    assert.equal(generated.success, true, generated.error);
+    assert.equal(generated.providerKind, 'TypeScriptSdk');
+    assert.equal(generated.imageBase64, tinyPngBase64);
+    assert.equal(generated.mimeType, 'image/png');
+    assert.equal(captures.codexOptions[0].config.features.image_generation, true);
+    assert.deepEqual(captures.codexOptions[0].config.mcp_servers, {});
+    assert.equal(captures.threadOptions[0].sandboxMode, 'read-only');
+    assert.equal(captures.inputs[0][0].type, 'text');
+    assert.equal(captures.inputs[0][1].type, 'local_image');
+    assert.equal(await fs.stat(captures.inputs[0][1].path).then(() => true).catch(() => false), false);
+
+    let attempts = 0;
+    let loginCount = 0;
+    const authCaptures = { codexOptions: [], threadOptions: [], inputs: [] };
+    const authSdk = createFakeSdk(() => {
+        attempts += 1;
+        if (attempts === 1) {
+            return (async function* invalidAuth() {
+                throw new Error('401 Unauthorized: invalid_refresh_token. Please log out and sign in again.');
+            })();
+        }
+        return imageEvents();
+    }, authCaptures);
+    const authRuntime = createRuntime(authSdk, async () => {
+        loginCount += 1;
+        return { success: true, exitCode: 0 };
+    });
+    const retried = await authRuntime.runImage({ prompt: 'Create one test image.' });
+
+    assert.equal(loginCount, 1);
+    assert.equal(attempts, 2);
+    assert.equal(retried.success, true, retried.error);
+    assert.equal(retried.loginOpened, true);
+    assert.equal(retried.authenticationRequired, false);
+    assert.equal(retried.providerKind, 'TypeScriptSdk');
+
+    console.log(JSON.stringify({
+        ok: true,
+        providerKind: generated.providerKind,
+        referenceAttachment: true,
+        browserLoginRetry: true
+    }));
+} finally {
+    await fs.rm(runtimeHome, { recursive: true, force: true });
+}

package/server.js

@@ -13022,6 +13022,23 @@ app.post('/api/codex/thread/run', async (req, res) => {
     }
 });
 
+app.post('/api/codex/image/run', async (req, res) => {
+    try {
+        res.json(await getCodexRuntime().runImage(req.body || {}));
+    } catch (err) {
+        console.error('[Codex/ImageRun] Error:', err);
+        res.status(err.statusCode || 500).json({
+            success: false,
+            providerKind: 'Unavailable',
+            imageBase64: '',
+            mimeType: '',
+            error: err?.message || String(err),
+            authenticationRequired: false,
+            loginOpened: false
+        });
+    }
+});
+
 app.post('/api/codex/thread/resume', async (req, res) => {
     try {
         res.json(await getCodexRuntime().resumeThread(req.body || {}));

package/wwwroot/_content/MindExecution.Shared/js/mind-map-board-render-ownership.js

@@ -0,0 +1,81 @@
+(function () {
+    'use strict';
+
+    const BUILD_ID = '20260819-board-render-owner-v1';
+
+    function normalizeBoardId(value) {
+        return String(value || '').trim().toLowerCase();
+    }
+
+    function clearResidentGeometry(mesh, useDrawRange = false) {
+        if (!mesh) return;
+
+        mesh.visible = false;
+        const geometry = mesh.geometry;
+        if (!geometry) return;
+
+        if ('instanceCount' in geometry) {
+            geometry.instanceCount = 0;
+        }
+        if (useDrawRange && typeof geometry.setDrawRange === 'function') {
+            geometry.setDrawRange(0, 0);
+        }
+    }
+
+    function retireResidentBoard(renderer, module, details = {}) {
+        if (!renderer) return false;
+
+        renderer.resetState?.();
+        renderer.pendingNodes?.clear?.();
+
+        clearResidentGeometry(renderer.instancedHaloMesh);
+        clearResidentGeometry(renderer.instancedMesh);
+        clearResidentGeometry(renderer.instancedLineMesh);
+        clearResidentGeometry(renderer.instancedBorderLineMesh, true);
+        clearResidentGeometry(renderer.instancedConsoleMesh);
+        clearResidentGeometry(renderer.instancedImageMesh);
+
+        renderer._activeBoardRenderId = normalizeBoardId(details.toBoardId);
+        renderer._boardRenderEpoch = Math.max(0, Number(renderer._boardRenderEpoch || 0)) + 1;
+        renderer._residentBuilt = false;
+        renderer._residentBuildPhase = 'board-switch';
+
+        if (module) {
+            module._forceUpdateFrames = Math.max(Number(module._forceUpdateFrames || 0), 2);
+        }
+
+        window.MindCanvasTrace?.emit?.('board.resident.retired', {
+            fromBoardId: details.fromBoardId || null,
+            toBoardId: details.toBoardId || null,
+            reason: details.reason || 'board-switch',
+            epoch: renderer._boardRenderEpoch
+        });
+        return true;
+    }
+
+    function prepareCachedBoard(renderer, module, details = {}) {
+        if (!renderer) return false;
+
+        const boardId = normalizeBoardId(details.boardId);
+        renderer._activeBoardRenderId = boardId;
+        if (details.lineDataCache instanceof Map) {
+            renderer.lineDataCache = details.lineDataCache;
+        }
+        renderer.requestResidentPatch?.('board-reload');
+
+        if (module) {
+            module._forceUpdateFrames = Math.max(Number(module._forceUpdateFrames || 0), 2);
+        }
+        return true;
+    }
+
+    window.MindMapBoardRenderOwnership = Object.freeze({
+        BUILD_ID,
+        normalizeBoardId,
+        retireResidentBoard,
+        prepareCachedBoard
+    });
+    window.MindCanvasBuildInfo?.registerPart?.('boardRenderOwnership', BUILD_ID, {
+        file: 'mind-map-board-render-ownership.js'
+    });
+})();