@cachly-dev/mcp-server 0.10.46 → 0.10.47

package/src/handlers/brain.ts

@@ -417,27 +417,8 @@ export async function handleBrainTool(
           ? `📌 **You've looked this up 3 times.** Consider pinning it for instant access: add \`pinned: true\` via \`learn_from_attempts\` to always surface it first.`
           : '';
 
-        // ── Trust signal (today-safe consensus layer) ───────────────────────
-        // A lesson recalled many times — or confirmed by multiple distinct
-        // authors — has proven its value. Surface that as social proof.
-        const lessonAuthors = (lesson as { authors?: string[]; author?: string }).authors
-          ?? ((lesson as { author?: string }).author ? [(lesson as { author?: string }).author!] : []);
-        const distinctAuthors = [...new Set(lessonAuthors.filter(Boolean))];
-        const rc = updatedLesson.recall_count;
-        let trustBadge = '';
-        if (distinctAuthors.length >= 2 && rc >= 5) {
-          trustBadge = `🏆 **Battle-tested** — recalled ${rc}× · verified by ${distinctAuthors.length} developers. Trust this.`;
-        } else if (rc >= 10) {
-          trustBadge = `🏆 **Battle-tested** — recalled ${rc}×. This is one of your most-proven solutions.`;
-        } else if (distinctAuthors.length >= 2) {
-          trustBadge = `✅ **Team-verified** — confirmed by ${distinctAuthors.length} developers.`;
-        } else if (rc >= 5) {
-          trustBadge = `✅ **Proven** — recalled ${rc}× without contradiction.`;
-        }
-
         return [
           rememberWhen,
-          trustBadge,
           `${badge} **Best solution for \`${topic}\`** ${sevEmoji}${lesson.severity ? ` (${lesson.severity})` : ''} · recalled ${updatedLesson.recall_count}×`,
           ``,
           `**What worked:** ${lesson.what_worked}`,
@@ -502,22 +483,6 @@ export async function handleBrainTool(
         10,
       );
 
-      // Increment recall_count on matched lessons (fire-and-forget — same as recall_best_solution).
-      // This ensures the dashboard metric, Proven Laws, and trust badges reflect real smart_recall usage.
-      const lessonMatches = kwMatches.filter(m => m.key.startsWith('cachly:lesson:best:'));
-      for (const m of lessonMatches.slice(0, 5)) {
-        const existing = await redis.get(m.key).catch(() => null);
-        if (existing) {
-          const lesson = safeJsonParse(existing, null as null | { recall_count?: number; [k: string]: unknown });
-          if (lesson) {
-            const updated = { ...lesson, recall_count: (lesson.recall_count ?? 0) + 1, verified_at: new Date().toISOString() };
-            redis.set(m.key, JSON.stringify(updated)).catch(() => {});
-            const savedMins = (lesson.severity as string) === 'critical' ? 240 : (lesson.severity as string) === 'major' ? 60 : 30;
-            redis.incrbyfloat(`cachly:stats:time_saved_mins:${instance_id}`, savedMins).catch(() => {});
-          }
-        }
-      }
-
       const lines: string[] = [`🧠 **Smart Recall** for: _"${query}"_\n`];
 
       // Show sub-query info if multi-topic was detected
@@ -932,31 +897,6 @@ export async function handleBrainTool(
       // Brain health
       lines.push(`📊 **Brain:** ${lessons.length} lessons · ${ctxCount} context entries`, '');
 
-      // ── 📌 Proven Laws — auto-crystallized lessons (quick win 3) ─────────────
-      // A lesson that has proven itself (recalled ≥ CRYSTALLIZE_RECALLS times) or
-      // was explicitly pinned becomes a "law" — surfaced at the top of every
-      // briefing so the most battle-tested knowledge is never buried. This is
-      // the today-safe version of swarm crystallization: enough confirmations
-      // auto-promote a lesson without any manual step.
-      {
-        type LessonPin = typeof lessons[0] & { pinned?: boolean };
-        const CRYSTALLIZE_RECALLS = 5;
-        const laws = (lessons as LessonPin[])
-          .filter(l => l.outcome === 'success' && (l.pinned === true || (l.recall_count ?? 0) >= CRYSTALLIZE_RECALLS))
-          .sort((a, b) => (b.recall_count ?? 0) - (a.recall_count ?? 0))
-          .slice(0, 5);
-        if (laws.length > 0) {
-          lines.push(`📌 **Proven Laws** (auto-crystallized — your most-trusted knowledge):`);
-          for (const l of laws) {
-            const sev = l.severity === 'critical' ? '🔴' : l.severity === 'major' ? '🟡' : '';
-            const rc  = l.recall_count ?? 0;
-            const why = l.pinned === true ? 'pinned' : `recalled ${rc}×`;
-            lines.push(`  🏆${sev} \`${l.topic}\` _(${why})_ — ${l.what_worked.slice(0, 100)}`);
-          }
-          lines.push('');
-        }
-      }
-
       // ── Layer 7: MCM Domain Coverage Map ────────────────────────────────────
       if (lessons.length >= 3) {
         const domainMap = new Map<string, { total: number; success: number; critical: number }>();
@@ -1056,14 +996,8 @@ export async function handleBrainTool(
           for (const l of topRecalled) {
             const emoji = l.outcome === 'success' ? '✅' : l.outcome === 'partial' ? '⚠️' : '❌';
             const sev   = l.severity === 'critical' ? '🔴' : l.severity === 'major' ? '🟡' : '';
-            const rc    = l.recall_count ?? 0;
-            const la     = (l as { authors?: string[]; author?: string }).authors
-              ?? ((l as { author?: string }).author ? [(l as { author?: string }).author!] : []);
-            const nAuthors = new Set(la.filter(Boolean)).size;
-            const trust  = (nAuthors >= 2 && rc >= 5) || rc >= 10 ? ' 🏆'
-              : nAuthors >= 2 || rc >= 5 ? ' ✅' : '';
-            const rct   = rc > 1 ? ` _(${rc}× recalled)_` : '';
-            lines.push(`  ${emoji}${sev}${trust} \`${l.topic}\`${rct} — ${l.what_worked.slice(0, 100)}`);
+            const rct   = l.recall_count && l.recall_count > 1 ? ` _(${l.recall_count}× recalled)_` : '';
+            lines.push(`  ${emoji}${sev} \`${l.topic}\`${rct} — ${l.what_worked.slice(0, 100)}`);
           }
           lines.push('');
         }
@@ -1131,63 +1065,27 @@ export async function handleBrainTool(
       }
 
       // ── 🔮 Predictive Pre-Warning — intent-based danger detection ────────────
-      // Fires BEFORE work starts. Uses explicit focus when given; otherwise
-      // derives the likely work area from the last session's changed files +
-      // summary (you usually keep working where you left off). This makes the
-      // warning fire even when the caller forgets to pass `focus`.
-      {
+      // Fires BEFORE work starts. If focus area has known failure patterns → warn loudly.
+      if (focusTerms.length > 0) {
         type LessonAny = typeof lessons[0] & { author?: string; tags?: string[] };
-
-        // Common path noise / extensions to drop when deriving terms from files.
-        const PATH_NOISE = new Set([
-          'src', 'lib', 'test', 'tests', 'dist', 'index', 'main', 'app',
-          'internal', 'pkg', 'cmd', 'node_modules', 'components', 'utils',
-          'ts', 'tsx', 'js', 'jsx', 'go', 'py', 'rs', 'java', 'json', 'yaml', 'yml',
-        ]);
-        const deriveTermsFromFiles = (files: string[]): string[] => {
-          const terms = new Set<string>();
-          for (const f of files) {
-            for (const seg of f.toLowerCase().split(/[/\\._-]/)) {
-              if (seg.length > 3 && !PATH_NOISE.has(seg)) terms.add(seg);
-            }
-          }
-          return [...terms];
-        };
-
-        let warnTerms = focusTerms;
-        let warnLabel = focus;
-        let derived = false;
-        if (warnTerms.length === 0 && lastSession) {
-          const fromFiles = deriveTermsFromFiles(lastSession.files_changed ?? []);
-          const fromSummary = (lastSession.summary ?? '').toLowerCase()
-            .replace(/[^a-z0-9\s:_-]/g, ' ').split(/\s+/).filter(t => t.length > 3 && !PATH_NOISE.has(t));
-          warnTerms = [...new Set([...fromFiles, ...fromSummary])];
-          warnLabel = 'where you left off last session';
-          derived = true;
-        }
-
-        if (warnTerms.length > 0) {
-          const dangerLessons = (lessons as LessonAny[]).filter(l => {
-            if (l.outcome === 'success') return false;
-            const topicCategory = l.topic.split(':')[0];
-            return warnTerms.some(term =>
-              l.topic.toLowerCase().includes(term) ||
-              topicCategory === term ||
-              (l.tags ?? []).some((t: string) => t.toLowerCase() === term),
-            );
-          });
-          if (dangerLessons.length >= 1) {
-            const headline = derived
-              ? `  You're likely to continue **${warnLabel}** — ${dangerLessons.length} known pitfall${dangerLessons.length > 1 ? 's' : ''} there:`
-              : `  Known pitfalls for **"${warnLabel}"** (${dangerLessons.length} past failure${dangerLessons.length > 1 ? 's' : ''}):`;
-            const warning = [
-              `🚨 **PRE-WARNING** — Read this BEFORE starting:`,
-              headline,
-              ...dangerLessons.slice(0, 3).map(l => `  ❌ \`${l.topic}\` — ${(l.what_failed ?? l.what_worked).slice(0, 80)}`),
-              '',
-            ];
-            lines.splice(2, 0, ...warning); // after '🧠 **Session Briefing**' + empty line
-          }
+        const dangerLessons = (lessons as LessonAny[]).filter(l => {
+          if (l.outcome === 'success') return false;
+          const topicCategory = l.topic.split(':')[0];
+          return focusTerms.some(term =>
+            l.topic.toLowerCase().includes(term) ||
+            topicCategory === term ||
+            (l.tags ?? []).some((t: string) => t.toLowerCase() === term),
+          );
+        });
+        if (dangerLessons.length >= 1) {
+          // Insert warning block right after the title line (index 1 = blank line after title)
+          const warning = [
+            `🚨 **PRE-WARNING** — Read this BEFORE starting:`,
+            `  Known pitfalls for **"${focus}"** (${dangerLessons.length} past failure${dangerLessons.length > 1 ? 's' : ''}):`,
+            ...dangerLessons.slice(0, 3).map(l => `  ❌ \`${l.topic}\` — ${(l.what_failed ?? l.what_worked).slice(0, 80)}`),
+            '',
+          ];
+          lines.splice(2, 0, ...warning); // after '🧠 **Session Briefing**' + empty line
         }
       }
 

package/src/index.ts

@@ -54,13 +54,23 @@ import {
   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.46';
+const CURRENT_VERSION = '0.10.47';
+
+// ── Per-request context (multi-tenant HTTP / Smithery) ───────────────────────
+// In stdio mode the module-level JWT/instance globals apply.
+// In HTTP mode, the request handler runs each request in an ALS scope that
+// shadows JWT + instance ID with per-user values extracted from headers.
+interface ReqCtx { jwt: string; instanceId: string; }
+const reqCtx = new AsyncLocalStorage<ReqCtx>();
+function getJWT(): string { return reqCtx.getStore()?.jwt || JWT; }
+function getDefaultInstanceId(): string { 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.
@@ -70,15 +80,18 @@ let _defaultInstanceId: string = process.env.CACHLY_BRAIN_INSTANCE_ID ?? '';
 let _defaultInstanceLastAttempt = 0;
 
 async function resolveDefaultInstanceId(): Promise<string> {
+  // 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) return '';
+  if (!getJWT()) return '';
   // Cooldown: don't hammer the API on every tool call after a transient failure.
   const now = Date.now();
   if (_defaultInstanceLastAttempt > 0 && now - _defaultInstanceLastAttempt < 30_000) return '';
   _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) return '';
@@ -174,7 +187,7 @@ async function pollDeviceFlow(flow: DeviceFlowState): Promise<'pending' | 'expir
         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) {
@@ -189,7 +202,7 @@ async function pollDeviceFlow(flow: DeviceFlowState): Promise<'pending' | 'expir
             // 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(() => {});
@@ -201,7 +214,7 @@ async function pollDeviceFlow(flow: DeviceFlowState): Promise<'pending' | 'expir
       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) {
@@ -212,7 +225,7 @@ async function pollDeviceFlow(flow: DeviceFlowState): Promise<'pending' | 'expir
               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) {
@@ -283,7 +296,19 @@ async function getConnection(instance_id: string): Promise<Redis> {
     );
   }
 
-  if (pool.has(instance_id)) return pool.get(instance_id)!;
+  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 as any).status as string | undefined;
+    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 25 s if it is still provisioning.
   // This covers the zero-friction path: device-flow auth → auto-provision → first tool call
@@ -301,7 +326,7 @@ async function getConnection(instance_id: string): Promise<Redis> {
     // 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(() => {});
@@ -365,14 +390,45 @@ async function getConnection(instance_id: string): Promise<Redis> {
   client.on('error', evict);
   client.on('end', evict);
 
-  try {
-    await client.connect();
-  } catch (err: unknown) {
+  // 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: unknown;
+  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,
+          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;
+    }
+  }
+
+  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(() => {});
@@ -392,14 +448,14 @@ async function getConnection(instance_id: string): Promise<Redis> {
 // ── API helper ────────────────────────────────────────────────────────────────
 
 async function apiFetch<T>(path: string, options: RequestInit = {}): Promise<T> {
-  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,
     },
   });
@@ -454,7 +510,7 @@ function sendFunnelEvent(event: string, extra?: Record<string, unknown>): void {
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify({
       event, version: CURRENT_VERSION, editor: detectEditor(),
-      ...(JWT ? { jwt: JWT } : {}),
+      ...(getJWT() ? { jwt: getJWT() } : {}),
       ...extra,
     }),
     signal: AbortSignal.timeout(3000),
@@ -477,7 +533,7 @@ async function sendAnonymousTelemetry(toolName: string): Promise<void> {
 
 async function handleTool(name: string, args: Record<string, unknown>): Promise<string> {
   // Guard: if no JWT, return actionable onboarding message instead of HTTP 401
-  if (!JWT) {
+  if (!getJWT()) {
     void sendAnonymousTelemetry(name);
 
     // ── Zero-credential device flow ─────────────────────────────────────
@@ -557,14 +613,14 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
   // Delegate brain tools (learn, recall, session, etc.)
   const 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 as string | undefined) ?? _defaultInstanceId ?? '';
-    const telemetryExtra = JWT ? { api_key: JWT, instance_id: instanceId } : { instance_id: instanceId };
+    const instanceId = (args.instance_id as string | undefined) ?? 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);
@@ -625,9 +681,9 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
   // 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;
   }
@@ -653,8 +709,8 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
   if (syndicateResult !== null) {
     // brain_predict is in syndicate handler — track telemetry here.
     if (name === 'brain_predict') {
-      const instanceId = (args.instance_id as string | undefined) ?? _defaultInstanceId ?? '';
-      const telemetryExtra = JWT ? { api_key: JWT, instance_id: instanceId } : { instance_id: instanceId };
+      const instanceId = (args.instance_id as string | undefined) ?? getDefaultInstanceId() ?? '';
+      const telemetryExtra = getJWT() ? { api_key: getJWT(), instance_id: instanceId } : { instance_id: instanceId };
       sendFunnelEvent('brain_predict', telemetryExtra);
     }
     return syndicateResult;
@@ -663,8 +719,8 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
   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 as string | undefined) ?? _defaultInstanceId ?? '';
-    const telemetryExtra = JWT ? { api_key: JWT, instance_id: instanceId } : { instance_id: instanceId };
+    const instanceId = (args.instance_id as string | undefined) ?? getDefaultInstanceId() ?? '';
+    const telemetryExtra = getJWT() ? { api_key: getJWT(), instance_id: instanceId } : { instance_id: instanceId };
     if (name === 'brain_from_git') {
       sendFunnelEvent('brain_from_git', telemetryExtra);
     } else if (name === 'brain_predict_failures') {
@@ -691,7 +747,7 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
       }
 
       // Check JWT / auth
-      if (!JWT) {
+      if (!getJWT()) {
         return [
           `📡 **cachly API Status**`,
           ``,
@@ -706,7 +762,7 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
       // Decode JWT claims (inspection only, no verification)
       let authInfo = '❌ invalid JWT format';
       try {
-        const parts = JWT.split('.');
+        const parts = getJWT().split('.');
         if (parts.length === 3) {
           const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString('utf-8')) as {
             sub?: string; exp?: number; iss?: string;
@@ -739,7 +795,7 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
           const lines: string[] = ['\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
@@ -2156,7 +2212,6 @@ if (process.argv[2] === 'setup') {
     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;
@@ -2180,7 +2235,6 @@ if (process.argv[2] === 'setup') {
       console.error('Falling back: sign in at https://cachly.dev/setup-ai and paste your API token.\n');
       token = await ask('   Paste API token (cky_live_...): ');
       if (!token) { console.error('\nToken is required. Aborting.\n'); rl.close(); process.exit(1); }
-      sendFunnelEvent('setup_auth_completed');
       console.log('');
       deviceCode = ''; // mark as fallback so we skip polling
     }
@@ -2214,7 +2268,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
@@ -2331,7 +2384,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();
@@ -2577,7 +2629,7 @@ if (process.argv[2] === 'index') {
   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_...>');
@@ -2619,7 +2671,7 @@ if (process.argv[2] === 'learn-git') {
   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_...>');
@@ -2654,7 +2706,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 =
@@ -2730,9 +2783,37 @@ const httpPort = process.env.PORT ? parseInt(process.env.PORT, 10) : undefined;
 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: import('node:http').IncomingMessage, url: URL): ReqCtx {
+    let jwtVal = '';
+    let instId = '';
+    const auth = req.headers['authorization'];
+    if (typeof auth === 'string' && auth.toLowerCase().startsWith('bearer ')) {
+      jwtVal = auth.slice(7).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 */ }
+    }
+    return { jwt: jwtVal, instanceId: instId };
+  }
+
   const httpServer = createServer((req, res) => {
     const url = new URL(req.url ?? '/', `http://localhost:${httpPort}`);
     if (url.pathname === '/health') {
@@ -2740,6 +2821,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() })),
@@ -2748,7 +2831,16 @@ if (httpPort) {
       return;
     }
     if (url.pathname === '/mcp' || url.pathname === '/') {
-      transport.handleRequest(req, res);
+      const ctx = extractReqCtx(req, url);
+      reqCtx.run(ctx, () => {
+        transport.handleRequest(req, res).catch((err) => {
+          process.stderr.write(`cachly-mcp HTTP handler error: ${(err as Error).message}\n`);
+          if (!res.headersSent) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'internal_error' }));
+          }
+        });
+      });
       return;
     }
     res.writeHead(404);