@portel/photon 1.18.0 → 1.20.0

package/dist/auto-ui/beam.js

@@ -14,7 +14,7 @@ import * as path from 'path';
 import * as os from 'os';
 import { fileURLToPath } from 'url';
 import { createHash } from 'crypto';
-import { setSecurityHeaders, SimpleRateLimiter, escapeHtml } from '../shared/security.js';
+import { setSecurityHeaders, SimpleRateLimiter, escapeHtml, getCorsOrigin, } from '../shared/security.js';
 /**
  * Check if shell integration has been installed (photon init cli).
  * Cached at module load since it won't change during a Beam session.
@@ -100,7 +100,7 @@ import { ensurePhotonEditorDeclaration, writePhotonEditorDeclaration, } from '..
 import { ensureDaemon } from '../daemon/manager.js';
 import { SchemaExtractor } from '@portel/photon-core';
 import { generateServerCard } from '../server-card.js';
-import { handleStreamableHTTP, broadcastNotification, broadcastToBeam, } from './streamable-http-transport.js';
+import { handleStreamableHTTP, broadcastNotification, broadcastToBeam, stopSessionCleanup, } from './streamable-http-transport.js';
 import { getBundledPhotonPath, BEAM_BUNDLED_PHOTONS } from '../shared-utils.js';
 // BUNDLED_PHOTONS and getBundledPhotonPath are imported from shared-utils.js
 // Extracted modules (Phase 5)
@@ -116,14 +116,40 @@ import { configurePhotonViaMCP, reloadPhotonViaMCP, removePhotonViaMCP, updateMe
 import { generateAgentCard } from '../a2a/card-generator.js';
 // Delegate to extracted module
 const getConfigFilePath = getConfigFilePathFromModule;
-// Module-level state for external MCPs (shared with transport handler)
-const externalMCPs = [];
-const externalMCPClients = new Map();
-const externalMCPSDKClients = new Map();
+// ═══════════════════════════════════════════════════════════════════════════════
+// BEAM CONTEXT — all module-level mutable state lives here
+// ═══════════════════════════════════════════════════════════════════════════════
+class BeamContext {
+    /** External MCP server metadata */
+    externalMCPs = [];
+    /** Transport-level clients for external MCPs */
+    externalMCPClients = new Map();
+    /** SDK Client instances for tool calls with structuredContent */
+    externalMCPSDKClients = new Map();
+    /**
+     * Notification subscriptions per photon.
+     * Key: photon name, Value: list of event types this photon cares about
+     * Example: { "chat": ["mentions", "direct-messages"], "tasks": ["deadline", "assigned-to-me"] }
+     */
+    photonNotificationSubscriptions = new Map();
+    /**
+     * Track which state-changed channels we've already subscribed to,
+     * so dynamically discovered photons can be subscribed without duplicates.
+     */
+    subscribedStateChannels = new Set();
+    /** Convenience accessor matching the shape expected by external-mcp module */
+    get externalMCPState() {
+        return {
+            externalMCPs: this.externalMCPs,
+            externalMCPClients: this.externalMCPClients,
+            externalMCPSDKClients: this.externalMCPSDKClients,
+        };
+    }
+}
+const ctx = new BeamContext();
 // Delegates — external MCP management now in beam/external-mcp.ts
-const externalMCPState = { externalMCPs, externalMCPClients, externalMCPSDKClients };
-const loadExternalMCPs = (config) => loadExternalMCPsFromModule(config, externalMCPState);
-const reconnectExternalMCP = (name) => reconnectExternalMCPFromModule(name, externalMCPState);
+const loadExternalMCPs = (config) => loadExternalMCPsFromModule(config, ctx.externalMCPState);
+const reconnectExternalMCP = (name) => reconnectExternalMCPFromModule(name, ctx.externalMCPState);
 // Delegates to extracted config module
 const migrateConfig = migrateConfigFromModule;
 const loadConfig = loadConfigFromModule;
