@cachly-dev/mcp-server 0.10.0 → 0.10.1

package/src/handlers/fedbrain.ts

@@ -6,7 +6,6 @@ import { calculateConfidence, confidenceBadge, CONFIDENCE_WARN_VALUE, CONFIDENCE
 import { ckgSlug, extractProblemConcept, ckgUpsertNode, ckgUpdateEdge } from '../ckg.js';
 import type { CKGEdge, CKGNode } from '../ckg.js';
 import { keywordSearch, tokenize } from '../search.js';
-import { safeJsonParse } from '../utils.js';
 import { computeEmbedding, hasEmbedProvider } from '../embeddings.js';
 
 // Git concurrency semaphore (for brain_from_git parallel workers)
@@ -398,8 +397,7 @@ export async function handleFedbrainTool(
       const raw = await redis.get(`cachly:lesson:best:${lesson_key}`);
       if (!raw) return `❌ Lesson \`${lesson_key}\` not found. Store it first with \`learn_from_attempts\`.`;
 
-      const lesson = safeJsonParse(raw, null as null | { topic: string; outcome: string; what_worked: string; what_failed?: string; tags?: string[]; commands?: string[]; severity?: string; ts?: string });
-      if (!lesson) return `❌ Lesson \`${lesson_key}\` data is corrupted. Re-store with \`learn_from_attempts\`.`;
+      const lesson = JSON.parse(raw) as { topic: string; outcome: string; what_worked: string; what_failed?: string; tags?: string[]; commands?: string[]; severity?: string; ts?: string };
 
       const domainTokens = [lesson.topic.split(':')[0], ...(lesson.tags ?? [])].filter(Boolean);
       const domainFingerprint = [...new Set(domainTokens)].sort().join(',');
@@ -749,8 +747,7 @@ export async function handleFedbrainTool(
       }
 
       type Crystal = { label: string; ts: string; session_count: number; lesson_count: number; top_patterns: Array<{ category: string; insight: string; count: number }>; categories: string[]; created_from: string };
-      const crystal = safeJsonParse<Crystal | null>(raw, null);
-      if (!crystal) return `❌ Memory Crystal data is corrupted. Re-create with \`memory_crystalize()\`.`;
+      const crystal: Crystal = JSON.parse(raw);
       const age = Math.floor((Date.now() - new Date(crystal.ts).getTime()) / 86400000);
       const freshEmoji = age <= 7 ? '🟢' : age <= 30 ? '🟡' : '🔴';
 
@@ -787,55 +784,49 @@ export async function handleFedbrainTool(
       const crystalRaw = await redis.get('cachly:crystal:latest');
       if (crystalRaw) {
         type Crystal = { label: string; ts: string; session_count: number; lesson_count: number; top_patterns: Array<{ category: string; insight: string; count: number }> };
-        const crystal = safeJsonParse<Crystal | null>(crystalRaw, null);
-        if (crystal) {
-          lines.push(`### 💎 Memory Crystal: ${crystal.label}`);
-          lines.push(`Compressed from ${crystal.session_count} sessions, ${crystal.lesson_count} lessons.`);
-          const topN = focus
-            ? crystal.top_patterns.filter(p => p.category.toLowerCase().includes(focus.toLowerCase()) || p.insight.toLowerCase().includes(focus.toLowerCase())).slice(0, 4)
-            : crystal.top_patterns.slice(0, 4);
-          for (const p of topN) lines.push(`  • **${p.category}**: ${p.insight.slice(0, 100)}`);
-          lines.push('');
-        }
+        const crystal: Crystal = JSON.parse(crystalRaw);
+        lines.push(`### 💎 Memory Crystal: ${crystal.label}`);
+        lines.push(`Compressed from ${crystal.session_count} sessions, ${crystal.lesson_count} lessons.`);
+        const topN = focus
+          ? crystal.top_patterns.filter(p => p.category.toLowerCase().includes(focus.toLowerCase()) || p.insight.toLowerCase().includes(focus.toLowerCase())).slice(0, 4)
+          : crystal.top_patterns.slice(0, 4);
+        for (const p of topN) lines.push(`  • **${p.category}**: ${p.insight.slice(0, 100)}`);
+        lines.push('');
       }
 
       // 2. Last session summary
       const lastSession = await redis.get('cachly:session:last');
       if (lastSession) {
         type Session = { summary?: string; ts?: string; focus?: string };
-        const sess = safeJsonParse<Session | null>(lastSession, null);
-        if (sess) {
-          lines.push(`### 🕐 Last Session`);
-          if (sess.focus) lines.push(`Focus: _${sess.focus}_`);
-          if (sess.summary) lines.push(`Summary: ${sess.summary.slice(0, 300)}`);
-          lines.push('');
-        }
+        const sess: Session = JSON.parse(lastSession);
+        lines.push(`### 🕐 Last Session`);
+        if (sess.focus) lines.push(`Focus: _${sess.focus}_`);
+        if (sess.summary) lines.push(`Summary: ${sess.summary.slice(0, 300)}`);
+        lines.push('');
       }
 
       // 3. Session handoff
       const handoff = await redis.get('cachly:session:handoff');
       if (handoff) {
         type Handoff = { remaining_tasks?: string[]; instructions?: string; context_summary?: string; blocked_on?: string };
-        const h = safeJsonParse<Handoff | null>(handoff, null);
-        if (h) {
-          lines.push(`### 📋 Handoff (from last window)`);
-          if (h.context_summary) lines.push(`Context: ${h.context_summary.slice(0, 200)}`);
-          if (h.remaining_tasks?.length) {
-            lines.push(`Remaining tasks:`);
-            for (const t of h.remaining_tasks.slice(0, 5)) lines.push(`  • ${t}`);
-          }
-          if (h.instructions) lines.push(`⚠️ Instructions: ${h.instructions.slice(0, 200)}`);
-          if (h.blocked_on) lines.push(`🚧 Blocked on: ${h.blocked_on}`);
-          lines.push('');
+        const h: Handoff = JSON.parse(handoff);
+        lines.push(`### 📋 Handoff (from last window)`);
+        if (h.context_summary) lines.push(`Context: ${h.context_summary.slice(0, 200)}`);
+        if (h.remaining_tasks?.length) {
+          lines.push(`Remaining tasks:`);
+          for (const t of h.remaining_tasks.slice(0, 5)) lines.push(`  • ${t}`);
         }
+        if (h.instructions) lines.push(`⚠️ Instructions: ${h.instructions.slice(0, 200)}`);
+        if (h.blocked_on) lines.push(`🚧 Blocked on: ${h.blocked_on}`);
+        lines.push('');
       }
 
       // 4. WIP registry
       const wipRaw = await redis.get('cachly:ctx:wip-registry');
       if (wipRaw) {
         type Ctx = { content?: string };
-        const wip = safeJsonParse<Ctx | null>(wipRaw, null);
-        if (wip?.content) {
+        const wip: Ctx = JSON.parse(wipRaw);
+        if (wip.content) {
           lines.push(`### 🔧 WIP Registry`);
           lines.push(wip.content.slice(0, 400));
           lines.push('');
@@ -1035,14 +1026,12 @@ export async function handleFedbrainTool(
         for (const nk of nodeKeys.slice(0, 5)) {
           const nodeRaw = await redis.get(nk);
           if (!nodeRaw) continue;
-          const node = safeJsonParse<CKGNode | null>(nodeRaw, null);
-          if (!node) continue;
+          const node: CKGNode = JSON.parse(nodeRaw);
           const edgeKeys = await redis.smembers(`cachly:ckg:idx:from:${node.id}`);
           for (const ek of edgeKeys.slice(0, 20)) {
             const edgeRaw = await redis.get(ek);
             if (!edgeRaw) continue;
-            const edge = safeJsonParse<CKGEdge | null>(edgeRaw, null);
-            if (!edge) continue;
+            const edge: CKGEdge = JSON.parse(edgeRaw);
             if (edge.edgeType !== 'causes' && edge.edgeType !== 'degrades_under') continue;
 
             // Look up fix for this failure from CKG 'fixes' edges
@@ -1051,13 +1040,12 @@ export async function handleFedbrainTool(
             for (const fek of fixEdgeKeys.slice(0, 10)) {
               const feRaw = await redis.get(fek);
               if (!feRaw) continue;
-              const fe = safeJsonParse<CKGEdge | null>(feRaw, null);
-              if (!fe) continue;
+              const fe: CKGEdge = JSON.parse(feRaw);
               if (fe.edgeType === 'fixes') {
                 const lessonRaw = await redis.get(`cachly:lesson:best:${fe.from}`);
                 if (lessonRaw) {
-                  const lesson = safeJsonParse(lessonRaw, null as null | { what_worked?: string });
-                  fix = lesson?.what_worked?.slice(0, 120);
+                  const lesson = JSON.parse(lessonRaw) as { what_worked?: string };
+                  fix = lesson.what_worked?.slice(0, 120);
                   break;
                 }
               }

package/src/handlers/team.ts

@@ -5,7 +5,6 @@ import type { Redis } from 'ioredis';
 import { calculateConfidence, confidenceBadge, CONFIDENCE_STALE_VALUE, CONFIDENCE_WARN_VALUE,
          CONFIDENCE_WARN_DAYS, CONFIDENCE_STALE_DAYS, simpleHash } from '../confidence.js';
 import type { Instance } from './brain.js';
-import { safeJsonParse } from '../utils.js';
 
 type GetConnection = (instanceId: string) => Promise<Redis>;
 type ApiFetch = <T>(path: string, options?: RequestInit) => Promise<T>;
@@ -54,11 +53,10 @@ export async function handleTeamTool(
 
       type Lesson = { topic: string; what_worked: string; outcome: string; file_paths?: string[] };
       const relevant: string[] = [];
-      const sfRaws = lessonKeys.length > 0 ? await redis.mget(...lessonKeys) : [];
-      for (const raw of sfRaws) {
+      for (const k of lessonKeys) {
+        const raw = await redis.get(k);
         if (!raw) continue;
-        const lesson = safeJsonParse<Lesson | null>(raw, null);
-        if (!lesson) continue;
+        const lesson = JSON.parse(raw) as Lesson;
         // Match by file_paths stored in lesson OR by topic keywords matching file name
         const topicWords = lesson.topic.toLowerCase().split(/[:\-_]/);
         const fileMatches = changed_files.some(f => {
@@ -148,12 +146,10 @@ export async function handleTeamTool(
         author?: string; tags?: string[];
       };
       let lessons: TeamLesson[] = [];
-      if (lessonKeys.length > 0) {
-        const raws = await redis.mget(...lessonKeys);
-        for (const raw of raws) {
-          const l = safeJsonParse<TeamLesson | null>(raw ?? null, null);
-          if (l) lessons.push(l);
-        }
+      for (const k of lessonKeys) {
+        const raw = await redis.get(k);
+        if (!raw) continue;
+        try { lessons.push(JSON.parse(raw) as TeamLesson); } catch { /* skip */ }
       }
 
       // Filter
@@ -282,12 +278,10 @@ export async function handleTeamTool(
 
       type RawLesson = { topic: string; outcome: string; what_worked: string; severity?: string; ts: string; auto_learned?: boolean };
       const allLessons: RawLesson[] = [];
-      if (allLessonKeys.length > 0) {
-        const raws = await redis.mget(...allLessonKeys);
-        for (const raw of raws) {
-          const l = safeJsonParse<RawLesson | null>(raw ?? null, null);
-          if (l) allLessons.push(l);
-        }
+      for (const k of allLessonKeys) {
+        const raw = await redis.get(k);
+        if (!raw) continue;
+        try { allLessons.push(JSON.parse(raw) as RawLesson); } catch { /* skip */ }
       }
 
       // Group lessons by top-level category
@@ -373,17 +367,18 @@ export async function handleTeamTool(
         verified_at?: string; severity?: string; audit_trail?: unknown[];
       };
       const lessons: DrLesson[] = [];
-      if (lessonKeys.length > 0) {
-        const raws = await redis.mget(...lessonKeys);
-        for (const raw of raws) {
-          const l = safeJsonParse<DrLesson | null>(raw ?? null, null);
-          if (l) lessons.push(l);
-        }
+      for (const k of lessonKeys) {
+        const raw = await redis.get(k);
+        if (!raw) continue;
+        try { lessons.push(JSON.parse(raw) as DrLesson); } catch { /* skip */ }
       }
 
       // Last session
       const lastSessionRaw = await redis.get('cachly:session:last');
-      const lastSession = safeJsonParse<{ ts: string; summary: string } | null>(lastSessionRaw, null);
+      let lastSession: { ts: string; summary: string } | null = null;
+      if (lastSessionRaw) {
+        try { lastSession = JSON.parse(lastSessionRaw); } catch { /* ignore */ }
+      }
 
       // Open failures
       const openFailures = lessons.filter(l => l.outcome === 'failure' || l.outcome === 'partial');
@@ -514,24 +509,13 @@ export async function handleTeamTool(
         issues.push(`💡 ${unusedLessons.length} lessons never recalled — verify topics match your workflow`);
       }
 
-      const divider = '─'.repeat(48);
-      const lines = [
-        `🩺 **Brain Doctor**`,
-        `\`${divider}\``,
-        '',
-        '**📊 Health Checks**',
-        ...checks.map(c => '  ' + c),
-        '',
-      ];
+      const lines = ['🩺 **Brain Doctor Report**', '', ...checks.map(c => '  ' + c), ''];
       if (issues.length > 0) {
-        lines.push(`**🔧 Action Items** (${issues.length} issue${issues.length > 1 ? 's' : ''})`);
-        issues.forEach((item, idx) => lines.push(`  ${idx + 1}. ${item}`));
+        lines.push('**Issues to fix:**');
+        for (const i of issues) lines.push('  ' + i);
         lines.push('');
-        lines.push(`_Fix the action items above, then re-run \`brain_doctor\` to verify._`);
       } else {
-        lines.push('**✅ All checks passed** — Brain is healthy!');
-        lines.push('');
-        lines.push('_Keep the brain sharp: `session_start` → work → `learn_from_attempts` → `session_end`_');
+        lines.push('  🎉 Brain looks healthy! Keep calling session_start/session_end.');
       }
       return lines.join('\n');
     }
@@ -552,11 +536,7 @@ export async function handleTeamTool(
         .filter((l): l is NonNullable<typeof l> => l !== null && new Date(l.ts).getTime() <= cutoff)
         .sort((a, b) => new Date(a.ts).getTime() - new Date(b.ts).getTime());
 
-      if (before.length === 0) {
-        const first = safeJsonParse(all[0] ?? null, null as null | { ts?: string });
-        const earliest = first?.ts ? new Date(first.ts).toLocaleDateString('de-DE') : 'unknown';
-        return `📭 No entries for \`${topic}\` found before **${date}**. Earliest entry: ${earliest}.`;
-      }
+      if (before.length === 0) return `📭 No entries for \`${topic}\` found before **${date}**. Earliest entry: ${new Date(JSON.parse(all[0]).ts).toLocaleDateString('de-DE')}.`;
 
       const lines = [
         `🏺 **Brain Archaeology: \`${topic}\` before ${date}**`,
@@ -583,7 +563,7 @@ export async function handleTeamTool(
       const raw = await redis.get(depKey);
       if (!raw) return `📭 No lessons found that depend on \`${dependency}\`.\n\nAdd dependencies via: \`learn_from_attempts(..., depends_on=["${dependency}"])\``;
 
-      const topics: string[] = safeJsonParse<string[]>(raw, []);
+      const topics: string[] = JSON.parse(raw);
       const lines = [
         `🔗 **Causal Chain: \`${dependency}\`** — ${topics.length} dependent lesson${topics.length === 1 ? '' : 's'}`,
         '',
@@ -592,8 +572,7 @@ export async function handleTeamTool(
       for (const t of topics) {
         const lessonRaw = await redis.get(`cachly:lesson:best:${t}`);
         if (!lessonRaw) { lines.push(`  • \`${t}\` _(lesson deleted)_`); continue; }
-        const lesson = safeJsonParse(lessonRaw, null as null | { outcome?: string; severity?: string; needs_review?: boolean });
-        if (!lesson) { lines.push(`  • \`${t}\` _(lesson corrupted)_`); continue; }
+        const lesson = JSON.parse(lessonRaw) as { outcome?: string; severity?: string; needs_review?: boolean };
         const emoji = lesson.outcome === 'success' ? '✅' : lesson.outcome === 'partial' ? '⚠️' : '❌';
         const reviewBadge = lesson.needs_review ? ' 🔍 **needs_review**' : '';
         lines.push(`  ${emoji} \`${t}\` (${lesson.severity ?? 'major'})${reviewBadge}`);
@@ -635,8 +614,8 @@ export async function handleTeamTool(
       // Preserve recall_count on update
       const existing = await redis.get(key);
       if (existing) {
-        const prev = safeJsonParse(existing, null as null | { recall_count?: number });
-        record.recall_count = prev?.recall_count ?? 0;
+        const prev = JSON.parse(existing) as { recall_count?: number };
+        record.recall_count = prev.recall_count ?? 0;
       }
       await redis.set(key, JSON.stringify(record));
       return `🌐 **Global lesson stored**: \`${topic}\`\n\n${lesson}\n\nRecallable from any project via \`global_recall(topic="${topic}")\`.`;
@@ -656,12 +635,10 @@ export async function handleTeamTool(
 
       type GlobalLesson = { topic: string; lesson: string; severity?: string; ts: string; recall_count?: number };
       let lessons: GlobalLesson[] = [];
-      if (keys.length > 0) {
-        const raws = await redis.mget(...keys);
-        for (const raw of raws) {
-          const l = safeJsonParse<GlobalLesson | null>(raw ?? null, null);
-          if (l) lessons.push(l);
-        }
+      for (const k of keys) {
+        const raw = await redis.get(k);
+        if (!raw) continue;
+        try { lessons.push(JSON.parse(raw) as GlobalLesson); } catch { /* skip */ }
       }
 
       if (topic) {
@@ -678,8 +655,7 @@ export async function handleTeamTool(
         const k = `cachly:global:lesson:${l.topic}`;
         const raw = await redis.get(k);
         if (raw) {
-          const rec = safeJsonParse(raw, null as null | { recall_count?: number });
-          if (!rec) continue;
+          const rec = JSON.parse(raw) as { recall_count?: number };
           rec.recall_count = (rec.recall_count ?? 0) + 1;
           await redis.set(k, JSON.stringify(rec));
         }

package/src/index.ts

@@ -52,22 +52,19 @@ import { Redis } from 'ioredis';
 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.0';
+const CURRENT_VERSION = '0.9.17';
 
 // ── 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.
 let _defaultInstanceId: string = process.env.CACHLY_BRAIN_INSTANCE_ID ?? '';
-// Timestamp of last failed fetch — retries after 30 s (not permanently blocked).
-let _defaultInstanceLastAttempt = 0;
+let _defaultInstanceFetched = false;
 
 async function resolveDefaultInstanceId(): Promise<string> {
   if (_defaultInstanceId) return _defaultInstanceId;
+  if (_defaultInstanceFetched) return '';
+  _defaultInstanceFetched = true;
   if (!JWT) 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' },
@@ -75,15 +72,9 @@ async function resolveDefaultInstanceId(): Promise<string> {
     });
     if (!res.ok) return '';
     const data = await res.json() as { data?: Array<{ id: string; status: string }> };
-    const instances = (data?.data ?? []) as Array<{ id: string; status: string }>;
-    // Prefer running, fall back to provisioning so the ID is resolved even during startup.
-    const best = instances.find(i => i.status === 'running') ?? instances.find(i => i.status === 'provisioning');
-    if (best) {
-      _defaultInstanceId = best.id;
-      _defaultInstanceLastAttempt = 0;
-      return _defaultInstanceId;
-    }
-  } catch { /* transient error — will retry after cooldown */ }
+    const running = (data?.data ?? []).filter(i => i.status === 'running');
+    if (running.length > 0) { _defaultInstanceId = running[0].id; return _defaultInstanceId; }
+  } catch { /* non-fatal — caller will surface missing instance_id error */ }
   return '';
 }
 
@@ -158,55 +149,24 @@ async function pollDeviceFlow(flow: DeviceFlowState): Promise<'pending' | 'expir
       JWT = apiKey;
       setEmbedJwt(apiKey); // keep embeddings.ts in sync
       _deviceFlow = null;
-      // Auto-provision: find or create the user's brain instance.
-      _defaultInstanceLastAttempt = 0;
+      // Auto-provision instance
+      _defaultInstanceFetched = false;
       await resolveDefaultInstanceId();
       if (!_defaultInstanceId) {
+        // Try auto-provision
         try {
           const autoRes = await fetch(`${API_URL}/api/v1/instances/auto`, {
             method: 'POST',
             headers: { Authorization: `Bearer ${JWT}`, 'Content-Type': 'application/json' },
-            signal: AbortSignal.timeout(12000),
+            signal: AbortSignal.timeout(10000),
           });
           if (autoRes.ok) {
-            const body = await autoRes.json() as {
-              instance?: { id: string; status?: string };
-              instance_id?: string;
-              status?: string;
-            };
+            const body = await autoRes.json() as { instance?: { id: string }; instance_id?: string };
             const id = body.instance?.id ?? body.instance_id;
             if (id) _defaultInstanceId = id;
           }
         } catch { /* non-fatal */ }
       }
-      // Give a provisioning instance a head-start so getConnection's wait is shorter.
-      // The instance is almost always ready by the time the user's tool re-enters.
-      if (_defaultInstanceId) {
-        try {
-          const checkRes = await fetch(`${API_URL}/api/v1/instances/${_defaultInstanceId}`, {
-            headers: { Authorization: `Bearer ${JWT}`, Accept: 'application/json' },
-            signal: AbortSignal.timeout(4000),
-          });
-          if (checkRes.ok) {
-            const checkInst = await checkRes.json() as { status?: string };
-            if (checkInst.status === 'provisioning') {
-              // Wait up to 20s here so the re-entered tool call lands on a running instance.
-              const pDeadline = Date.now() + 20_000;
-              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' },
-                  signal: AbortSignal.timeout(4000),
-                }).catch(() => null);
-                if (rr?.ok) {
-                  const ri = await rr.json() as { status?: string };
-                  (checkInst as { status?: string }).status = ri.status;
-                } else { break; }
-              }
-            }
-          }
-        } catch { /* non-fatal — getConnection will handle the wait if still provisioning */ }
-      }
       return 'done';
     }
     if (data.error === 'slow_down') flow.pollInterval = Math.min(flow.pollInterval + 2000, 15000);
@@ -256,48 +216,18 @@ interface SemanticSearchResponse {
 const pool = new Map<string, Redis>();
 
 async function getConnection(instance_id: string): Promise<Redis> {
-  if (!instance_id) {
-    throw new McpError(
-      ErrorCode.InvalidRequest,
-      'No instance_id provided and no running instance could be resolved automatically.\n\n' +
-      '• Set CACHLY_BRAIN_INSTANCE_ID in your MCP config, or\n' +
-      '• 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 25 s 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.
-  let inst = await apiFetch<Instance>(`/api/v1/instances/${instance_id}`);
-  if (inst.status === 'provisioning') {
-    const deadline = Date.now() + 25_000;
-    while (inst.status === 'provisioning' && Date.now() < deadline) {
-      await new Promise(r => setTimeout(r, 3000));
-      inst = await apiFetch<Instance>(`/api/v1/instances/${instance_id}`);
-    }
-  }
-
+  const inst = await apiFetch<Instance>(`/api/v1/instances/${instance_id}`);
   if (inst.status !== 'running') {
-    // 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}` } : {}) },
-      body: JSON.stringify({ event: 'instance_not_reachable', instance_id, status: inst.status, version: CURRENT_VERSION }),
-      signal: AbortSignal.timeout(3000),
-    }).catch(() => {});
-    const hint = inst.status === 'provisioning'
-      ? `⏳ Brain instance "${inst.name}" is still starting up.\n\nThis usually finishes within 30 seconds. Please try again in a moment.`
-      : `Brain instance "${inst.name}" is not reachable (status: ${inst.status}).\n\n` +
-        `• View your instance at: https://cachly.dev/instances\n` +
-        `• Run \`get_api_status\` for a full diagnostic.`;
-    throw new McpError(ErrorCode.InvalidRequest, hint);
+    throw new McpError(
+      ErrorCode.InvalidRequest,
+      `Instance "${inst.name}" is not running (status: ${inst.status}). ` +
+        `It may still be provisioning or awaiting payment.`
+    );
   }
   if (!inst.host || !inst.port) {
-    throw new McpError(ErrorCode.InternalError,
-      `Instance "${inst.name}" is running but has no host/port — contact support@cachly.dev.`);
+    throw new McpError(ErrorCode.InternalError, `Instance "${inst.name}" has no host/port yet.`);
   }
 
   // Fetch connection details (includes password) from the dedicated endpoint.
@@ -310,7 +240,7 @@ async function getConnection(instance_id: string): Promise<Redis> {
     password = conn.password ?? undefined;
     tlsEnabled = conn.tls_enabled !== false;
   } catch {
-    // Fallback: use TLS flag from instance metadata
+    // Fallback: no password, use TLS default from instance
   }
 
   const client = new Redis({
@@ -318,33 +248,26 @@ async function getConnection(instance_id: string): Promise<Redis> {
     port: inst.port,
     password: password || undefined,
     ...(tlsEnabled ? { tls: {} } : {}),
-    lazyConnect: true,
+    lazyConnect: true,          // don't auto-connect — we connect explicitly below
     enableReadyCheck: true,
-    connectTimeout: 8000,
+    connectTimeout: 5000,
     retryStrategy: () => null,  // fail fast, no reconnect loops in MCP context
   });
 
-  const evict = () => pool.delete(instance_id);
-  client.on('error', evict);
-  client.on('end', evict);
+  client.on('error', () => {
+    pool.delete(instance_id); // remove stale connection on error
+  });
 
+  // Connect explicitly so we can catch connection errors as a proper rejected
+  // Promise instead of an unhandled 'error' event that would kill the process.
   try {
     await client.connect();
   } catch (err: unknown) {
     client.disconnect();
     const msg = err instanceof Error ? err.message : String(err);
-    void fetch(`${API_URL}/api/v1/telemetry/mcp`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json', ...(JWT ? { Authorization: `Bearer ${JWT}` } : {}) },
-      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(() => {});
     throw new McpError(
       ErrorCode.InternalError,
-      `Could not reach Brain instance "${inst.name}" (${inst.host}:${inst.port}).\n\n` +
-      `• Check your network connection\n` +
-      `• Run \`get_api_status\` to verify instance status\n` +
-      `• Technical detail: ${msg}`
+      `Could not connect to instance "${inst.name}" (${inst.host}:${inst.port}): ${msg}`
     );
   }
 
@@ -614,44 +537,6 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
         authInfo = '❌ JWT decode failed – check CACHLY_JWT format';
       }
 
-      // List instances + connectivity
-      let instanceInfo = '';
-      try {
-        const listRes = await apiFetch<{ data: Instance[] }>('/api/v1/instances');
-        const instances = listRes.data ?? [];
-        if (instances.length === 0) {
-          instanceInfo = '\n\n🧠 **Brain Instances:** none — create one at https://cachly.dev/instances';
-        } else {
-          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' : '';
-            lines.push(`  ${badge} **${inst.name}** (\`${inst.id}\`) · ${inst.status}${defaultMark}`);
-            if (inst.status === 'running' && inst.host) {
-              // Try a quick ping on the cached connection
-              const pooled = pool.get(inst.id);
-              if (pooled) {
-                try {
-                  await pooled.ping();
-                  lines.push(`     💓 Redis: connected`);
-                } catch {
-                  lines.push(`     ⚠️  Redis: pooled but ping failed — will reconnect on next use`);
-                }
-              } else {
-                lines.push(`     💤 Redis: not connected yet (connects on first tool use)`);
-              }
-            } else if (inst.status === 'provisioning') {
-              lines.push(`     ⏳ Still provisioning — check back in ~30 s`);
-            } else if (inst.status !== 'running') {
-              lines.push(`     ❌ Not reachable (status: ${inst.status})`);
-            }
-          }
-          instanceInfo = lines.join('\n');
-        }
-      } catch (e) {
-        instanceInfo = `\n\n🧠 **Brain Instances:** could not fetch — ${(e as Error).message}`;
-      }
-
       return [
         `📡 **cachly API Status**`,
         ``,
@@ -660,7 +545,6 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
         ``,
         `🔑 **Auth:**`,
         authInfo,
-        instanceInfo,
       ].join('\n');
     }
 
@@ -698,9 +582,8 @@ async function autoStartSession(instanceId: string): Promise<void> {
     _autoSessionInstanceId = instanceId;
     try {
       await handleTool('session_start', { instance_id: instanceId, focus: 'auto (MCP session)' });
-    } catch { /* non-fatal — session tracking is a best-effort feature */ } finally {
-      _autoSessionStarting = null;
-    }
+    } catch { /* non-fatal — session tracking is a best-effort feature */ }
+    _autoSessionStarting = null;
   })();
   await _autoSessionStarting;
 
@@ -749,9 +632,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   // Skip session management tools to avoid recursion.
   const sessionTools = new Set(['session_start', 'session_end', 'auto_learn_session']);
   if (!sessionTools.has(name) && !_autoSessionStarted && !_autoSessionStarting) {
-    const instanceId = ((args as Record<string, unknown>)?.instance_id as string | undefined)
-      || _defaultInstanceId
-      || process.env.CACHLY_BRAIN_INSTANCE_ID;
+    const instanceId = (args as Record<string, unknown>)?.instance_id as string | undefined;
     if (instanceId) {
       await autoStartSession(instanceId).catch(() => undefined);
     }

package/src/tools.ts

@@ -437,11 +437,10 @@ const TOOLS = [
   {
     name: 'get_api_status',
     description:
-      'Full diagnostic for your cachly Brain — call this FIRST whenever anything is not working. ' +
-      'Returns: API reachability, JWT validity + expiry, your user ID, ' +
-      'all Brain instances with live status (🟢 running / 🟡 provisioning / 🔴 stopped), ' +
-      'Redis ping on the active connection, and actionable fix steps for every issue found. ' +
-      'Workflow: run get_api_status → read the issue it flags → fix it → retry your tool.',
+      'Check the cachly API health and your authentication status. ' +
+      'Returns whether the JWT is valid, your user ID (sub claim), ' +
+      'token expiry, and the auth provider (keycloak). ' +
+      'Use this to debug connection issues or verify your CACHLY_JWT is correct.',
     inputSchema: { type: 'object', properties: {}, required: [] },
   },
   // ── Thinking/Context Cache (for AI assistants) ────────────────────────────