@cachly-dev/mcp-server 0.10.49 → 0.10.56

package/dist/{src/index.js → index.js}

@@ -1,7 +1,5 @@
 #!/usr/bin/env node
 import { jwtExpiryMs, checkJwt, handleApiError } from './auth.js';
-import { handleTcoTool } from './handlers/tco.js';
-import { notify } from './notifier.js';
 import { readFile } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
 // True only when this file is the entry point (not imported by tests or other modules).
@@ -36,40 +34,25 @@ const _isMain = process.argv[1] != null &&
  * ── Auth & Status ────────────────────────────────────────────────────────────
  *   • get_api_status        – check API health + JWT auth info (Keycloak)
  *
- * ── Travel Chaos Organizer (TCO) ────────────────────────────────────────────
- *   • tco_list_trips    – list all trips
- *   • tco_create_trip   – create a new trip
- *   • tco_get_timeline  – get timeline items for a trip
- *   • tco_delete_trip   – delete a trip
- *   • tco_inbox_list    – list Chaos Inbox items
- *   • tco_inbox_assign  – assign inbox item to a trip
- *   • tco_inbox_reject  – reject/discard an inbox item
- *   • tco_parse_url     – fetch a URL and parse with Ollama
- *   • tco_import_email  – import raw email text
- *   (Requires TCO_API_URL env var; auth forwarded from CACHLY_JWT — same Keycloak realm)
- *
  * Configuration (env vars):
  *   CACHLY_API_URL      – default https://api.cachly.dev
  *   CACHLY_JWT          – your JWT (Keycloak access token)
  *   CACHLY_EMBED_PROVIDER – embedding backend: openai (default), gemini, mistral, cohere, ollama, cachly (server fallback)
  *   CACHLY_EMBED_MODEL  – override embedding model (optional)
- *   TCO_API_URL         – Travel Chaos Organizer backend URL (optional, enables tco_* tools)
  */
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
 import { Redis } from 'ioredis';
+import { AsyncLocalStorage } from 'node:async_hooks';
 // ── Config ────────────────────────────────────────────────────────────────────
 const API_URL = process.env.CACHLY_API_URL ?? 'https://api.cachly.dev';
 let JWT = process.env.CACHLY_JWT ?? '';
-const EMBED_MODEL = process.env.CACHLY_EMBED_MODEL ?? '';
-const CURRENT_VERSION = '0.10.49';
-// Max time to wait for a freshly-provisioned instance to become "running" before
-// giving up. Free-tier provisioning in high-latency regions can take 45–90s, so the
-// old hard-coded 25s caused spurious "instance_not_reachable" on first run.
-// Override via CACHLY_PROVISION_TIMEOUT_MS.
-const PROVISION_TIMEOUT_MS = Number(process.env.CACHLY_PROVISION_TIMEOUT_MS ?? 90_000);
+const CURRENT_VERSION = '0.10.55';
+const reqCtx = new AsyncLocalStorage();
+function getJWT() { return reqCtx.getStore()?.jwt || JWT; }
+function getDefaultInstanceId() { return reqCtx.getStore()?.instanceId || _defaultInstanceId; }
 // ── Default Instance Resolution (for Smithery & single-credential setups) ────
 // When CACHLY_BRAIN_INSTANCE_ID is set, tools can omit the instance_id parameter.
 // When neither is set, we auto-fetch the first running instance once per process.