@@ -135,19 +161,8 @@ const extractClassMetadataFromSource = extractClassMetadataFromModule;
 const applyMethodVisibility = applyMethodVisibilityFromModule;
 const extractCspFromSource = extractCspFromModule;
 // ═══════════════════════════════════════════════════════════════════════════════
-// NOTIFICATION SUBSCRIPTIONS
+// NOTIFICATION SUBSCRIPTIONS (state lives in ctx: BeamContext)
 // ═══════════════════════════════════════════════════════════════════════════════
-/**
- * Map to store notification subscriptions per photon
- * Key: photon name, Value: list of event types this photon cares about
- * Example: { "chat": ["mentions", "direct-messages"], "tasks": ["deadline", "assigned-to-me"] }
- */
-const photonNotificationSubscriptions = new Map();
-/**
- * Track which state-changed channels we've already subscribed to,
- * so dynamically discovered photons can be subscribed without duplicates.
- */
-const subscribedStateChannels = new Set();
 /**
  * Generate the service worker JS that validates the Beam backend
  * on PWA launch and shows a diagnostic page if something is wrong.
@@ -460,6 +475,16 @@ const BOOT_PAGE = \`<!DOCTYPE html>
 export async function startBeam(rawWorkingDir, port) {
     const workingDir = path.resolve(rawWorkingDir);
     const { PHOTON_VERSION } = await import('../version.js');
+    // Run startup migrations (fast no-op when already applied)
+    try {
+        const { runNamespaceMigration } = await import('../namespace-migration.js');
+        await runNamespaceMigration();
+        const { runDataMigration } = await import('../data-migration.js');
+        await runDataMigration();
+    }
+    catch {
+        // Non-critical
+    }
     // StartupSequencer manages ordered output during startup
     const startup = new StartupSequencer(PHOTON_VERSION, workingDir);
     const isTTY = process.stderr.isTTY;
@@ -513,7 +538,7 @@ export async function startBeam(rawWorkingDir, port) {
     }
     // Build photon list with short names plus a numeric suffix for duplicates.
     // Also track resolved paths from namespace scan.
-    const namespacePaths = new Map(); // displayName → filePath
+    const photonRouteMeta = new Map(); // displayName → route metadata
     const userPhotonList = [];
     const duplicateIndex = new Map();
     for (const p of userPhotonListDetailed) {
@@ -522,7 +547,12 @@ export async function startBeam(rawWorkingDir, port) {
         duplicateIndex.set(p.name, nextIndex);
         const displayName = duplicateCount > 1 ? `${p.name} (${nextIndex})` : p.name;
         userPhotonList.push(displayName);
-        namespacePaths.set(displayName, p.filePath);
+        photonRouteMeta.set(displayName, {
+            filePath: p.filePath,
+            shortName: p.name,
+            namespace: p.namespace || undefined,
+            qualifiedName: p.qualifiedName || undefined,
+        });
     }
     // Add bundled photons with their paths
     const bundledPhotonPaths = new Map();
@@ -562,10 +592,11 @@ export async function startBeam(rawWorkingDir, port) {
     // Helper: load a single photon, returning the info to push into photons[]
     async function loadSinglePhoton(name) {
         const photonPath = bundledPhotonPaths.get(name) ||
-            namespacePaths.get(name) ||
+            photonRouteMeta.get(name)?.filePath ||
             (await resolvePhotonPath(name, workingDir));
         if (!photonPath)
             return null;
+        const routeMeta = photonRouteMeta.get(name);
         // Apply saved config to environment before loading
         if (savedConfig.photons[name]) {
             for (const [key, value] of Object.entries(savedConfig.photons[name])) {
@@ -580,7 +611,9 @@ export async function startBeam(rawWorkingDir, port) {
         let isInternal;
         try {
             source = await readText(photonPath);
-            await ensurePhotonEditorDeclaration(photonPath, source, workingDir).catch(() => { });
+            await ensurePhotonEditorDeclaration(photonPath, source, workingDir).catch((e) => {
+                logger.debug(`Failed to ensure editor declaration for ${photonPath}: ${e?.message || e}`);
+            });
         }
         catch {
             // Can't read source
@@ -662,11 +695,11 @@ export async function startBeam(rawWorkingDir, port) {
             mcp.schemas = schemas;
             // Store notification subscriptions per photon
             if (metadata.notificationSubscriptions?.watchFor) {
-                photonNotificationSubscriptions.set(name, metadata.notificationSubscriptions.watchFor);
+                ctx.photonNotificationSubscriptions.set(name, metadata.notificationSubscriptions.watchFor);
             }
             else {
                 // Clear previous subscription if photon no longer has @notify-on
-                photonNotificationSubscriptions.delete(name);
+                ctx.photonNotificationSubscriptions.delete(name);
             }
             // Get UI assets for linking
             const uiAssets = mcp.assets?.ui || [];
@@ -804,6 +837,9 @@ export async function startBeam(rawWorkingDir, port) {
             return {
                 id: generatePhotonId(photonPath),
                 name,
+                ...(routeMeta?.shortName ? { shortName: routeMeta.shortName } : {}),
+                ...(routeMeta?.namespace ? { namespace: routeMeta.namespace } : {}),
+                ...(routeMeta?.qualifiedName ? { qualifiedName: routeMeta.qualifiedName } : {}),
                 path: photonPath,
                 configured: true,
                 methods,
@@ -834,6 +870,9 @@ export async function startBeam(rawWorkingDir, port) {
             return {
                 id: generatePhotonId(photonPath),
                 name,
+                ...(routeMeta?.shortName ? { shortName: routeMeta.shortName } : {}),
+                ...(routeMeta?.namespace ? { namespace: routeMeta.namespace } : {}),
+                ...(routeMeta?.qualifiedName ? { qualifiedName: routeMeta.qualifiedName } : {}),
                 path: photonPath,
                 configured: false,
                 label: prettifyName(name),
@@ -859,6 +898,7 @@ export async function startBeam(rawWorkingDir, port) {
         if (!photon || !photon.configured)
             return null;
         const photonDir = path.dirname(photon.path);
+        const photonBaseName = path.basename(photon.path, '.photon.ts');
         const asset = photon.assets?.ui?.find((u) => u.id === uiId);
         let uiPath;
         if (asset?.resolvedPath) {
@@ -866,8 +906,8 @@ export async function startBeam(rawWorkingDir, port) {
         }
         else {
             // Prefer .photon.html, then .photon.md, fall back to .html
-            const photonHtmlPath = path.join(photonDir, photonName, 'ui', `${uiId}.photon.html`);
-            const photonMdPath = path.join(photonDir, photonName, 'ui', `${uiId}.photon.md`);
+            const photonHtmlPath = path.join(photonDir, photonBaseName, 'ui', `${uiId}.photon.html`);
+            const photonMdPath = path.join(photonDir, photonBaseName, 'ui', `${uiId}.photon.md`);
             try {
                 await fs.access(photonHtmlPath);
                 uiPath = photonHtmlPath;
@@ -878,7 +918,7 @@ export async function startBeam(rawWorkingDir, port) {
                     uiPath = photonMdPath;
                 }
                 catch {
-                    uiPath = path.join(photonDir, photonName, 'ui', `${uiId}.html`);
+                    uiPath = path.join(photonDir, photonBaseName, 'ui', `${uiId}.html`);
                 }
             }
         }
@@ -894,7 +934,7 @@ export async function startBeam(rawWorkingDir, port) {
         // Convention: format-<name> maps to assets/formats/<name>.html
         if (uiId.startsWith('format-')) {
             const formatName = uiId.slice('format-'.length);
-            const formatPath = path.join(photonDir, photonName, 'assets', 'formats', `${formatName}.html`);
+            const formatPath = path.join(photonDir, photonBaseName, 'assets', 'formats', `${formatName}.html`);
             try {
                 const content = await readText(formatPath);
                 return { content, isPhotonTemplate: false };
@@ -931,9 +971,9 @@ export async function startBeam(rawWorkingDir, port) {
         savedConfig,
         photons,
         photonMCPs,
-        externalMCPs,
-        externalMCPClients,
-        externalMCPSDKClients,
+        externalMCPs: ctx.externalMCPs,
+        externalMCPClients: ctx.externalMCPClients,
+        externalMCPSDKClients: ctx.externalMCPSDKClients,
         channelSubscriptions: new Map(),
         channelEventBuffers: new Map(),
         sessionViewState: new Map(),
@@ -983,10 +1023,11 @@ export async function startBeam(rawWorkingDir, port) {
                     baseUrl: `http://${req.headers.host}`,
                     version: PHOTON_VERSION,
                 });
-                res.writeHead(200, {
-                    'Content-Type': 'application/json',
-                    'Access-Control-Allow-Origin': '*',
-                });
+                const cardHeaders = { 'Content-Type': 'application/json' };
+                const cardCorsOrigin = getCorsOrigin(req);
+                if (cardCorsOrigin)
+                    cardHeaders['Access-Control-Allow-Origin'] = cardCorsOrigin;
+                res.writeHead(200, cardHeaders);
                 res.end(JSON.stringify(card));
                 return;
             }
@@ -1037,9 +1078,9 @@ export async function startBeam(rawWorkingDir, port) {
                 const handled = await handleStreamableHTTP(req, res, {
                     photons, // Pass all photons including unconfigured for configurationSchema
                     photonMCPs,
-                    externalMCPs,
-                    externalMCPClients,
-                    externalMCPSDKClients, // SDK clients for tool calls with structuredContent
+                    externalMCPs: ctx.externalMCPs,
+                    externalMCPClients: ctx.externalMCPClients,
+                    externalMCPSDKClients: ctx.externalMCPSDKClients, // SDK clients for tool calls with structuredContent
                     reconnectExternalMCP,
                     loadUIAsset,
                     workingDir,
@@ -1049,8 +1090,12 @@ export async function startBeam(rawWorkingDir, port) {
                     reloadPhoton: async (photonName) => {
                         return reloadPhotonViaMCP(photonName, photons, photonMCPs, loader, savedConfig, broadcastPhotonChange, activeLoads, (name, path, isStateful) => {
                             if (isStateful) {
-                                subscribeStatefulPhoton(name).catch(() => { });
-                                reloadDaemonPhoton(name, path, workingDir).catch(() => { });
+                                subscribeStatefulPhoton(name).catch((e) => {
+                                    logger.debug(`Failed to subscribe stateful photon ${name}: ${e?.message || e}`);
+                                });
+                                reloadDaemonPhoton(name, path, workingDir).catch((e) => {
+                                    logger.debug(`Failed to reload daemon photon ${name}: ${e?.message || e}`);
+                                });
                             }
                         });
                     },
@@ -1474,9 +1519,27 @@ export async function startBeam(rawWorkingDir, port) {
         appEl.appendChild(iframe);
         initBridge(iframe, bridgeMethod);
       } catch (err) {
-        appEl.innerHTML = '<div class="status-page show"><div class="icon">⚠️</div>'
-          + '<h2>Failed to load</h2><p>' + err.message + '</p>'
-          + '<button class="retry-btn" onclick="checkAndLoad()">Retry</button></div>';
+        appEl.innerHTML = '';
+        const statusDiv = document.createElement('div');
+        statusDiv.className = 'status-page show';
+
+        const icon = document.createElement('div');
+        icon.className = 'icon';
+        icon.textContent = '⚠️';
+
+        const h2 = document.createElement('h2');
+        h2.textContent = 'Failed to load';
+
+        const p = document.createElement('p');
+        p.textContent = err.message;
+
+        const btn = document.createElement('button');
+        btn.className = 'retry-btn';
+        btn.textContent = 'Retry';
+        btn.addEventListener('click', () => checkAndLoad());
+
+        statusDiv.append(icon, h2, p, btn);
+        appEl.appendChild(statusDiv);
       }
     }
 
@@ -1851,14 +1914,35 @@ export async function startBeam(rawWorkingDir, port) {
         const relativePath = path.relative(workingDir, changedPath);
         // React to .photon.ts file changes — both top-level and namespaced subdirectories.
         // Top-level: foo.photon.ts → "foo"
-        // Namespaced: portel/gitbox.photon.ts → "portel/gitbox"
+        // Namespaced: Arul-/git-box.photon.ts → "git-box" (short name only)
         if (relativePath.endsWith('.photon.ts')) {
-            return relativePath.slice(0, -'.photon.ts'.length);
+            // For namespaced paths, look up by file path first to respect disambiguated
+            // names like "chat (1)" / "chat (2)" assigned at startup
+            let resolvedPath;
+            try {
+                resolvedPath = realpathSync(changedPath);
+            }
+            catch {
+                resolvedPath = changedPath;
+            }
+            const byPath = photons.find((p) => {
+                try {
+                    return realpathSync(p.path) === resolvedPath;
+                }
+                catch {
+                    return p.path === changedPath;
+                }
+            });
+            if (byPath)
+                return byPath.name;
+            // New photon — derive short name from filename
+            const withoutExt = relativePath.slice(0, -'.photon.ts'.length);
+            const slashIndex = withoutExt.lastIndexOf(path.sep);
+            return slashIndex >= 0 ? withoutExt.slice(slashIndex + 1) : withoutExt;
         }
-        // Detect asset file changes for local (non-symlinked) photons.
-        // Asset folders live at <workingDir>/<photonName>/ for local photons.
-        // NOTE: Do NOT match runtime data directories (state/, media/, auth/) — only
-        // photon asset directories are relevant here, identified by the loaded photons list.
+        // Detect asset changes for local (non-symlinked) photons.
+        // Runtime data now lives in .data/ (filtered above), so any remaining
+        // file under {photonName}/ is a legitimate asset (ui/, etc.).
         for (const p of photons) {
             if (relativePath.startsWith(p.name + path.sep)) {
                 return p.name;
@@ -1886,9 +1970,37 @@ export async function startBeam(rawWorkingDir, port) {
                 try {
                     const photonIndex = photons.findIndex((p) => p.name === photonName);
                     const isNewPhoton = photonIndex === -1;
-                    const photonPath = isNewPhoton
-                        ? path.join(workingDir, `${photonName}.photon.ts`)
-                        : photons[photonIndex].path;
+                    let photonPath;
+                    if (!isNewPhoton) {
+                        photonPath = photons[photonIndex].path;
+                    }
+                    else {
+                        // Try flat path first, then search namespace subdirectories
+                        const flatPath = path.join(workingDir, `${photonName}.photon.ts`);
+                        if (existsSync(flatPath)) {
+                            photonPath = flatPath;
+                        }
+                        else {
+                            // Search namespace dirs (one level deep) for the photon file
+                            let found = null;
+                            try {
+                                const entries = await fs.readdir(workingDir, { withFileTypes: true });
+                                for (const entry of entries) {
+                                    if (!entry.isDirectory() || entry.name.startsWith('.'))
+                                        continue;
+                                    const candidate = path.join(workingDir, entry.name, `${photonName}.photon.ts`);
+                                    if (existsSync(candidate)) {
+                                        found = candidate;
+                                        break;
+                                    }
+                                }
+                            }
+                            catch {
+                                // readdir failed
+                            }
+                            photonPath = found || flatPath;
+                        }
+                    }
                     const previouslyConfigured = !isNewPhoton && photons[photonIndex]?.configured === true;
                     // Handle file deletion - if file no longer exists and photon is in list, remove it
                     if (!isNewPhoton && photonPath && !existsSync(photonPath)) {
@@ -1961,7 +2073,9 @@ export async function startBeam(rawWorkingDir, port) {
                         let constructorParams = [];
                         try {
                             const source = await readText(photonPath);
-                            await writePhotonEditorDeclaration(photonPath, source, workingDir).catch(() => { });
+                            await writePhotonEditorDeclaration(photonPath, source, workingDir).catch((e) => {
+                                logger.debug(`Failed to write editor declaration for ${photonPath}: ${e?.message || e}`);
+                            });
                             const params = extractor.extractConstructorParams(source);
                             constructorParams = params
                                 .filter((p) => p.isPrimitive)
@@ -2016,10 +2130,10 @@ export async function startBeam(rawWorkingDir, port) {
                         mcp.schemas = schemas; // Store schemas for result rendering
                         // Update notification subscriptions for reloaded photon
                         if (reloadMetadata.notificationSubscriptions?.watchFor) {
-                            photonNotificationSubscriptions.set(photonName, reloadMetadata.notificationSubscriptions.watchFor);
+                            ctx.photonNotificationSubscriptions.set(photonName, reloadMetadata.notificationSubscriptions.watchFor);
                         }
                         else {
-                            photonNotificationSubscriptions.delete(photonName);
+                            ctx.photonNotificationSubscriptions.delete(photonName);
                         }
                         const lifecycleMethods = ['onInitialize', 'onShutdown', 'constructor'];
                         const uiAssets = mcp.assets?.ui || [];
@@ -2242,6 +2356,9 @@ export async function startBeam(rawWorkingDir, port) {
         const watcher = watch(workingDir, { recursive: true }, (eventType, filename) => {
             if (!filename)
                 return;
+            // Skip all runtime data — .data/ contains all photon data, never source code
+            if (filename.startsWith('.data' + path.sep) || filename === '.data')
+                return;
             const fullPath = path.join(workingDir, filename);
             logger.debug(`📂 File event: ${eventType} ${filename}`);
             const photonName = getPhotonForPath(fullPath);
@@ -2375,7 +2492,7 @@ export async function startBeam(rawWorkingDir, port) {
     }
     // Load external MCPs from config
     const externalMCPList = await loadExternalMCPs(savedConfig);
-    externalMCPs.push(...externalMCPList);
+    ctx.externalMCPs.push(...externalMCPList);
     // Mark startup complete — flushes queued output and restores console
     startup.ready();
     // Notify connected clients that photon list is now available
@@ -2386,9 +2503,9 @@ export async function startBeam(rawWorkingDir, port) {
         const instanceNames = ['default'];
         for (const instanceName of instanceNames) {
             const channel = `${photonName}:${instanceName}:state-changed`;
-            if (subscribedStateChannels.has(channel))
+            if (ctx.subscribedStateChannels.has(channel))
                 continue;
-            subscribedStateChannels.add(channel);
+            ctx.subscribedStateChannels.add(channel);
             subscribeChannel(photonName, channel, (message) => {
                 // Sync Beam's local instance from the daemon-persisted state file BEFORE
                 // notifying the frontend. The daemon persists state to disk after mutations,
@@ -2479,7 +2596,7 @@ export async function startBeam(rawWorkingDir, port) {
                 // Subscribe to notifications channel (always-on, not just active)
                 const notificationChannel = `${photonName}:${instanceName}:notifications`;
                 // Get this photon's notification subscriptions from @notify-on tags
-                const watchFor = photonNotificationSubscriptions.get(photonName);
+                const watchFor = ctx.photonNotificationSubscriptions.get(photonName);
                 subscribeChannel(photonName, notificationChannel, (message) => {
                     // Check if this photon cares about this notification type
                     if (!watchFor || !watchFor.includes(message?.type)) {
@@ -2666,14 +2783,14 @@ export async function startBeam(rawWorkingDir, port) {
                     // Remove MCPs — do all synchronous Map mutations first, then close async
                     const removedSdkClients = [];
                     for (const name of removed) {
-                        const idx = externalMCPs.findIndex((m) => m.name === name);
+                        const idx = ctx.externalMCPs.findIndex((m) => m.name === name);
                         if (idx !== -1)
-                            externalMCPs.splice(idx, 1);
-                        const sdkClient = externalMCPSDKClients.get(name);
+                            ctx.externalMCPs.splice(idx, 1);
+                        const sdkClient = ctx.externalMCPSDKClients.get(name);
                         if (sdkClient)
                             removedSdkClients.push({ name, client: sdkClient });
-                        externalMCPSDKClients.delete(name);
-                        externalMCPClients.delete(name);
+                        ctx.externalMCPSDKClients.delete(name);
+                        ctx.externalMCPClients.delete(name);
                         logger.info(`🔌 Removed external MCP: ${name}`);
                     }
                     // Close SDK clients after all Maps are consistent
@@ -2692,7 +2809,7 @@ export async function startBeam(rawWorkingDir, port) {
                             mcpServers: Object.fromEntries(added.map((k) => [k, newServers[k]])),
                         };
                         const newMCPs = await loadExternalMCPs(addConfig);
-                        externalMCPs.push(...newMCPs);
+                        ctx.externalMCPs.push(...newMCPs);
                         for (const m of newMCPs) {
                             logger.info(`🔌 Added external MCP: ${m.name} (${m.connected ? m.methods.length + ' tools' : 'failed'})`);
                         }
@@ -2700,14 +2817,14 @@ export async function startBeam(rawWorkingDir, port) {
                     // Reconnect modified MCPs — synchronous cleanup first, then async reconnect
                     const modifiedSdkClients = [];
                     for (const name of modified) {
-                        const idx = externalMCPs.findIndex((m) => m.name === name);
+                        const idx = ctx.externalMCPs.findIndex((m) => m.name === name);
                         if (idx !== -1)
-                            externalMCPs.splice(idx, 1);
-                        const sdkClient = externalMCPSDKClients.get(name);
+                            ctx.externalMCPs.splice(idx, 1);
+                        const sdkClient = ctx.externalMCPSDKClients.get(name);
                         if (sdkClient)
                             modifiedSdkClients.push({ name, client: sdkClient });
-                        externalMCPSDKClients.delete(name);
-                        externalMCPClients.delete(name);
+                        ctx.externalMCPSDKClients.delete(name);
+                        ctx.externalMCPClients.delete(name);
                     }
                     // Close old SDK clients
                     for (const { client } of modifiedSdkClients) {
@@ -2725,7 +2842,7 @@ export async function startBeam(rawWorkingDir, port) {
                             mcpServers: { [name]: newServers[name] },
                         };
                         const reconnected = await loadExternalMCPs(modConfig);
-                        externalMCPs.push(...reconnected);
+                        ctx.externalMCPs.push(...reconnected);
                         logger.info(`🔌 Reconnected external MCP: ${name}`);
                     }
                     // Update savedConfig
@@ -2753,9 +2870,11 @@ export async function startBeam(rawWorkingDir, port) {
  * Closes all external MCP SDK clients to prevent ugly tracebacks on shutdown.
  */
 export async function stopBeam() {
+    // Stop session cleanup timer
+    stopSessionCleanup();
     // Close all SDK clients gracefully
     const closePromises = [];
-    for (const [, client] of externalMCPSDKClients) {
+    for (const [, client] of ctx.externalMCPSDKClients) {
         closePromises.push(client.close().catch(() => {
             // Ignore close errors - process is exiting anyway
         }));
@@ -2764,7 +2883,7 @@ export async function stopBeam() {
     if (closePromises.length > 0) {
         await withTimeout(Promise.all(closePromises), 1000, 'MCP client close timeout').catch(() => { }); // Timeout during shutdown is expected
     }
-    externalMCPSDKClients.clear();
-    externalMCPClients.clear();
+    ctx.externalMCPSDKClients.clear();
+    ctx.externalMCPClients.clear();
 }
 //# sourceMappingURL=beam.js.map