@amodalai/runtime 0.1.25 → 0.2.0

package/dist/src/agent/local-server.js

@@ -1,17 +1,31 @@
 /**
  * @license
- * Copyright 2025 Amodal Labs, Inc.
+ * Copyright 2026 Amodal Labs, Inc.
  * SPDX-License-Identifier: MIT
  */
+/**
+ * Local server for repo-based agent mode.
+ *
+ * Loads the `.amodal/` config from `config.repoPath`, creates a
+ * StandaloneSessionManager, mounts all routes, and optionally watches
+ * for config changes (hot reload).
+ *
+ * Replaces the old initialization sequence that depended on gemini-cli-core's
+ * Config, GeminiClient, and upstream ToolRegistry.
+ */
 import express from 'express';
 import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { loadRepo } from '@amodalai/core';
-import { SessionManager } from '../session/session-manager.js';
-import { LocalShellExecutor } from './shell-executor-local.js';
+import { StandaloneSessionManager } from '../session/manager.js';
+import { PGLiteSessionStore } from '../session/store.js';
+import { buildSessionComponents } from '../session/session-builder.js';
+import { LocalToolExecutor } from './tool-executor-local.js';
+import { buildMcpConfigs } from './mcp-config.js';
 import { ConfigWatcher } from './config-watcher.js';
 import { ProactiveRunner } from './proactive/proactive-runner.js';
 import { createChatStreamRouter } from '../routes/chat-stream.js';
+import { createChatRouter } from '../routes/chat.js';
 import { createAdminChatRouter } from './routes/admin-chat.js';
 import { createTaskRouter } from './routes/task.js';
 import { createInspectRouter } from './routes/inspect.js';
@@ -28,15 +42,10 @@ import { SessionStore } from './session-store.js';
 import { EvalStore } from './eval-store.js';
 import { buildPages } from './page-builder.js';
 import { LOCAL_APP_ID } from '../constants.js';