@@ -77,18 +60,29 @@ let _defaultInstanceId = process.env.CACHLY_BRAIN_INSTANCE_ID ?? '';
 // Timestamp of last failed fetch — retries after 30 s (not permanently blocked).
 let _defaultInstanceLastAttempt = 0;
 async function resolveDefaultInstanceId() {
+    // In an HTTP request scope the instance ID is fixed by the caller's header.
+    const scopedId = reqCtx.getStore()?.instanceId;
+    if (scopedId)
+        return scopedId;
     if (_defaultInstanceId)
         return _defaultInstanceId;
-    if (!JWT)
+    if (!getJWT())
         return '';
     // Cooldown: don't hammer the API on every tool call after a transient failure.
+    // 10 s is enough to avoid rate-limit spam while not blocking the user for too long.
     const now = Date.now();
-    if (_defaultInstanceLastAttempt > 0 && now - _defaultInstanceLastAttempt < 30_000)
-        return '';
+    if (_defaultInstanceLastAttempt > 0 && now - _defaultInstanceLastAttempt < 10_000) {
+        throw new McpError(ErrorCode.InvalidRequest, '⚠️ Cachly Brain is temporarily unreachable (API error a few seconds ago).\n\n' +
+            'The server will retry automatically in a moment. If this persists:\n' +
+            '• Run `get_api_status` for a full diagnostic\n' +
+            '• Check that CACHLY_JWT is set and valid\n' +
+            '• Visit https://cachly.dev/instances to verify your Brain is running');
+    }
+    ;
     _defaultInstanceLastAttempt = now;
     try {
         const res = await fetch(`${API_URL}/api/v1/instances`, {
-            headers: { Authorization: `Bearer ${JWT}`, Accept: 'application/json' },
+            headers: { Authorization: `Bearer ${getJWT()}`, Accept: 'application/json' },
             signal: AbortSignal.timeout(5000),
         });
         if (!res.ok)
@@ -165,44 +159,33 @@ async function pollDeviceFlow(flow) {
             catch { /* use raw JWT as fallback */ }
             JWT = apiKey;
             setEmbedJwt(apiKey); // keep embeddings.ts in sync
-            _deviceFlow = null;
-            sendFunnelEvent('device_flow_completed');
-            // Persist the API key to ~/.claude/mcp.json so subsequent MCP server restarts
-            // keep the token. Without this, JWT is lost on restart and brain_recall_count
-            // is never incremented (telemetry has no api_key → no tenant resolution).
-            void (async () => {
-                try {
-                    const { writeFile, mkdir, readFile } = await import('node:fs/promises');
-                    const { existsSync } = await import('node:fs');
-                    const { resolve, dirname } = await import('node:path');
-                    const home = process.env.HOME ?? process.env.USERPROFILE ?? '';
-                    if (!home)
-                        return;
-                    const configPath = resolve(home, '.claude', 'mcp.json');
-                    let cfg = {};
-                    if (existsSync(configPath)) {
-                        try {
-                            cfg = JSON.parse(await readFile(configPath, 'utf-8'));
-                        }
-                        catch { /* corrupt — start fresh */ }
-                    }
-                    cfg.mcpServers ??= {};
-                    const existing = cfg.mcpServers['cachly'];
-                    if (existing) {
-                        existing.env ??= {};
-                        existing.env['CACHLY_JWT'] = apiKey;
-                    }
-                    else {
-                        cfg.mcpServers['cachly'] = {
-                            command: 'npx', args: ['-y', '@cachly-dev/mcp-server@latest'],
-                            env: { CACHLY_JWT: apiKey },
-                        };
+            // Persist API key to ~/.claude/mcp.json so the next editor restart
+            // doesn't start over from a missing CACHLY_JWT (fixes BrainRecallCount=0 bug).
+            try {
+                const { resolve: _res, dirname: _dir } = await import('node:path');
+                const { homedir: _hd } = await import('node:os');
+                const { writeFile: _wf, mkdir: _mk, readFile: _rf } = await import('node:fs/promises');
+                const { existsSync: _ex } = await import('node:fs');
+                const globalJwtPath = _res(_hd(), '.claude', 'mcp.json');
+                await _mk(_dir(globalJwtPath), { recursive: true });
+                let cfg = {};
+                if (_ex(globalJwtPath)) {
+                    try {
+                        cfg = JSON.parse(await _rf(globalJwtPath, 'utf-8'));
                     }
-                    await mkdir(dirname(configPath), { recursive: true });
-                    await writeFile(configPath, JSON.stringify(cfg, null, 2), 'utf-8');
+                    catch { /* corrupt — start fresh */ }
                 }
-                catch { /* non-critical — don't break the flow on filesystem errors */ }
-            })();
+                cfg.mcpServers ??= {};
+                cfg.mcpServers['cachly'] ??= {};
+                cfg.mcpServers['cachly'].env ??= {};
+                cfg.mcpServers['cachly'].env['CACHLY_JWT'] = apiKey;
+                if (_defaultInstanceId)
+                    cfg.mcpServers['cachly'].env['CACHLY_BRAIN_INSTANCE_ID'] = _defaultInstanceId;
+                await _wf(globalJwtPath, JSON.stringify(cfg, null, 2), 'utf-8');
+            }
+            catch { /* non-fatal — editor will just prompt again on next restart */ }
+            _deviceFlow = null;
+            sendFunnelEvent('device_flow_completed');
             // Auto-provision: find or create the user's brain instance.
             _defaultInstanceLastAttempt = 0;
             await resolveDefaultInstanceId();
@@ -210,7 +193,7 @@ async function pollDeviceFlow(flow) {
                 try {
                     const autoRes = await fetch(`${API_URL}/api/v1/instances/auto`, {
                         method: 'POST',
-                        headers: { Authorization: `Bearer ${JWT}`, 'Content-Type': 'application/json' },
+                        headers: { Authorization: `Bearer ${getJWT()}`, 'Content-Type': 'application/json' },
                         signal: AbortSignal.timeout(12000),
                     });
                     if (autoRes.ok) {
@@ -223,7 +206,7 @@ async function pollDeviceFlow(flow) {
                         // Log so telemetry can detect free-tier auto-provision failures
                         void fetch(`${API_URL}/api/v1/telemetry/mcp`, {
                             method: 'POST',
-                            headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${JWT}` },
+                            headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${getJWT()}` },
                             body: JSON.stringify({ event: 'auto_provision_failed', status: autoRes.status, version: CURRENT_VERSION }),
                             signal: AbortSignal.timeout(3000),
                         }).catch(() => { });
@@ -236,7 +219,7 @@ async function pollDeviceFlow(flow) {
             if (_defaultInstanceId) {
                 try {
                     const checkRes = await fetch(`${API_URL}/api/v1/instances/${_defaultInstanceId}`, {
-                        headers: { Authorization: `Bearer ${JWT}`, Accept: 'application/json' },
+                        headers: { Authorization: `Bearer ${getJWT()}`, Accept: 'application/json' },
                         signal: AbortSignal.timeout(4000),
                     });
                     if (checkRes.ok) {
@@ -247,7 +230,7 @@ async function pollDeviceFlow(flow) {
                             while (checkInst.status === 'provisioning' && Date.now() < pDeadline) {
                                 await new Promise(r => setTimeout(r, 3000));
                                 const rr = await fetch(`${API_URL}/api/v1/instances/${_defaultInstanceId}`, {
-                                    headers: { Authorization: `Bearer ${JWT}`, Accept: 'application/json' },
+                                    headers: { Authorization: `Bearer ${getJWT()}`, Accept: 'application/json' },
                                     signal: AbortSignal.timeout(4000),
                                 }).catch(() => null);
                                 if (rr?.ok) {
@@ -263,37 +246,6 @@ async function pollDeviceFlow(flow) {
                 }
                 catch { /* non-fatal — getConnection will handle the wait if still provisioning */ }
             }
-            // Persist instance_id to ~/.claude/mcp.json after it's known.
-            // Without this, every restart loses CACHLY_BRAIN_INSTANCE_ID → resolveDefaultInstanceId
-            // makes an extra API call on every startup (with 30s cooldown on failure).
-            if (_defaultInstanceId) {
-                void (async () => {
-                    try {
-                        const { writeFile, readFile } = await import('node:fs/promises');
-                        const { existsSync } = await import('node:fs');
-                        const { resolve } = await import('node:path');
-                        const home = process.env.HOME ?? process.env.USERPROFILE ?? '';
-                        if (!home)
-                            return;
-                        const configPath = resolve(home, '.claude', 'mcp.json');
-                        if (!existsSync(configPath))
-                            return;
-                        let cfg = {};
-                        try {
-                            cfg = JSON.parse(await readFile(configPath, 'utf-8'));
-                        }
-                        catch {
-                            return;
-                        }
-                        const entry = cfg.mcpServers?.['cachly'];
-                        if (entry?.env) {
-                            entry.env['CACHLY_BRAIN_INSTANCE_ID'] = _defaultInstanceId;
-                            await writeFile(configPath, JSON.stringify(cfg, null, 2), 'utf-8');
-                        }
-                    }
-                    catch { /* non-critical */ }
-                })();
-            }
             return 'done';
         }
         if (data.error === 'slow_down')
@@ -304,12 +256,71 @@ async function pollDeviceFlow(flow) {
         return 'pending';
     }
 }
+// ── Silent Auto-Setup (instant-trial, zero-click) ─────────────────────────
+// Attempts to provision a free trial silently on the first tool call when no
+// JWT is set. Returns true if credentials were written and the tool can
+// proceed transparently; false if the API is unreachable or trials are full.
+// Only runs once per process (subsequent failures short-circuit immediately).
+let _silentSetupAttempted = false;
+async function silentAutoSetup() {
+    if (_silentSetupAttempted)
+        return false;
+    _silentSetupAttempted = true;
+    try {
+        const res = await fetch(`${API_URL}/auth/instant-trial`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({}),
+            signal: AbortSignal.timeout(8000),
+        });
+        if (!res.ok)
+            return false;
+        const data = await res.json();
+        if (!data.api_key)
+            return false;
+        JWT = data.api_key;
+        setEmbedJwt(data.api_key);
+        if (data.instance_id)
+            _defaultInstanceId = data.instance_id;
+        sendFunnelEvent('trial_provisioned', { version: CURRENT_VERSION });
+        // Persist credentials so the next editor restart doesn't re-provision.
+        try {
+            const { resolve: _rp, dirname: _dn } = await import('node:path');
+            const { homedir: _hd } = await import('node:os');
+            const { writeFile: _wf, mkdir: _mk, readFile: _rf } = await import('node:fs/promises');
+            const { existsSync: _ex } = await import('node:fs');
+            const cfgPath = _rp(_hd(), '.claude', 'mcp.json');
+            await _mk(_dn(cfgPath), { recursive: true });
+            let cfg = {};
+            if (_ex(cfgPath)) {
+                try {
+                    cfg = JSON.parse(await _rf(cfgPath, 'utf-8'));
+                }
+                catch { /* corrupt — overwrite */ }
+            }
+            cfg.mcpServers ??= {};
+            cfg.mcpServers['cachly'] ??= {};
+            cfg.mcpServers['cachly'].env ??= {};
+            cfg.mcpServers['cachly'].env['CACHLY_JWT'] = data.api_key;
+            if (_defaultInstanceId)
+                cfg.mcpServers['cachly'].env['CACHLY_BRAIN_INSTANCE_ID'] = _defaultInstanceId;
+            await _wf(cfgPath, JSON.stringify(cfg, null, 2), 'utf-8');
+        }
+        catch { /* non-fatal — trial is active for this session even if persist fails */ }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 // ── Embeddings (imported from embeddings.ts) ────────────────────────────────
 import { setEmbedJwt } from './embeddings.js';
 // ── Search Engine (imported from search.ts) ─────────────────────────────────
 import { tokenize, splitMultiQuery, levenshtein, recencyBoost, extractTimestamp, STOPWORDS, katakanaToRomaji, arabicLightStem, expandCrossLingual, CROSS_LINGUAL_MAP, ZERO_RESULTS_LOG, zeroResultsTotal } from './search.js';
 // ── Exported for testing (re-export from search.ts) ─────────────────────────
 export { tokenize, splitMultiQuery, levenshtein, recencyBoost, extractTimestamp, STOPWORDS, katakanaToRomaji, arabicLightStem, expandCrossLingual, CROSS_LINGUAL_MAP };
+// ── Types ─────────────────────────────────────────────────────────────────────
+// Instance is imported from handlers/brain.ts
 // ── Connection pool ───────────────────────────────────────────────────────────
 /** Reuse Redis connections across tool calls (keyed by instance_id). */
 const pool = new Map();
@@ -320,16 +331,26 @@ async function getConnection(instance_id) {
             '• Pass instance_id explicitly to the tool, or\n' +
             '• Run `list_instances` to see your available instances.');
     }
-    if (pool.has(instance_id))
-        return pool.get(instance_id);
-    // Fetch instance, waiting up to PROVISION_TIMEOUT_MS if it is still provisioning.
-    // This covers the zero-friction path: device-flow auth → auto-provision → first tool call
-    // all happen in quick succession and the instance isn't running yet.
+    if (pool.has(instance_id)) {
+        const cached = pool.get(instance_id);
+        // Verify the pooled connection is still alive before reusing it.
+        // ioredis 'error' eviction is async — a connection can be in the pool
+        // but already internally broken (status 'reconnecting' or 'end').
+        const status = cached.status;
+        if (status === 'ready' || status === 'connect') {
+            return cached;
+        }
+        // Stale — evict and fall through to reconnect.
+        pool.delete(instance_id);
+        cached.disconnect();
+    }
+    // Fetch instance, waiting up to 8 s if it is still provisioning.
+    // (autoStartSession already gave the instance a head-start; 8 s covers any remaining gap.)
     let inst = await apiFetch(`/api/v1/instances/${instance_id}`);
     if (inst.status === 'provisioning') {
-        const deadline = Date.now() + PROVISION_TIMEOUT_MS;
+        const deadline = Date.now() + 8_000;
         while (inst.status === 'provisioning' && Date.now() < deadline) {
-            await new Promise(r => setTimeout(r, 3000));
+            await new Promise(r => setTimeout(r, 2000));
             inst = await apiFetch(`/api/v1/instances/${instance_id}`);
         }
     }
@@ -337,7 +358,7 @@ async function getConnection(instance_id) {
         // Telemetry: unreachable instance so the team can proactively investigate
         void fetch(`${API_URL}/api/v1/telemetry/mcp`, {
             method: 'POST',
-            headers: { 'Content-Type': 'application/json', ...(JWT ? { Authorization: `Bearer ${JWT}` } : {}) },
+            headers: { 'Content-Type': 'application/json', ...(getJWT() ? { Authorization: `Bearer ${getJWT()}` } : {}) },
             body: JSON.stringify({ event: 'instance_not_reachable', instance_id, status: inst.status, version: CURRENT_VERSION }),
             signal: AbortSignal.timeout(3000),
         }).catch(() => { });
@@ -370,7 +391,9 @@ async function getConnection(instance_id) {
     }
     // Fetch connection details (includes password) from the dedicated endpoint.
     let password;
-    let tlsEnabled = inst.tls_enabled !== false; // default true
+    // Default to false — most free/dev instances run without TLS.
+    // Only enable TLS when the API explicitly returns tls_enabled: true.
+    let tlsEnabled = inst.tls_enabled === true;
     try {
         const conn = await apiFetch(`/api/v1/instances/${instance_id}/connection`);
         password = conn.password ?? undefined;
@@ -389,25 +412,56 @@ async function getConnection(instance_id) {
         host: inst.host,
         port: inst.port,
         password: password || undefined,
-        commandTimeout: 8000,
         ...(tlsEnabled ? { tls: {} } : {}),
         lazyConnect: true,
         enableReadyCheck: true,
         connectTimeout: 8000,
+        commandTimeout: 10000,
         retryStrategy: () => null, // fail fast, no reconnect loops in MCP context
     });
     const evict = () => pool.delete(instance_id);
     client.on('error', evict);
     client.on('end', evict);
-    try {
-        await client.connect();
+    // Retry up to 3 times with 2s backoff. Covers the window between K8s PodReady
+    // and Valkey actually accepting connections (RDB/AOF load, ~1-3s on cold start).
+    let connectErr;
+    for (let attempt = 0; attempt < 3; attempt++) {
+        try {
+            if (attempt > 0) {
+                await new Promise(r => setTimeout(r, 2000 * attempt));
+                // Fresh client on retry — ioredis doesn't allow reconnect after explicit disconnect.
+                client.disconnect();
+                const retryClient = new Redis({
+                    host: inst.host,
+                    port: inst.port,
+                    password: password || undefined,
+                    ...(tlsEnabled ? { tls: {} } : {}),
+                    lazyConnect: true,
+                    enableReadyCheck: true,
+                    connectTimeout: 8000,
+                    commandTimeout: 10000,
+                    retryStrategy: () => null,
+                });
+                retryClient.on('error', () => pool.delete(instance_id));
+                retryClient.on('end', () => pool.delete(instance_id));
+                await retryClient.connect();
+                pool.set(instance_id, retryClient);
+                return retryClient;
+            }
+            await client.connect();
+            connectErr = undefined;
+            break;
+        }
+        catch (err) {
+            connectErr = err;
+        }
     }
-    catch (err) {
+    if (connectErr) {
         client.disconnect();
-        const msg = err instanceof Error ? err.message : String(err);
+        const msg = connectErr instanceof Error ? connectErr.message : String(connectErr);
         void fetch(`${API_URL}/api/v1/telemetry/mcp`, {
             method: 'POST',
-            headers: { 'Content-Type': 'application/json', ...(JWT ? { Authorization: `Bearer ${JWT}` } : {}) },
+            headers: { 'Content-Type': 'application/json', ...(getJWT() ? { Authorization: `Bearer ${getJWT()}` } : {}) },
             body: JSON.stringify({ event: 'redis_connect_failed', instance_id, host: inst.host, port: inst.port, error: msg, version: CURRENT_VERSION }),
             signal: AbortSignal.timeout(3000),
         }).catch(() => { });
@@ -421,14 +475,14 @@ async function getConnection(instance_id) {
 }
 // ── API helper ────────────────────────────────────────────────────────────────
 async function apiFetch(path, options = {}) {
-    checkJwt(JWT);
+    checkJwt(getJWT());
     const timeoutMs = Number(process.env.CACHLY_API_TIMEOUT_MS ?? 15_000);
     const res = await fetch(`${API_URL}${path}`, {
         ...options,
         signal: AbortSignal.timeout(timeoutMs),
         headers: {
             'Content-Type': 'application/json',
-            Authorization: `Bearer ${JWT}`,
+            Authorization: `Bearer ${getJWT()}`,
             ...options.headers,
         },
     });
@@ -449,7 +503,7 @@ import { handleTeamTool } from './handlers/team.js';
 import { handleRoadmapTool } from './handlers/roadmap.js';
 import { handleAdvancedTool } from './handlers/advanced.js';
 import { handleSyndicateTool } from './handlers/syndicate.js';
-import { handleFedbrainTool, _lastBrainFromGitCounts } from './handlers/fedbrain.js';
+import { handleFedbrainTool } from './handlers/fedbrain.js';
 // ── Tools (imported from tools.ts) ─────────────────────────────────────────
 import { TOOLS } from './tools.js';
 // ── Handlers ──────────────────────────────────────────────────────────────────
@@ -472,7 +526,10 @@ function sendFunnelEvent(event, extra) {
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({
             event, version: CURRENT_VERSION, editor: detectEditor(),
-            ...(JWT ? { jwt: JWT } : {}),
+            // Send Cachly API keys (cky_*) for server-side tenant resolution (recall counting, emails).
+            // Raw Keycloak JWTs (eyJ...) are intentionally excluded — they are short-lived bearer tokens
+            // that should never leave the MCP process boundary.
+            ...(getJWT().startsWith('cky_') ? { api_key: getJWT() } : {}),
             ...extra,
         }),
         signal: AbortSignal.timeout(3000),
@@ -495,11 +552,18 @@ async function sendAnonymousTelemetry(toolName) {
     catch { /* fire-and-forget, never block the user */ }
 }
 async function handleTool(name, args) {
-    // Guard: if no JWT, return actionable onboarding message instead of HTTP 401
-    if (!JWT) {
+    // Guard: if no JWT, try silent auto-setup first, then fall back to device flow.
+    if (!getJWT()) {
+        // ── Step 1: Silent instant-trial (zero-click) ────────────────────────
+        // On the very first tool call, attempt to silently provision a free trial.
+        // If it succeeds the user never sees an auth prompt — Brain is just active.
+        const provisioned = await silentAutoSetup();
+        if (provisioned) {
+            return handleTool(name, args); // Transparent re-entry with active credentials
+        }
         void sendAnonymousTelemetry(name);
-        // ── Zero-credential device flow ─────────────────────────────────────
-        // 1st call: start device flow, return code + URL
+        // ── Step 2: Zero-credential device flow ─────────────────────────────
+        // 1st call after silent setup fails: start device flow, return code + URL
         // 2nd+ calls: poll for token; once authenticated, proceed transparently
         if (_deviceFlow) {
             const result = await pollDeviceFlow(_deviceFlow);
@@ -571,16 +635,16 @@ async function handleTool(name, args) {
             args = { ...args, instance_id: defaultId };
     }
     // Delegate brain tools (learn, recall, session, etc.)
-    const brainResult = await handleBrainTool(name, args, getConnection, apiFetch);
+    let brainResult = await handleBrainTool(name, args, getConnection, apiFetch);
     if (brainResult !== null) {
-        if (!_firstCallSuccessSent && JWT) {
+        if (!_firstCallSuccessSent && getJWT()) {
             _firstCallSuccessSent = true;
-            sendFunnelEvent('first_call_success', { tool: name, instance_id: args.instance_id ?? _defaultInstanceId ?? '' });
+            sendFunnelEvent('first_call_success', { tool: name, instance_id: args.instance_id ?? getDefaultInstanceId() ?? '' });
         }
         // Per-tool telemetry — fires after every successful brain tool call.
         // api_key carries the cky_live_... token so the backend can resolve tenant + increment counters.
-        const instanceId = args.instance_id ?? _defaultInstanceId ?? '';
-        const telemetryExtra = JWT ? { api_key: JWT, instance_id: instanceId } : { instance_id: instanceId };
+        const instanceId = args.instance_id ?? getDefaultInstanceId() ?? '';
+        const telemetryExtra = getJWT() ? { api_key: getJWT(), instance_id: instanceId } : { instance_id: instanceId };
         if (name === 'recall_best_solution') {
             // recall_best_solution → increments BrainRecallCount + triggers level-up logic
             sendFunnelEvent('recall_best_solution', telemetryExtra);
@@ -598,25 +662,48 @@ async function handleTool(name, args) {
                 // Existing brain — session_start acts as implicit recall → increment counter.
                 sendFunnelEvent('recall_best_solution', telemetryExtra);
             }
-            else if (isFirstSession && args.workspace_path) {
-                // First session with a known workspace: auto-bootstrap from git history.
-                // Runs synchronously so the user sees the result in the same response.
+            // Auto-bootstrap brain_from_git when workspace_path is provided and it hasn't run yet.
+            // We check a sentinel key in Valkey so this only fires once per workspace path,
+            // not just on the very first session (handles cases where brain was empty but
+            // session data existed, or where the user re-installed).
+            if (args.workspace_path) {
                 try {
-                    const gitBootstrap = await handleFedbrainTool('brain_from_git', {
-                        instance_id: instanceId,
-                        repo_path: args.workspace_path,
-                        limit: 50,
-                    }, getConnection, apiFetch);
-                    if (gitBootstrap !== null) {
-                        const gitCounts = _lastBrainFromGitCounts;
-                        sendFunnelEvent('brain_from_git', { ...telemetryExtra, ...(gitCounts ?? {}) });
-                        sendFunnelEvent('recall_best_solution', telemetryExtra);
-                        // Append bootstrap summary to the session_start briefing.
-                        // brainResult is always a string here (handleBrainTool returns string for session_start).
-                        const bootstrapText = String(gitBootstrap);
-                        if (bootstrapText) {
-                            return String(brainResult) + '\n---\n' + bootstrapText;
+                    const workspacePath = args.workspace_path;
+                    const autoKey = `cachly:brain_from_git:auto_done:${Buffer.from(workspacePath).toString('base64').slice(0, 40)}`;
+                    const redis = await getConnection(instanceId);
+                    const alreadyDone = await redis.get(autoKey);
+                    if (!alreadyDone) {
+                        // Mark immediately to prevent concurrent runs across multiple MCP tool calls
+                        await redis.set(autoKey, '1', 'EX', 365 * 86400);
+                        // Append a placeholder so the user gets immediate feedback, then bootstrap in background.
+                        // Running brain_from_git synchronously would block session_start for 30-120s on large repos.
+                        const bgMsg = '\n\n---\n\n🚀 **Auto-indexing your git history in the background** — your Brain will learn from recent commits automatically. No action needed.';
+                        if (typeof brainResult === 'object' && brainResult !== null && 'content' in brainResult) {
+                            brainResult.content.push({ type: 'text', text: bgMsg });
                         }
+                        else if (typeof brainResult === 'string') {
+                            brainResult = brainResult + bgMsg;
+                        }
+                        // Fire-and-forget — never block the session_start response
+                        void handleFedbrainTool('brain_from_git', {
+                            instance_id: instanceId,
+                            repo_path: workspacePath,
+                            limit: 50,
+                        }, getConnection, apiFetch).then(async (gitBootstrap) => {
+                            if (gitBootstrap !== null) {
+                                sendFunnelEvent('brain_from_git', telemetryExtra);
+                                sendFunnelEvent('recall_best_solution', telemetryExtra);
+                                // Store ingested count for the next session_start wow moment
+                                try {
+                                    const ingested = gitBootstrap.match(/Ingested:\s*\*\*(\d+)\*/);
+                                    if (ingested) {
+                                        const r = await getConnection(instanceId);
+                                        await r.set('cachly:brain_from_git:auto_bootstrap_result', JSON.stringify({ count: parseInt(ingested[1], 10), ts: new Date().toISOString() }), 'EX', 7 * 86400);
+                                    }
+                                }
+                                catch { /* non-critical — must never break the session */ }
+                            }
+                        }).catch(() => { });
                     }
                 }
                 catch { /* git bootstrap errors must never break session_start */ }
@@ -633,7 +720,7 @@ async function handleTool(name, args) {
             const srText = typeof brainResult === 'object' && brainResult !== null && 'content' in brainResult
                 ? JSON.stringify(brainResult)
                 : String(brainResult ?? '');
-            if (srText.length > 50 && !srText.includes('No lessons found') && !srText.includes('no lessons') && !srText.includes('No matches found')) {
+            if (srText.length > 50 && !srText.includes('No lessons found') && !srText.includes('no lessons')) {
                 sendFunnelEvent('recall_best_solution', telemetryExtra);
             }
         }
@@ -642,9 +729,9 @@ async function handleTool(name, args) {
     // Delegate context tools (remember/recall/list/forget)
     const contextResult = await handleContextTool(name, args, getConnection, apiFetch);
     if (contextResult !== null) {
-        if (!_firstCallSuccessSent && JWT) {
+        if (!_firstCallSuccessSent && getJWT()) {
             _firstCallSuccessSent = true;
-            sendFunnelEvent('first_call_success', { tool: name, instance_id: args.instance_id ?? _defaultInstanceId ?? '' });
+            sendFunnelEvent('first_call_success', { tool: name, instance_id: args.instance_id ?? getDefaultInstanceId() ?? '' });
         }
         return contextResult;
     }
@@ -669,8 +756,8 @@ async function handleTool(name, args) {
     if (syndicateResult !== null) {
         // brain_predict is in syndicate handler — track telemetry here.
         if (name === 'brain_predict') {
-            const instanceId = args.instance_id ?? _defaultInstanceId ?? '';
-            const telemetryExtra = JWT ? { api_key: JWT, instance_id: instanceId } : { instance_id: instanceId };
+            const instanceId = args.instance_id ?? getDefaultInstanceId() ?? '';
+            const telemetryExtra = getJWT() ? { api_key: getJWT(), instance_id: instanceId } : { instance_id: instanceId };
             sendFunnelEvent('brain_predict', telemetryExtra);
         }
         return syndicateResult;
@@ -678,21 +765,16 @@ async function handleTool(name, args) {
     const fedbrainResult = await handleFedbrainTool(name, args, getConnection, apiFetch);
     if (fedbrainResult !== null) {
         // brain_from_git and brain_predict_failures are in fedbrain handler.
-        const instanceId = args.instance_id ?? _defaultInstanceId ?? '';
-        const telemetryExtra = JWT ? { api_key: JWT, instance_id: instanceId } : { instance_id: instanceId };
+        const instanceId = args.instance_id ?? getDefaultInstanceId() ?? '';
+        const telemetryExtra = getJWT() ? { api_key: getJWT(), instance_id: instanceId } : { instance_id: instanceId };
         if (name === 'brain_from_git') {
-            const gitCounts = _lastBrainFromGitCounts;
-            sendFunnelEvent('brain_from_git', { ...telemetryExtra, ...(gitCounts ?? {}) });
+            sendFunnelEvent('brain_from_git', telemetryExtra);
         }
         else if (name === 'brain_predict_failures') {
             sendFunnelEvent('brain_predict_failures', telemetryExtra);
         }
         return fedbrainResult;
     }
-    // Delegate Travel Chaos Organizer tools (requires TCO_API_URL env var)
-    const tcoResult = await handleTcoTool(name, args, JWT ?? '');
-    if (tcoResult !== null)
-        return tcoResult;
     switch (name) {
         // ── Instance management ──────────────────────────────────────────────
         case 'get_api_status': {
@@ -712,7 +794,7 @@ async function handleTool(name, args) {
                 healthStatus = `unreachable: ${e.message}`;
             }
             // Check JWT / auth
-            if (!JWT) {
+            if (!getJWT()) {
                 return [
                     `📡 **cachly API Status**`,
                     ``,
@@ -724,27 +806,38 @@ async function handleTool(name, args) {
                 ].join('\n');
             }
             // Decode JWT claims (inspection only, no verification)
-            let authInfo = '❌ invalid JWT format';
-            try {
-                const parts = JWT.split('.');
-                if (parts.length === 3) {
-                    const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString('utf-8'));
-                    const sub = payload.sub ?? '(unknown)';
-                    const iss = payload.iss ?? '(unknown)';
-                    const provider = iss.includes('keycloak') ? 'Keycloak' : 'OIDC';
-                    const expTs = payload.exp ? new Date(payload.exp * 1000) : null;
-                    const expired = expTs ? expTs < new Date() : false;
-                    authInfo = [
-                        `✅ JWT decoded`,
-                        `  Sub (user ID): ${sub}`,
-                        `  Provider:      ${provider}`,
-                        `  Issuer:        ${iss}`,
-                        `  Expires:       ${expTs ? expTs.toISOString() : 'never'} ${expired ? '⚠️  EXPIRED – get a new token!' : '✅'}`,
-                    ].join('\n');
-                }
+            const jwt = getJWT();
+            let authInfo;
+            // API keys (cky_live_... / cky_trial_...) are valid long-lived credentials.
+            // Only try to decode as JWT (3-part base64url) if it looks like one.
+            if (jwt.startsWith('cky_')) {
+                const keyType = jwt.startsWith('cky_trial_') ? 'Trial' : 'Live';
+                const keyId = jwt.slice(0, 20) + '…';
+                authInfo = `✅ API key (${keyType})\n  Key prefix: ${keyId}`;
             }
-            catch {
-                authInfo = '❌ JWT decode failed – check CACHLY_JWT format';
+            else {
+                authInfo = '❌ invalid credential format';
+                try {
+                    const parts = jwt.split('.');
+                    if (parts.length === 3) {
+                        const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString('utf-8'));
+                        const sub = payload.sub ?? '(unknown)';
+                        const iss = payload.iss ?? '(unknown)';
+                        const provider = iss.includes('keycloak') ? 'Keycloak' : 'OIDC';
+                        const expTs = payload.exp ? new Date(payload.exp * 1000) : null;
+                        const expired = expTs ? expTs < new Date() : false;
+                        authInfo = [
+                            `✅ JWT decoded`,
+                            `  Sub (user ID): ${sub}`,
+                            `  Provider:      ${provider}`,
+                            `  Issuer:        ${iss}`,
+                            `  Expires:       ${expTs ? expTs.toISOString() : 'never'} ${expired ? '⚠️  EXPIRED – get a new token!' : '✅'}`,
+                        ].join('\n');
+                    }
+                }
+                catch {
+                    authInfo = '❌ JWT decode failed – check CACHLY_JWT format';
+                }
             }
             // List instances + connectivity
             let instanceInfo = '';
@@ -758,7 +851,7 @@ async function handleTool(name, args) {
                     const lines = ['\n\n🧠 **Brain Instances:**'];
                     for (const inst of instances) {
                         const badge = inst.status === 'running' ? '🟢' : inst.status === 'provisioning' ? '🟡' : '🔴';
-                        const defaultMark = inst.id === _defaultInstanceId ? ' ← active' : '';
+                        const defaultMark = inst.id === getDefaultInstanceId() ? ' ← active' : '';
                         lines.push(`  ${badge} **${inst.name}** (\`${inst.id}\`) · ${inst.status}${defaultMark}`);
                         if (inst.status === 'running' && inst.host) {
                             // Try a quick ping on the cached connection
@@ -886,13 +979,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             || _defaultInstanceId
             || process.env.CACHLY_BRAIN_INSTANCE_ID;
         if (instanceId) {
-            await autoStartSession(instanceId).catch(() => undefined);
+            // Fire-and-forget — session management is non-critical and must never block tool calls.
+            // The session_start briefing (which includes brain_from_git) can take 30-120s on large
+            // repos; awaiting it here would freeze the user's first MCP tool call entirely.
+            void autoStartSession(instanceId);
         }
     }
-    else if (_autoSessionStarting) {
-        // Another concurrent call is mid-start — wait for it before proceeding.
-        await _autoSessionStarting.catch(() => undefined);
-    }
+    // Note: we intentionally do NOT await _autoSessionStarting for any call.
+    // The session tracker runs in background — tool calls must always proceed immediately.
     if (!sessionTools.has(name))
         _autoSessionToolCount++;
     try {
@@ -902,9 +996,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     catch (err) {
         if (err instanceof McpError)
             throw err;
-        const msg = err.message ?? String(err);
-        notify('cachly', 'tool_error', { tool: name, error: msg }).catch(() => undefined);
-        throw new McpError(ErrorCode.InternalError, msg);
+        throw new McpError(ErrorCode.InternalError, err.message);
     }
 });
 // Graceful shutdown – close all Redis connections + auto-end brain session
@@ -1892,7 +1984,7 @@ if (process.argv[2] === 'status') {
 if (process.argv[2] === 'health') {
     const { existsSync } = await import('node:fs');
     const { readFile } = await import('node:fs/promises');
-    const { resolve, join: pJoin } = await import('node:path');
+    const { resolve } = await import('node:path');
     const cwd = process.cwd();
     let passed = 0;
     let failed = 0;
@@ -1906,6 +1998,10 @@ if (process.argv[2] === 'health') {
     if (!jwt) {
         fail('CACHLY_JWT not set — run: npx @cachly-dev/mcp-server@latest setup');
     }
+    else if (jwt.startsWith('cky_')) {
+        // Opaque cachly API key — no JWT expiry to check, format is valid by prefix
+        ok('API key set (cky_*** opaque key)');
+    }
     else {
         try {
             const parts = jwt.split('.');
@@ -1925,7 +2021,7 @@ if (process.argv[2] === 'health') {
             }
         }
         catch {
-            fail('CACHLY_JWT format invalid (expected JWT with 3 parts)');
+            fail('CACHLY_JWT format invalid (expected a cky_*** API key or a JWT with 3 parts)');
         }
     }
     // ── 2. Brain API reachability ───────────────────────────────────────────────
@@ -1976,11 +2072,27 @@ if (process.argv[2] === 'health') {
                                 });
                                 if (connRes.ok) {
                                     const conn = await connRes.json();
-                                    pingPassword = conn.password;
-                                    pingTls = conn.tls_enabled !== false;
+                                    // password may be a direct field, or embedded in connection_string as redis://:pass@host:port
+                                    if (conn.password) {
+                                        pingPassword = conn.password;
+                                    }
+                                    else if (conn.connection_string) {
+                                        try {
+                                            const u = new URL(conn.connection_string);
+                                            if (u.password)
+                                                pingPassword = decodeURIComponent(u.password);
+                                        }
+                                        catch { /* leave pingPassword undefined */ }
+                                    }
+                                    pingTls = conn.tls_enabled === true;
+                                }
+                                else {
+                                    warn(`Could not fetch Redis credentials (HTTP ${connRes.status}) — connectivity test may fail`);
                                 }
                             }
-                            catch { /* proceed without password */ }
+                            catch (connErr) {
+                                warn(`Could not fetch Redis credentials — ${connErr.message}`);
+                            }
                             const pingClient = new Redis({
                                 host: inst.host, port: inst.port,
                                 password: pingPassword,
@@ -2114,7 +2226,6 @@ if (process.argv[2] === 'setup') {
         const AUTH_BASE = 'https://auth.cachly.dev/realms/cachly/protocol/openid-connect';
         const CLIENT_ID = 'cachly-cli';
         console.log('Step 1: Sign in to cachly (free, no credit card)\n');
-        sendFunnelEvent('setup_auth_started');
         // Start device flow
         let deviceCode = '', userCode = '', verifyUri = '', pollInterval = 5000;
         try {
@@ -2140,7 +2251,6 @@ if (process.argv[2] === 'setup') {
                 rl.close();
                 process.exit(1);
             }
-            sendFunnelEvent('setup_auth_completed');
             console.log('');
             deviceCode = ''; // mark as fallback so we skip polling
         }
@@ -2173,7 +2283,6 @@ if (process.argv[2] === 'setup') {
                     if (tokenData.access_token) {
                         token = tokenData.access_token;
                         console.log(' \x1b[32m✓ Authorized!\x1b[0m\n');
-                        sendFunnelEvent('setup_auth_completed');
                         break;
                     }
                     // authorization_pending = keep polling; slow_down = increase interval
@@ -2214,7 +2323,7 @@ if (process.argv[2] === 'setup') {
             token = keyBody.key; // swap JWT → cky_live_...
             console.log(' ✓\n');
         }
-        catch (e) {
+        catch {
             console.log(' (skipped)\n');
             // Non-fatal: fall back to using the Keycloak JWT directly.
             // It will expire but setup still works for now.
@@ -2267,10 +2376,9 @@ if (process.argv[2] === 'setup') {
                 // Newly created — poll until running or give up after 30 s.
                 const newId = autoBody.instance_id;
                 console.log(` ✓ created (${newId.slice(0, 8)}…)\n`);
-                // 45 attempts × 3s = 135s — generous for free-tier in slow regions.
                 process.stdout.write('⏳ Waiting for instance to start');
-                for (let attempt = 0; attempt < 45; attempt++) {
-                    await new Promise(r => setTimeout(r, 3000));
+                for (let attempt = 0; attempt < 15; attempt++) {
+                    await new Promise(r => setTimeout(r, 2000));
                     process.stdout.write('.');
                     try {
                         const checkRes = await fetch(`${API_URL}/api/v1/instances/${newId}`, { headers: { Authorization: `Bearer ${token}` } });
@@ -2309,7 +2417,6 @@ if (process.argv[2] === 'setup') {
         console.log(`   (Run with --instance-id <id> to use a different one)\n`);
     }
     console.log(`✓  Instance: ${instance.name} (${instance.id.slice(0, 8)}…)\n`);
-    sendFunnelEvent('setup_instance_ready', { instance_id: instance.id });
     // ── Step 3: Detect editors ────────────────────────────────────────────────
     const cwd = process.cwd();
     const detected = [];
@@ -2487,6 +2594,8 @@ if (process.argv[2] === 'setup') {
     console.log(`   Dashboard: https://cachly.dev/instances/${instance.id}`);
     console.log(`\n   📛 Add a live badge to your README:`);
     console.log(`      npx @cachly-dev/mcp-server@latest badge\n`);
+    console.log(`   🤝 Invite a teammate — they'll arrive pre-briefed on your project:`);
+    console.log(`      npx @cachly-dev/mcp-server@latest invite\n`);
     // ── Step 7: Email opt-in (non-blocking — at the very end) ────────────────
     if (!nonInteractive) {
         const email = await ask('   📬 Stay in the loop? Email for release notes [Enter to skip]: ');
@@ -2558,7 +2667,7 @@ if (process.argv[2] === 'index') {
     const instanceId = flag('instance-id') ?? process.env.CACHLY_BRAIN_INSTANCE_ID;
     const maxFiles = parseInt(flag('max-files') ?? '500', 10);
     const namespace = flag('namespace') ?? 'cachly:sem:code';
-    if (!instanceId || !JWT) {
+    if (!instanceId || !getJWT()) {
         console.error('\n❌  CACHLY_BRAIN_INSTANCE_ID and CACHLY_JWT must be set\n');
         console.error('   export CACHLY_BRAIN_INSTANCE_ID=<uuid>');
         console.error('   export CACHLY_JWT=<cky_live_...>');
@@ -2595,7 +2704,7 @@ if (process.argv[2] === 'learn-git') {
     const repoDir = resolve(flag('dir') ?? argv.find(a => !a.startsWith('--')) ?? '.');
     const instanceId = flag('instance-id') ?? process.env.CACHLY_BRAIN_INSTANCE_ID;
     const maxCommits = parseInt(flag('max-commits') ?? '50', 10);
-    if (!instanceId || !JWT) {
+    if (!instanceId || !getJWT()) {
         console.error('\n❌  CACHLY_BRAIN_INSTANCE_ID and CACHLY_JWT must be set\n');
         console.error('   export CACHLY_BRAIN_INSTANCE_ID=<uuid>');
         console.error('   export CACHLY_JWT=<cky_live_...>');
@@ -2611,7 +2720,7 @@ if (process.argv[2] === 'learn-git') {
             limit: maxCommits,
         });
         console.log(result);
-        sendFunnelEvent('brain_from_git', { api_key: JWT, instance_id: instanceId });
+        sendFunnelEvent('brain_from_git', { instance_id: instanceId });
         console.log('\n✅  Brain learned from your commits.\n');
         // Let fire-and-forget telemetry flush before exit.
         await new Promise(r => setTimeout(r, 300));
@@ -2627,7 +2736,8 @@ if (process.argv[2] === 'learn-git') {
 // actionable message in their editor's MCP log instead of silent failures.
 // Skip for CLI commands that intentionally run without credentials.
 const _cliNoAuthCommands = ['demo', 'share', 'health', 'setup', 'init', 'digest', 'invite', 'badge', 'join', 'upgrade'];
-if (!JWT && !_cliNoAuthCommands.includes(process.argv[2] ?? '') && !(!process.argv[2] && process.stdout.isTTY)) {
+// In multi-tenant HTTP mode (PORT set) we never need a startup JWT — per-request auth.
+if (!JWT && !process.env.PORT && !_cliNoAuthCommands.includes(process.argv[2] ?? '') && !(!process.argv[2] && process.stdout.isTTY)) {
     // No args + no JWT in a non-TTY context = running as MCP server without credentials.
     // Print actionable setup banner to stdout so it's captured by callers/tests.
     const banner = '\n' +
@@ -2691,12 +2801,79 @@ if (!process.env.CACHLY_NO_UPDATE_CHECK) {
     })();
 }
 const httpPort = process.env.PORT ? parseInt(process.env.PORT, 10) : undefined;
+// ── Per-request MCP Server factory (HTTP / Smithery stateless mode) ──────────
+// SDK ≥1.9 forbids reusing a stateless transport across requests.
+// Solution: create a fresh Server+Transport per /mcp request.
+// The module-level `server` below is used for stdio mode only.
+function createHttpMcpServer() {
+    const srv = new Server({ name: 'cachly-mcp', version: CURRENT_VERSION }, { capabilities: { tools: {} } });
+    srv.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+    srv.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        try {
+            const text = await handleTool(name, (args ?? {}));
+            return { content: [{ type: 'text', text }] };
+        }
+        catch (err) {
+            if (err instanceof McpError)
+                throw err;
+            throw new McpError(ErrorCode.InternalError, err.message);
+        }
+    });
+    return srv;
+}
 if (httpPort) {
     // ── HTTP mode (Streamable HTTP transport) ───────────────────────────────
     // Used for Smithery URL deployment: PORT=3000 node dist/index.js
+    // Multi-tenant: per-request JWT + instance ID resolved via:
+    //   1. Authorization: Bearer <jwt>  +  X-Cachly-Instance-Id: <uuid>
+    //   2. Smithery config: ?config=base64url({CACHLY_JWT, CACHLY_BRAIN_INSTANCE_ID, ...})
+    // Falls back to module-level env-derived values when neither is provided.
     const { createServer } = await import('node:http');
-    const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
-    await server.connect(transport);
+    function extractReqCtx(req, url) {
+        let jwtVal = '';
+        let instId = '';
+        const auth = req.headers['authorization'];
+        if (typeof auth === 'string' && auth.trim()) {
+            const a = auth.trim();
+            jwtVal = a.toLowerCase().startsWith('bearer ') ? a.slice(7).trim() : a;
+        }
+        // Fallback: raw JWT in custom header (Smithery "header" transport without Bearer prefix)
+        if (!jwtVal) {
+            const rawJwt = req.headers['cachly_jwt'] ?? req.headers['cachly-jwt'] ?? req.headers['x-cachly-jwt'] ?? req.headers['x-api-key'];
+            if (typeof rawJwt === 'string')
+                jwtVal = rawJwt.trim();
+        }
+        const hdrInst = req.headers['x-cachly-instance-id'];
+        if (typeof hdrInst === 'string')
+            instId = hdrInst.trim();
+        // Smithery passes user config as a base64url-encoded JSON blob in ?config=
+        const cfgParam = url.searchParams.get('config');
+        if (cfgParam && (!jwtVal || !instId)) {
+            try {
+                const b64 = cfgParam.replace(/-/g, '+').replace(/_/g, '/');
+                const padded = b64 + '='.repeat((4 - b64.length % 4) % 4);
+                const json = JSON.parse(Buffer.from(padded, 'base64').toString('utf8'));
+                if (!jwtVal && typeof json.CACHLY_JWT === 'string')
+                    jwtVal = json.CACHLY_JWT;
+                if (!instId && typeof json.CACHLY_BRAIN_INSTANCE_ID === 'string')
+                    instId = json.CACHLY_BRAIN_INSTANCE_ID;
+            }
+            catch { /* malformed config — ignore, fall back to globals */ }
+        }
+        // Direct query params (Smithery "query" transport, manual clients, etc.)
+        if (!jwtVal) {
+            const q = url.searchParams.get('CACHLY_JWT') ?? url.searchParams.get('cachly_jwt') ?? url.searchParams.get('api_key');
+            if (q)
+                jwtVal = q.trim();
+        }
+        if (!instId) {
+            const q = url.searchParams.get('CACHLY_BRAIN_INSTANCE_ID') ?? url.searchParams.get('cachly_brain_instance_id') ?? url.searchParams.get('instance_id');
+            if (q)
+                instId = q.trim();
+        }
+        return { jwt: jwtVal, instanceId: instId };
+    }
     const httpServer = createServer((req, res) => {
         const url = new URL(req.url ?? '/', `http://localhost:${httpPort}`);
         if (url.pathname === '/health') {
@@ -2704,6 +2881,8 @@ if (httpPort) {
             res.end(JSON.stringify({
                 status: 'ok',
                 version: CURRENT_VERSION,
+                transport: 'streamable-http',
+                multiTenant: true,
                 zeroResults: {
                     total: zeroResultsTotal,
                     last10: ZERO_RESULTS_LOG.slice(-10).map(e => ({ query: e.query, ts: new Date(e.ts).toISOString() })),
@@ -2711,8 +2890,52 @@ if (httpPort) {
             }));
             return;
         }
+        // Static server card — lets Smithery skip live scanning (avoids auth complexity).
+        if (url.pathname === '/.well-known/mcp/server-card.json') {
+            const card = {
+                name: 'cachly AI Brain',
+                version: CURRENT_VERSION,
+                description: 'Persistent AI memory for Claude Code, Cursor, Copilot, Windsurf & friends. Remembers every lesson, fix, and architecture decision forever.',
+                transport: { type: 'streamable-http', url: 'https://mcp.cachly.dev/mcp' },
+                capabilities: { tools: {} },
+            };
+            res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+            res.end(JSON.stringify(card));
+            return;
+        }
         if (url.pathname === '/mcp' || url.pathname === '/') {
-            transport.handleRequest(req, res);
+            // Handle CORS preflight
+            if (req.method === 'OPTIONS') {
+                res.writeHead(204, {
+                    'Access-Control-Allow-Origin': '*',
+                    'Access-Control-Allow-Methods': 'GET, POST, DELETE, OPTIONS',
+                    'Access-Control-Allow-Headers': 'Authorization, Content-Type, Mcp-Session-Id, X-Cachly-Instance-Id, cachly_jwt, cachly-jwt, x-cachly-jwt, x-api-key',
+                });
+                res.end();
+                return;
+            }
+            const ctx = extractReqCtx(req, url);
+            // Create a fresh Server+Transport for each request (stateless multi-tenant mode).
+            // SDK ≥1.9 throws if a stateless transport is reused across requests.
+            const reqServer = createHttpMcpServer();
+            const reqTransport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+            reqServer.connect(reqTransport).then(() => {
+                reqCtx.run(ctx, () => {
+                    reqTransport.handleRequest(req, res).catch((err) => {
+                        process.stderr.write(`cachly-mcp HTTP handler error: ${err.message}\n`);
+                        if (!res.headersSent) {
+                            res.writeHead(500, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify({ error: 'internal_error' }));
+                        }
+                    });
+                });
+            }).catch((err) => {
+                process.stderr.write(`cachly-mcp connect error: ${err.message}\n`);
+                if (!res.headersSent) {
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'internal_error' }));
+                }
+            });
             return;
         }
         res.writeHead(404);
@@ -2727,5 +2950,4 @@ else {
     const transport = new StdioServerTransport();
     await server.connect(transport);
 }
-notify('cachly', 'startup', { version: CURRENT_VERSION, mode: process.env.MCP_HTTP_PORT ? 'http' : 'stdio' }).catch(() => undefined);
 //# sourceMappingURL=index.js.map