-import { log } from '../logger.js';
+import { log, createLogger } from '../logger.js';
 const PROVIDER_CHECKS = [
-    { provider: 'anthropic', envVar: 'ANTHROPIC_API_KEY', url: 'https://api.anthropic.com/v1/models', authHeader: (k) => ({ 'x-api-key': k, 'anthropic-version': '2023-06-01' }) },
-    { provider: 'openai', envVar: 'OPENAI_API_KEY', url: 'https://api.openai.com/v1/models?limit=1', authHeader: (k) => ({ Authorization: `Bearer ${k}` }) },
-    { provider: 'google', envVar: 'GOOGLE_API_KEY', url: 'https://generativelanguage.googleapis.com/v1beta/models?pageSize=1', authHeader: (k) => ({ 'x-goog-api-key': k }) },
-    { provider: 'deepseek', envVar: 'DEEPSEEK_API_KEY', url: 'https://api.deepseek.com/v1/models', authHeader: (k) => ({ Authorization: `Bearer ${k}` }) },
-    { provider: 'groq', envVar: 'GROQ_API_KEY', url: 'https://api.groq.com/openai/v1/models', authHeader: (k) => ({ Authorization: `Bearer ${k}` }) },
-    { provider: 'mistral', envVar: 'MISTRAL_API_KEY', url: 'https://api.mistral.ai/v1/models', authHeader: (k) => ({ Authorization: `Bearer ${k}` }) },
-    { provider: 'xai', envVar: 'XAI_API_KEY', url: 'https://api.x.ai/v1/models', authHeader: (k) => ({ Authorization: `Bearer ${k}` }) },
+    { provider: 'anthropic', envVar: 'ANTHROPIC_API_KEY', url: 'https://api.anthropic.com/v1/messages', authHeader: (key) => ({ 'x-api-key': key, 'anthropic-version': '2023-06-01' }) },
+    { provider: 'openai', envVar: 'OPENAI_API_KEY', url: 'https://api.openai.com/v1/models', authHeader: (key) => ({ Authorization: `Bearer ${key}` }) },
 ];
 async function checkProviders() {
     const results = await Promise.allSettled(PROVIDER_CHECKS.map(async (check) => {
@@ -45,7 +54,6 @@ async function checkProviders() {
             return { provider: check.provider, envVar: check.envVar, keySet: false, verified: false };
         }
         try {
-            // globalThis.fetch is available in Node 18+
             const res = await globalThis.fetch(check.url, {
                 method: 'GET',
                 headers: check.authHeader(key),
@@ -62,46 +70,51 @@ async function checkProviders() {
     }));
     return results.map((r) => r.status === 'fulfilled' ? r.value : { provider: 'unknown', envVar: '', keySet: false, verified: false });
 }
+// ---------------------------------------------------------------------------
+// Local server
+// ---------------------------------------------------------------------------
 /**
  * Creates an Express server for repo-based agent mode.
  *
  * Loads the `.amodal/` config from `config.repoPath`, creates a
- * `SessionManager`, mounts chat/task/inspect/automation/webhook routes,
- * and optionally watches for config changes (hot reload).
+ * `StandaloneSessionManager`, mounts all routes, and optionally watches
+ * for config changes (hot reload).
  */
 export async function createLocalServer(config) {
-    const repo = await loadRepo({ localPath: config.repoPath });
+    let bundle = await loadRepo({ localPath: config.repoPath });
     // Check provider API keys in the background at startup
     let providerStatuses = PROVIDER_CHECKS.map((c) => ({
         provider: c.provider, envVar: c.envVar, keySet: !!process.env[c.envVar], verified: false,
     }));
-    checkProviders().then((results) => {
+    void checkProviders().then((results) => {
         providerStatuses = results;
         const verified = results.filter((r) => r.verified).map((r) => r.provider);
         if (verified.length > 0) {
-            process.stderr.write(`[dev] Provider keys verified: ${verified.join(', ')}\n`);
+            log.info('provider_keys_verified', { providers: verified });
         }
         const failed = results.filter((r) => r.keySet && !r.verified);
         for (const f of failed) {
-            process.stderr.write(`[dev] Provider key invalid: ${f.provider} (${f.error ?? 'unknown'})\n`);
+            log.warn('provider_key_invalid', { provider: f.provider, error: f.error });
         }
-    }).catch(() => { });
-    // Create shell executor if sandbox.shellExec is enabled
-    const shellExecutor = repo.config.sandbox?.shellExec
-        ? new LocalShellExecutor()
-        : undefined;
-    // Create shared store backend if stores are defined
+    }).catch((err) => {
+        log.error('provider_check_failed', { error: err instanceof Error ? err.message : String(err) });
+    });
+    // Create custom tool executor
+    const toolExecutor = bundle.tools.length > 0 ? new LocalToolExecutor() : undefined;
+    // -------------------------------------------------------------------------
+    // Store backend
+    // -------------------------------------------------------------------------
     let storeBackend;
     let storeBackendType = 'none';
-    if (repo.stores.length > 0) {
-        const storeConfig = repo.config.stores;
+    if (bundle.stores.length > 0) {
+        const storeConfig = bundle.config.stores;
         const backend = storeConfig?.backend ?? 'pglite';
         if (backend === 'postgres' && storeConfig?.postgresUrl) {
             const connUrl = storeConfig.postgresUrl.startsWith('env:')
                 ? process.env[storeConfig.postgresUrl.slice(4)] ?? ''
                 : storeConfig.postgresUrl;
             if (!connUrl) {
-                log.error(`Postgres URL not set (${storeConfig.postgresUrl})`, 'dev');
+                log.error('store_postgres_url_missing', { configured: storeConfig.postgresUrl });
             }
             else {
                 try {
@@ -109,95 +122,150 @@ export async function createLocalServer(config) {
                     // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- dynamic import for optional postgres backend
                     const mod = await import(pgModPath).catch(() => null);
                     if (mod?.createPostgresStoreBackend) {
-                        storeBackend = await mod.createPostgresStoreBackend(repo.stores, connUrl);
+                        storeBackend = await mod.createPostgresStoreBackend(bundle.stores, connUrl);
                         storeBackendType = 'postgres';
-                        log.info(`Store backend ready (postgres, ${String(repo.stores.length)} stores)`, 'dev');
+                        log.info('store_backend_ready', { type: 'postgres', storeCount: bundle.stores.length });
                     }
                     else {
-                        log.error('Postgres backend not available — install @amodalai/store-postgres', 'dev');
+                        log.error('store_postgres_unavailable', { hint: 'install @amodalai/store-postgres' });
                     }
                 }
                 catch (err) {
-                    log.error(`Postgres store backend failed: ${err instanceof Error ? err.message : String(err)}`, 'dev');
-                    log.info('Falling back to PGLite', 'dev');
+                    log.error('store_postgres_failed', { error: err instanceof Error ? err.message : String(err) });
+                    log.info('store_fallback_pglite', {});
                 }
             }
         }
         // Default: PGLite
         if (!storeBackend) {
             const dataDir = storeConfig?.dataDir ?? `${config.repoPath}/.amodal/store-data`;
-            // Check for lock file — another instance may be using this data dir
-            const lockPath = `${dataDir}/server.lock`;
+            // Check for lock file — another instance may be using this data dir.
+            // Lock file lives in the PARENT dir (not inside dataDir) so it doesn't
+            // conflict with PGLite's own PostgreSQL data files (e.g. postmaster.pid).
+            const lockPath = `${dataDir}.lock`;
             try {
                 const { readFileSync, writeFileSync, mkdirSync, unlinkSync } = await import('node:fs');
-                mkdirSync(dataDir, { recursive: true });
+                const path = await import('node:path');
+                mkdirSync(path.dirname(dataDir), { recursive: true });
                 try {
                     const existing = readFileSync(lockPath, 'utf-8').trim();
                     try {
                         process.kill(Number(existing), 0);
-                        log.warn(`Another amodal instance (PID ${existing}) may be using this store directory. PGLite does not support concurrent access.`, 'dev');
+                        log.warn('store_lock_conflict', { pid: existing });
                     }
-                    catch { /* PID not running, stale lock */ }
+                    catch { /* PID not running — stale lock, safe to overwrite */ }
                 }
-                catch { /* no lock file */ }
+                catch { /* No lock file exists — first run */ }
                 writeFileSync(lockPath, String(process.pid));
                 const lockCleanup = lockPath;
                 process.on('exit', () => { try {
                     unlinkSync(lockCleanup);
                 }
-                catch { /* */ } });
+                catch { /* exit handler — can't log */ } });
+            }
+            catch (err) {
+                log.warn('store_lock_setup_failed', { dataDir, error: err instanceof Error ? err.message : String(err) });
             }
-            catch { /* lock file handling failed, proceed anyway */ }
             try {
-                storeBackend = await createPGLiteStoreBackend(repo.stores, dataDir);
+                storeBackend = await createPGLiteStoreBackend(bundle.stores, dataDir);
                 storeBackendType = 'pglite';
-                log.info(`Store backend ready (pglite, ${String(repo.stores.length)} stores, dir: ${dataDir})`, 'dev');
+                log.info('store_backend_ready', { type: 'pglite', storeCount: bundle.stores.length, dataDir });
             }
             catch (err) {
-                log.error(`Store backend failed to initialize: ${err instanceof Error ? err.message : String(err)}`, 'dev');
-                log.error(`Try deleting ${dataDir} and restarting`, 'dev');
+                const errMsg = err instanceof Error ? err.message : (typeof err === 'object' ? JSON.stringify(err) : String(err));
+                log.error('store_backend_init_failed', { error: errMsg, dataDir });
             }
         }
     }
-    // Session persistence — created before SessionManager so hydration works
-    const sessionStore = new SessionStore(config.repoPath);
-    const sessionManager = new SessionManager({
-        baseParams: {
-            sessionId: 'local-init',
-            interactive: false,
-            noBrowser: true,
-            debugMode: process.env['DEBUG'] === 'true',
-            cwd: config.repoPath,
-            targetDir: config.repoPath,
-        },
+    // -------------------------------------------------------------------------
+    // Session manager (new standalone stack)
+    // -------------------------------------------------------------------------
+    const sessionLogger = createLogger({ component: 'session-manager' });
+    const sessionStore = new PGLiteSessionStore({ logger: sessionLogger });
+    await sessionStore.initialize();
+    const sessionManager = new StandaloneSessionManager({
+        logger: sessionLogger,
+        store: sessionStore,
         ttlMs: config.sessionTtlMs,
-        bundle: repo,
-        shellExecutor,
-        storeBackend,
-        sessionStore: {
-            async getSession(sessionId) {
-                const persisted = sessionStore.load(sessionId);
-                if (!persisted || !persisted.conversationHistory.length)
-                    return null;
-                return {
-                    id: persisted.id,
-                    app_id: persisted.appId,
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Persisted data
-                    messages: persisted.conversationHistory,
-                    status: 'completed',
-                };
-            },
-        },
     });
-    const runner = new ProactiveRunner(repo, {
+    sessionManager.start();
+    // Legacy session store for UI history (file-based)
+    const legacySessionStore = new SessionStore(config.repoPath);
+    // -------------------------------------------------------------------------
+    // MCP connections (shared across sessions)
+    // -------------------------------------------------------------------------
+    let mcpManager = null;
+    {
+        const { McpManager } = await import('@amodalai/core');
+        const mcpConfigs = buildMcpConfigs(bundle);
+        if (Object.keys(mcpConfigs).length > 0) {
+            const manager = new McpManager();
+            try {
+                await manager.startServers(mcpConfigs);
+                if (manager.connectedCount > 0) {
+                    mcpManager = manager;
+                    const tools = manager.getDiscoveredTools();
+                    log.info('mcp_initialized', { servers: manager.connectedCount, tools: tools.length });
+                }
+            }
+            catch (err) {
+                log.error('mcp_init_failed', { error: err instanceof Error ? err.message : String(err) });
+            }
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Shared resources for route handlers
+    // -------------------------------------------------------------------------
+    const shared = {
+        storeBackend: storeBackend ?? null,
+        mcpManager,
+        logger: log,
+        toolExecutor,
+    };
+    // Helper: get current bundle (updated by config watcher)
+    const getBundle = () => bundle;
+    // Helper: create automation session components
+    const createAutomationSessionComponents = () => {
+        const components = buildSessionComponents({
+            bundle,
+            storeBackend: storeBackend ?? null,
+            mcpManager,
+            logger: log,
+            toolExecutor,
+            sessionType: 'automation',
+        });
+        const session = sessionManager.create({
+            tenantId: 'local',
+            userId: 'automation',
+            provider: components.provider,
+            toolRegistry: components.toolRegistry,
+            permissionChecker: components.permissionChecker,
+            systemPrompt: components.systemPrompt,
+            userRoles: components.userRoles,
+            toolContextFactory: components.toolContextFactory,
+            appId: LOCAL_APP_ID,
+        });
+        return { session, toolContextFactory: components.toolContextFactory };
+    };
+    // -------------------------------------------------------------------------
+    // Proactive runner
+    // -------------------------------------------------------------------------
+    const runner = new ProactiveRunner(bundle, {
+        sessionManager,
+        createSessionComponents: createAutomationSessionComponents,
+        logger: log,
         webhookSecret: config.webhookSecret,
-        createSession: async () => sessionManager.create(LOCAL_APP_ID),
-        destroySession: async (id) => sessionManager.destroy(id),
-        onSessionComplete: (session, automationName) => {
-            sessionStore.save(session, automationName);
+        onSessionComplete: (session) => {
+            void sessionManager.persist(session);
         },
     });
+    // -------------------------------------------------------------------------
+    // Config watcher (hot reload)
+    // -------------------------------------------------------------------------
     let watcher = null;
+    // -------------------------------------------------------------------------
+    // Express app
+    // -------------------------------------------------------------------------
     const app = express();
     // CORS
     const corsOrigin = config.corsOrigin ?? '*';
@@ -227,9 +295,9 @@ export async function createLocalServer(config) {
     app.post('/auth/token', (_req, res) => {
         res.json({ token: '', expires_at: null });
     });
-    // Unified config endpoint — same path as hosted, different response
+    // Unified config endpoint
     app.get('/api/config', (_req, res) => {
-        const bundleData = sessionManager.getBundle();
+        const bundleData = getBundle();
         const cfg = bundleData.config;
         // Collect all env:* references from connection specs
         const envRefs = [];
@@ -241,11 +309,8 @@ export async function createLocalServer(config) {
             }
         }
         res.json({
-            // Common fields (used by useHostedConfig)
             appId: LOCAL_APP_ID,
             appName: cfg?.name ?? '',
-            // No authMode — signals to the SPA that no auth is needed
-            // Local dev fields (used by config pages)
             name: cfg?.name ?? '',
             version: cfg?.version ?? '',
             description: cfg?.description ?? '',
@@ -262,43 +327,38 @@ export async function createLocalServer(config) {
     // Resolve resume session ID
     let resumeSessionId = config.resumeSessionId;
     if (resumeSessionId === 'latest') {
-        resumeSessionId = sessionStore.latest() ?? undefined;
+        resumeSessionId = legacySessionStore.latest() ?? undefined;
     }
     if (resumeSessionId) {
-        log.debug(`Resume session: ${resumeSessionId}`, 'dev');
+        log.debug('resume_session', { sessionId: resumeSessionId });
     }
     // Client config — tells the web UI which session to resume
     app.get('/config', (_req, res) => {
         res.json({ resumeSessionId: resumeSessionId ?? null });
     });
-    // Sessions endpoints
+    // Sessions endpoints (legacy file-based store for UI history)
     app.get('/sessions', (req, res) => {
         const automationFilter = typeof req.query?.['automation'] === 'string' ? String(req.query['automation']) : undefined;
-        const all = sessionStore.list();
-        // Filter out eval and admin sessions from chat history
+        const all = legacySessionStore.list();
         const visible = all.filter((s) => s.appId !== 'eval-runner' && s.appId !== 'admin');
         const filtered = automationFilter ? visible.filter((s) => s.automationName === automationFilter) : visible;
         res.json({ sessions: filtered });
     });
     app.get('/session/:id', (req, res) => {
-        const persisted = sessionStore.load(req.params['id'] ?? '');
+        const persisted = legacySessionStore.load(req.params['id'] ?? '');
         if (!persisted) {
             res.status(404).json({ error: 'Session not found' });
             return;
         }
-        // Convert persisted messages to the format the UI expects.
-        // Supports both SessionMessage format ({type, text}) and legacy LLMMessage ({role, content}).
         const messages = persisted.conversationHistory.map((msg) => {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Persisted message
             const m = msg;
-            // SessionMessage format (new): {type: 'user'|'assistant_text'|'error', text, toolCalls?, ...}
             if (m['type'] === 'user') {
                 return { role: 'user', text: String(m['text'] ?? '') };
             }
             if (m['type'] === 'assistant_text') {
                 return { role: 'assistant', text: String(m['text'] ?? ''), toolCalls: m['toolCalls'] };
             }
-            // Legacy LLMMessage format: {role: 'user'|'assistant', content: string|Block[]}
             if (m['role'] === 'user') {
                 return { role: 'user', text: typeof m['content'] === 'string' ? m['content'] : '' };
             }
@@ -321,23 +381,17 @@ export async function createLocalServer(config) {
         }
         // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- validated above
         const title = body['title'];
-        const updated = sessionStore.updateTitle(sessionId, title);
+        const updated = legacySessionStore.updateTitle(sessionId, title);
         if (!updated) {
             res.status(404).json({ error: 'Session not found' });
             return;
         }
-        // Also update in-memory session if active
-        const activeSession = sessionManager.get(sessionId);
-        if (activeSession) {
-            activeSession.title = title;
-        }
         res.json({ ok: true });
     });
     app.delete('/session/:id', (req, res) => {
         const sessionId = req.params['id'] ?? '';
-        // Destroy in-memory session if active
         void sessionManager.destroy(sessionId);
-        const deleted = sessionStore.delete(sessionId);
+        const deleted = legacySessionStore.delete(sessionId);
         if (!deleted) {
             res.status(404).json({ error: 'Session not found' });
             return;
@@ -348,29 +402,69 @@ export async function createLocalServer(config) {
     app.use(createFilesRouter({ repoPath: config.repoPath }));
     // Evals
     const evalStore = new EvalStore(config.repoPath);
-    app.use(createEvalRouter({ sessionManager, evalStore, repoPath: config.repoPath, getPort: () => config.port }));
+    app.use(createEvalRouter({ getBundle, evalStore, repoPath: config.repoPath, getPort: () => config.port }));
     // Feedback
     const feedbackStore = new FeedbackStore(config.repoPath);
     app.use(createFeedbackRouter({ feedbackStore }));
-    // Routes
+    // Chat routes (new stack)
     app.use(createChatStreamRouter({
         sessionManager,
+        bundleResolver: { staticBundle: bundle },
+        shared,
         createStreamHooks: () => ({
             onSessionPersist: (sessionId) => {
                 const session = sessionManager.get(sessionId);
-                if (session)
-                    sessionStore.save(session);
+                if (session) {
+                    void sessionManager.persist(session);
+                    // Also mirror to the legacy file-based store so the /sessions
+                    // endpoints (read by the UI history panel) see chat sessions.
+                    // Without this, chat sessions only land in PGLite and the UI
+                    // only sees automation/task sessions. PGLite remains the source
+                    // of truth — a mirror failure is logged and swallowed (the hook
+                    // is invoked from fireDrainHooks after the response has drained,
+                    // so throwing here would break the route handler).
+                    try {
+                        legacySessionStore.save({
+                            id: session.id,
+                            appId: session.appId,
+                            title: session.metadata.title,
+                            messages: session.messages,
+                            createdAt: session.createdAt,
+                            lastAccessedAt: session.lastAccessedAt,
+                        });
+                    }
+                    catch (err) {
+                        log.warn('legacy_session_mirror_failed', {
+                            sessionId: session.id,
+                            error: err instanceof Error ? err.message : String(err),
+                        });
+                    }
+                }
             },
         }),
     }));
-    app.use(createTaskRouter({ sessionManager }));
-    app.use(createAdminChatRouter({ sessionManager, getPort: () => config.port }));
-    app.use(createInspectRouter({ sessionManager, repoPath: config.repoPath }));
+    app.use(createChatRouter({
+        sessionManager,
+        bundleResolver: { staticBundle: bundle },
+        shared,
+    }));
+    // Task runner
+    app.use(createTaskRouter({ sessionManager, createTaskSession: createAutomationSessionComponents }));
+    // Admin chat (new stack)
+    app.use(createAdminChatRouter({
+        sessionManager,
+        shared,
+        getBundle,
+        getPort: () => config.port,
+    }));
+    // Inspect
+    app.use(createInspectRouter({ getBundle, repoPath: config.repoPath }));
+    // Automations
     app.use(createAutomationRouter({ runner }));
     app.use(createWebhookRouter({ runner, webhookSecret: config.webhookSecret }));
     // Store REST API (if stores are defined)
     if (storeBackend) {
-        app.use(createStoresRouter({ repo, storeBackend, appId: LOCAL_APP_ID }));
+        app.use(createStoresRouter({ repo: bundle, storeBackend, appId: LOCAL_APP_ID }));
     }
     // Build user pages (if pages/ directory exists)
     let builtPages = [];
@@ -378,14 +472,12 @@ export async function createLocalServer(config) {
         const result = await buildPages(config.repoPath);
         builtPages = result.pages;
         if (builtPages.length > 0) {
-            log.info(`Built ${String(builtPages.length)} page(s)`, 'dev');
-            // Serve compiled page bundles
+            log.info('pages_built', { count: builtPages.length });
             app.use('/pages-bundle', express.static(result.outDir));
         }
     }
     catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        log.error(`Page build failed: ${msg}`, 'dev');
+        log.error('pages_build_failed', { error: err instanceof Error ? err.message : String(err) });
     }
     // Pages list endpoint
     app.get('/api/pages', (_req, res) => {
@@ -398,11 +490,8 @@ export async function createLocalServer(config) {
         app.use(config.appMiddleware);
     }
     else if (config.staticAppDir && existsSync(config.staticAppDir)) {
-        // Serve pre-built SPA static assets with index.html fallback
         app.use(express.static(config.staticAppDir));
-        // SPA fallback — serve index.html for any non-API, non-static route
         app.use((_req, res, next) => {
-            // Don't intercept API or inspect routes (already handled above)
             if (_req.path.startsWith('/api/') || _req.path.startsWith('/inspect/') || _req.method !== 'GET') {
                 next();
                 return;
@@ -427,17 +516,16 @@ export async function createLocalServer(config) {
             // Start hot reload watcher
             if (config.hotReload) {
                 watcher = new ConfigWatcher(config.repoPath, (newBundle) => {
-                    sessionManager.updateBundle(newBundle);
+                    bundle = newBundle;
+                    // Shared resources and session components will pick up the new
+                    // bundle on next session creation via getBundle().
+                    log.info('config_reloaded', { name: newBundle.config.name });
                 });
                 watcher.start();
             }
             return new Promise((resolve) => {
                 const httpServer = app.listen(port, host, () => {
-                    log.info(`Repo server listening on ${host}:${port}`);
-                    log.info(`Repo: ${config.repoPath}`);
-                    if (config.hotReload) {
-                        log.info('Hot reload enabled');
-                    }
+                    log.info('server_started', { host, port, repoPath: config.repoPath, hotReload: !!config.hotReload });
                     resolve(httpServer);
                 });
                 server = httpServer;
@@ -462,10 +550,13 @@ export async function createLocalServer(config) {
                 server = null;
             }
             await sessionManager.shutdown();
+            if (mcpManager) {
+                await mcpManager.shutdown();
+            }
             if (storeBackend) {
                 await storeBackend.close();
             }
-            log.info('Repo server stopped');
+            log.info('server_stopped', {});
         },
     };
 }