@cachly-dev/mcp-server 0.5.36 → 0.5.38

package/src/index.ts

@@ -1,12 +1,9 @@
 #!/usr/bin/env node
 import { randomUUID } from 'node:crypto';
-import { createHash } from 'node:crypto';
 import { readdir, readFile, stat } from 'node:fs/promises';
-import { readFileSync } from 'node:fs';
-import { execSync } from 'node:child_process';
 import { join, relative, extname } from 'node:path';
 /**
- * cachly MCP Server v0.4.0
+ * cachly MCP Server v0.5.38
  *
  * Exposes cachly.dev as MCP tools so any AI assistant
  * (GitHub Copilot, Claude, Cursor, Windsurf, Continue.dev …) can:
@@ -34,6 +31,7 @@ import { join, relative, extname } from 'node:path';
  *
  * Configuration (env vars):
  *   CACHLY_API_URL      – default https://api.cachly.dev
+ *   CACHLY_AUTH_URL     – default https://auth.cachly.dev (Keycloak base URL for health checks)
  *   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)
@@ -41,7 +39,6 @@ import { join, relative, extname } from 'node:path';
 
 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,
@@ -53,9 +50,9 @@ import { Redis } from 'ioredis';
 // ── Config ────────────────────────────────────────────────────────────────────
 
 const API_URL = process.env.CACHLY_API_URL ?? 'https://api.cachly.dev';
+const AUTH_URL = process.env.CACHLY_AUTH_URL ?? 'https://auth.cachly.dev';
 const JWT = process.env.CACHLY_JWT ?? '';
 const EMBED_MODEL = process.env.CACHLY_EMBED_MODEL ?? '';
-const CURRENT_VERSION = '0.5.26';
 /**
  * ┌──────────────────────────────────────────────────────────────────────┐
  * │  EMBEDDING PROVIDER — pluggable, client-side first                  │
@@ -75,44 +72,6 @@ const CURRENT_VERSION = '0.5.26';
  */
 const EMBED_PROVIDER = (process.env.CACHLY_EMBED_PROVIDER ?? detectEmbedProvider()).toLowerCase();
 
-// ── Confidence Decay Config (all values configurable via env) ─────────────────
-const CONFIDENCE_WARN_DAYS  = Number(process.env.CACHLY_CONFIDENCE_WARN_DAYS  ?? 5);   // → 0.7
-const CONFIDENCE_STALE_DAYS = Number(process.env.CACHLY_CONFIDENCE_STALE_DAYS ?? 10);  // → 0.5
-const CONFIDENCE_WARN_VALUE  = 0.7;
-const CONFIDENCE_STALE_VALUE = 0.5;
-
-/** Calculate current confidence for a lesson based on how long since last verified. */
-function calculateConfidence(lesson: { verified_at?: string; ts: string; recall_count?: number }): number {
-  const ref = lesson.verified_at ?? lesson.ts;
-  const ageMs = Date.now() - new Date(ref).getTime();
-  const ageDays = ageMs / 86400000;
-  if (ageDays >= CONFIDENCE_STALE_DAYS) return CONFIDENCE_STALE_VALUE;
-  if (ageDays >= CONFIDENCE_WARN_DAYS)  return CONFIDENCE_WARN_VALUE;
-  // Linear interpolation between fresh (1.0) and warn threshold
-  return 1.0 - (ageDays / CONFIDENCE_WARN_DAYS) * (1.0 - CONFIDENCE_WARN_VALUE);
-}
-
-/** Render a confidence badge string. */
-function confidenceBadge(confidence: number, ageDays: number): string {
-  if (confidence >= 0.9) return '✅';
-  if (confidence >= 0.7) return `⚠️ (${Math.round(ageDays)}d old, confidence ${(confidence * 100).toFixed(0)}% — verify before applying)`;
-  return `🔴 STALE (${Math.round(ageDays)}d old, confidence ${(confidence * 100).toFixed(0)}% — likely outdated!)`;
-}
-
-/** Category-specific required fields for structured lessons. */
-const STRUCTURED_TEMPLATES: Record<string, { required: string[]; hint: string }> = {
-  'deploy':  { required: ['commands'],                hint: 'deploy:* needs commands[]' },
-  'bash':    { required: ['commands'],                hint: 'bash:* needs commands[]' },
-  'infra':   { required: ['commands'],                hint: 'infra:* needs commands[] + verified on real system' },
-  'pricing': { required: [],                          hint: 'pricing:* — add context with source (e.g. "Stripe Dashboard Apr 2026")' },
-  'stripe':  { required: [],                          hint: 'stripe:* — add context with Stripe API version' },
-};
-
-/** Fast content hash for index invalidation (not cryptographic, just change detection) */
-function simpleHash(text: string): string {
-  return createHash('md5').update(text).digest('hex').slice(0, 12);
-}
-
 function detectEmbedProvider(): string {
   // Client-side keys first (direct, fast, no server roundtrip)
   if (process.env.OPENAI_API_KEY) return 'openai';
@@ -301,15 +260,13 @@ function embedProviderHint(): string {
 //   • Recency boost — newer entries rank higher (exponential decay, 7-day half-life)
 //   • Multi-query splitting — numbered lists, semicolons, conjunctions
 //   • Fuzzy matching with Levenshtein distance ≤ 2
-//   • Multilingual stopwords (EN, DE, FR, ES, IT, PT, ZH, JA, KO)
-//   • CJK character bigram extraction — handles Chinese, Japanese, Korean
+//   • Multilingual stopwords (EN, DE, FR, ES, IT, PT)
 //   • Pipeline Redis reads for performance
 //
 
 /**
  * Stopwords — filtered out during tokenization.
- * Covers: English, German, French, Spanish, Italian, Portuguese,
- *         Chinese (Simplified + Traditional), Japanese, Korean.
+ * Covers: English, German, French, Spanish, Italian, Portuguese.
  * Keeps the index small and scores meaningful.
  */
 const STOPWORDS = new Set([
@@ -383,63 +340,15 @@ const STOPWORDS = new Set([
   'eu', 'tu', 'ele', 'ela', 'nós', 'eles', 'elas', 'você', 'vocês',
   'não', 'já', 'sim', 'bem', 'muito', 'também', 'ainda', 'sempre',
   'todo', 'toda', 'todos', 'cada', 'outro', 'outra', 'quando', 'porque',
-  // ── Chinese (Simplified + Traditional) — high-frequency function characters ──
-  '的', '了', '是', '在', '不', '和', '我', '他', '这', '中', '大', '为',
-  '上', '个', '国', '以', '要', '就', '出', '说', '们', '有', '来', '到',
-  '时', '地', '年', '得', '着', '那', '过', '后', '还', '与', '也', '可',
-  '于', '从', '但', '而', '被', '把', '让', '使', '对', '很', '都', '一',
-  '会', '没', '人', '它', '这个', '那个', '什么', '如果', '因为', '所以',
-  '已经', '可以', '这些', '那些', '我们', '他们', '她们', '它们',
-  // ── Japanese — common hiragana particles and auxiliary verbs ──
-  'の', 'は', 'が', 'を', 'に', 'で', 'と', 'も', 'や', 'か', 'な', 'ね',
-  'よ', 'わ', 'て', 'い', 'う', 'え', 'お', 'き', 'く', 'け', 'こ', 'さ',
-  'し', 'す', 'せ', 'そ', 'た', 'ち', 'つ', 'ぬ', 'ん', 'から', 'まで',
-  'より', 'へ', 'です', 'ます', 'ない', 'ある', 'いる', 'する', 'こと',
-  'もの', 'ので', 'では', 'には', 'との', 'への', 'から', 'まで',
-  // ── Korean — common particles and auxiliary forms ──
-  '이', '가', '은', '는', '을', '를', '의', '에', '와', '과', '도',
-  '로', '에서', '한', '하', '있', '없', '것', '수', '않', '들',
-  '이다', '하다', '이고', '이며', '라고', '에게', '에서', '으로',
 ]);
 
-// CJK Unicode ranges used for bigram extraction
-const CJK_RE = /[\u3040-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff\uac00-\ud7af]/;
-const SEGMENT_RE = /([\u3040-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff\uac00-\ud7af]+|[^\u3040-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff\uac00-\ud7af]+)/g;
-
-/**
- * Tokenize text into meaningful keywords.
- * Handles accented Latin characters and CJK (Chinese, Japanese, Korean).
- * CJK text is split into character bigrams (the standard for indexing logographic languages).
- */
+/** Tokenize text into meaningful keywords. Handles unicode (accented chars). */
 function tokenize(text: string): string[] {
-  const tokens: string[] = [];
-  const lower = text.toLowerCase();
-
-  for (const [seg] of lower.matchAll(SEGMENT_RE)) {
-    if (CJK_RE.test(seg)) {
-      // CJK segment — extract overlapping character bigrams
-      for (let i = 0; i < seg.length - 1; i++) {
-        const bigram = seg[i] + seg[i + 1];
-        if (!STOPWORDS.has(seg[i]) && !STOPWORDS.has(bigram)) {
-          tokens.push(bigram);
-        }
-      }
-      // Trailing single character (for 1-char CJK terms)
-      if (seg.length >= 1) {
-        const last = seg[seg.length - 1];
-        if (!STOPWORDS.has(last)) tokens.push(last);
-      }
-    } else {
-      // Latin / other — existing logic
-      const words = seg
-        .replace(/[^a-záàâãäåæçéèêëíìîïñóòôõöúùûüýÿßœ0-9:_\-./]/g, ' ')
-        .split(/\s+/)
-        .filter(w => w.length > 1 && !STOPWORDS.has(w));
-      tokens.push(...words);
-    }
-  }
-
-  return tokens;
+  return text
+    .toLowerCase()
+    .replace(/[^a-záàâãäåæçéèêëíìîïñóòôõöúùûüýÿßœ0-9:_\-./]/g, ' ')
+    .split(/\s+/)
+    .filter(w => w.length > 1 && !STOPWORDS.has(w));
 }
 
 /**
@@ -868,6 +777,20 @@ async function apiFetch<T>(path: string, options: RequestInit = {}): Promise<T>
     },
   });
   if (!res.ok) {
+    if (res.status === 401 || res.status === 403) {
+      throw new McpError(
+        ErrorCode.InvalidRequest,
+        `cachly API: authentication failed (${res.status}) — your JWT may be expired or invalid.\n` +
+        `Get a new API token at https://cachly.dev/settings or run \`get_api_status\` to check token expiry.`
+      );
+    }
+    if (res.status === 503 || res.status === 502) {
+      throw new McpError(
+        ErrorCode.InternalError,
+        `cachly API: auth service unavailable (${res.status}) — the authentication service may be temporarily down.\n` +
+        `Please try again in a moment or contact support@cachly.dev`
+      );
+    }
     const body = await res.json().catch(() => ({ error: res.statusText }));
     throw new McpError(
       ErrorCode.InternalError,
@@ -894,8 +817,8 @@ const TOOLS = [
     description:
       'Create a new managed Valkey/Redis cache instance on cachly.dev. ' +
       'Free tier provisions in ~30 seconds. Paid tiers return a Stripe checkout URL. ' +
-      'Available tiers: free (25 MB), dev (200 MB, €19/mo), pro (900 MB, €49/mo), ' +
-      'speed (900 MB Dragonfly + Semantic Cache, €79/mo), business (7 GB, €199/mo).',
+      'Available tiers: free (30 MB), dev (256 MB, €8/mo), pro (1 GB, €25/mo), ' +
+      'speed (1 GB Dragonfly + Semantic Cache, €39/mo), business (8 GB, €99/mo).',
     inputSchema: {
       type: 'object',
       properties: {
@@ -1270,10 +1193,10 @@ const TOOLS = [
   {
     name: 'get_api_status',
     description:
-      '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.',
+      'Check the cachly API health, auth service reachability, and your authentication status. ' +
+      'Returns API health, whether the Keycloak auth service is reachable, JWT validity, ' +
+      'user ID (sub claim), token expiry, and the auth provider. ' +
+      'Use this to debug connection issues, verify your CACHLY_JWT, or diagnose "Auth Service Unavailable" errors.',
     inputSchema: { type: 'object', properties: {}, required: [] },
   },
   // ── Thinking/Context Cache (for AI assistants) ────────────────────────────
@@ -1364,9 +1287,7 @@ const TOOLS = [
       'Fields: topic (short slug like "deploy:web"), outcome ("success"|"failure"), ' +
       'what_worked (what solved it), what_failed (what did NOT work), context (extra details). ' +
       'Supports structured metadata: severity, file_paths (files involved), commands (working commands), tags. ' +
-      'Deduplication: if a lesson for this topic already exists, it is updated with full audit trail. ' +
-      'Contradiction detection: warns if new outcome conflicts with existing lesson outcome. ' +
-      'Confidence: lesson starts at 1.0, decays after 5d (→0.7) and 10d (→0.5) without recall. ' +
+      'Deduplication: if a lesson for this topic already exists, it is updated instead of duplicated. ' +
       'Example: learn_from_attempts(topic="deploy:api", outcome="success", what_worked="nohup docker compose up -d --build", what_failed="docker compose up hangs on SSH timeout", severity="critical", commands=["nohup docker compose up -d --build"])',
     inputSchema: {
       type: 'object',
@@ -1397,15 +1318,6 @@ const TOOLS = [
           items: { type: 'string' },
           description: 'Topic tags for filtering (e.g. ["bash", "deploy", "env"])',
         },
-        depends_on: {
-          type: 'array',
-          items: { type: 'string' },
-          description: 'Prerequisites this lesson depends on (e.g. ["node:>=20", "docker:running", "wireguard:active"]). When a dependency is marked stale, all dependent lessons get needs_review.',
-        },
-        author: {
-          type: 'string',
-          description: 'Name or handle of the person storing this lesson (e.g. "alice", "bob"). Used for Team Telepathy — teammates see each other\'s lessons in session_start.',
-        },
       },
       required: ['instance_id', 'topic', 'outcome', 'what_worked'],
     },
@@ -1415,9 +1327,7 @@ const TOOLS = [
     description:
       'Recall the best known solution for a topic from past lessons. ' +
       'Call this BEFORE attempting any task that might have been done before. ' +
-      'Returns the most recent successful lesson for the topic, with confidence indicator. ' +
-      '⚠️ badge = lesson is >5d old (verify before applying). 🔴 = >10d old (likely stale!). ' +
-      'Recalling a lesson resets its confidence clock to 1.0 (marks as recently verified). ' +
+      'Returns the most recent successful lesson for the topic, or a summary of attempts. ' +
       'Example: recall_best_solution(topic="deploy:web") → returns the working deploy command.',
     inputSchema: {
       type: 'object',
@@ -1428,6 +1338,21 @@ const TOOLS = [
       required: ['instance_id', 'topic'],
     },
   },
+  {
+    name: 'forget_lesson',
+    description:
+      'Delete a stored lesson from the Brain. Use this when a lesson is wrong, outdated, or was learned incorrectly. ' +
+      'Removes both the best-solution entry and the attempt history for the topic. ' +
+      'Example: forget_lesson(topic="deploy:web") → deletes the wrong deployment lesson so a correct one can be stored.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        instance_id: { type: 'string', description: 'UUID of the cache instance' },
+        topic:       { type: 'string', description: 'Exact topic slug to delete, e.g. "deploy:web"' },
+      },
+      required: ['instance_id', 'topic'],
+    },
+  },
   {
     name: 'smart_recall',
     description:
@@ -1450,8 +1375,7 @@ const TOOLS = [
     description:
       'Single-call session briefing. Call this at the START of every session INSTEAD of multiple separate smart_recall/recall_best_solution calls. ' +
       'Returns: last session summary, recent lessons sorted by recency, relevant lessons for your focus area, ' +
-      'open failures (topics with only failure outcomes), brain health stats, team telepathy (what teammates learned this week), ' +
-      'predictive pre-warnings (if your focus area has known failure patterns), and memory crystals (compressed wisdom from old sessions). ' +
+      'open failures (topics with only failure outcomes), and brain health stats (lesson count, context count). ' +
       'Also saves a session start marker so session_end can compute duration.',
     inputSchema: {
       type: 'object',
@@ -1461,10 +1385,6 @@ const TOOLS = [
           type: 'string',
           description: 'Keywords for what you plan to work on today (e.g. "deploy infra api"). Used to surface relevant lessons at the top.',
         },
-        author: {
-          type: 'string',
-          description: 'Your name or handle (e.g. "alice"). Enables Team Telepathy — filters YOUR lessons vs TEAM lessons from past 7 days.',
-        },
       },
       required: ['instance_id'],
     },
@@ -1475,8 +1395,7 @@ const TOOLS = [
       'Save a session summary when you finish working. ' +
       'Records what was accomplished, files changed, and lesson count. ' +
       'The next session_start will show this summary as "Last session". ' +
-      'Call this when ending a work session, before going idle, or before summarizing. ' +
-      'Ambient Learning: if workspace_path is provided, reads git log since session start and auto-learns from commits.',
+      'Call this when ending a work session, before going idle, or before summarizing.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -1494,67 +1413,10 @@ const TOOLS = [
           type: 'number',
           description: 'Number of new lessons stored this session (optional)',
         },
-        workspace_path: {
-          type: 'string',
-          description: 'Absolute path to the project root (e.g. "/Users/you/myproject"). Enables Ambient Learning — reads git log since session start and auto-learns from commit messages.',
-        },
       },
       required: ['instance_id', 'summary'],
     },
   },
-  // ── Session Handoff — cross-window continuity ─────────────────────────────
-  {
-    name: 'session_handoff',
-    description:
-      'Save a detailed handoff for the NEXT chat window / session. ' +
-      'Stores: current progress, TODO list (done + remaining), changed files with descriptions, ' +
-      'instructions for the next assistant, and any incomplete work. ' +
-      'The next session_start automatically includes this handoff so the new window knows EXACTLY what happened and what remains. ' +
-      'Call this BEFORE closing a chat window, especially if work is incomplete. ' +
-      'This prevents the "continue" problem where new windows lose context, skip tasks, or produce broken code.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        instance_id: { type: 'string', description: 'UUID of the cache instance' },
-        completed_tasks: {
-          type: 'array',
-          items: { type: 'string' },
-          description: 'Tasks that were fully completed (e.g. "Implemented brainSearch() in JS SDK")',
-        },
-        remaining_tasks: {
-          type: 'array',
-          items: { type: 'string' },
-          description: 'Tasks NOT yet done — the next window MUST pick these up',
-        },
-        files_changed: {
-          type: 'array',
-          items: {
-            type: 'object',
-            properties: {
-              path: { type: 'string', description: 'File path relative to project root' },
-              status: { type: 'string', enum: ['complete', 'partial', 'broken'], description: 'State of this file' },
-              description: { type: 'string', description: 'What was changed and what still needs work' },
-            },
-            required: ['path', 'status'],
-          },
-          description: 'Changed files with their current state — marks partial/broken files so next window knows to fix them',
-        },
-        instructions: {
-          type: 'string',
-          description: 'Free-form instructions for the next assistant. Be specific: what to do next, what to avoid, what broke.',
-        },
-        context_summary: {
-          type: 'string',
-          description: 'Brief summary of what happened this session (architecture decisions, key findings, blockers)',
-        },
-        blocked_on: {
-          type: 'string',
-          description: 'If work is blocked, describe what is needed to unblock (e.g. "waiting for API deploy", "needs user input on design")',
-        },
-      },
-      required: ['instance_id', 'completed_tasks', 'remaining_tasks'],
-    },
-  },
   // ── AI Brain — Extended features ─────────────────────────────────────────
   {
     name: 'auto_learn_session',
@@ -1645,154 +1507,16 @@ const TOOLS = [
       required: ['instance_id'],
     },
   },
-  {
-    name: 'team_synthesize',
-    description:
-      'Team Brain Synthesis — merge multiple contributors\' lessons on the same topic into one canonical version. ' +
-      'When 2+ developers store lessons for the same topic with different details, this proposes the best merged version. ' +
-      'Shows: all contributions by author, what worked (consensus), what failed (union), canonical lesson to store. ' +
-      'Use this when onboarding new team members or before documenting a process.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        instance_id: { type: 'string', description: 'UUID of the shared team brain instance' },
-        topic:       { type: 'string', description: 'Topic slug to synthesize (e.g. "deploy:api")' },
-      },
-      required: ['instance_id', 'topic'],
-    },
-  },
-  {
-    name: 'memory_crystalize',
-    description:
-      'Compress the last 30-50 sessions and auto-learned lessons into a dense Memory Crystal. ' +
-      'A crystal is a compact, structured summary of everything the brain learned — grouped by category (deploy, fix, debug, …). ' +
-      'Crystals survive session cleanup and appear in session_start once enough sessions have accumulated. ' +
-      'Run this monthly or after a big milestone to preserve institutional knowledge. ' +
-      'Returns a digest of what was crystallized.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        instance_id: { type: 'string', description: 'UUID of the cache instance' },
-        label: {
-          type: 'string',
-          description: 'Optional label for this crystal (e.g. "Q1 2026", "v2 launch"). Auto-generated from date if omitted.',
-        },
-      },
-      required: ['instance_id'],
-    },
-  },
-  // ── Roadmap — Persistent project plan tracker ───────────────────────────
-  {
-    name: 'roadmap_add',
-    description:
-      'Add a new item to the persistent project roadmap stored in the Brain. ' +
-      'Items survive across sessions and editors — the roadmap is always up to date. ' +
-      'Use for features, bugs, refactors, or any planned work. ' +
-      'Call roadmap_list to see all open items, roadmap_next to get the next actionable item.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        instance_id: { type: 'string', description: 'UUID of the cache instance' },
-        title: { type: 'string', description: 'Short title of the task/feature (3–10 words)' },
-        description: { type: 'string', description: 'What needs to be done, acceptance criteria, context' },
-        priority: {
-          type: 'string',
-          enum: ['critical', 'high', 'medium', 'low'],
-          description: 'Priority level (default: medium)',
-        },
-        tags: {
-          type: 'array',
-          items: { type: 'string' },
-          description: 'Tags for filtering (e.g. ["api", "web", "sdk", "infra"])',
-        },
-        milestone: { type: 'string', description: 'Milestone/epic this belongs to (optional)' },
-      },
-      required: ['instance_id', 'title'],
-    },
-  },
-  {
-    name: 'roadmap_update',
-    description:
-      'Update the status, priority, or details of a roadmap item. ' +
-      'Use to move items through the lifecycle: planned → in-progress → done (or blocked/cancelled). ' +
-      'Also use to add notes/findings while working on an item.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        instance_id: { type: 'string', description: 'UUID of the cache instance' },
-        id: { type: 'string', description: 'Item ID returned by roadmap_add or roadmap_list' },
-        status: {
-          type: 'string',
-          enum: ['planned', 'in-progress', 'done', 'blocked', 'cancelled'],
-          description: 'New status for the item',
-        },
-        priority: {
-          type: 'string',
-          enum: ['critical', 'high', 'medium', 'low'],
-          description: 'Updated priority (optional)',
-        },
-        notes: { type: 'string', description: 'Progress notes, findings, or blockers (appended to existing notes)' },
-        title: { type: 'string', description: 'Updated title (optional)' },
-        description: { type: 'string', description: 'Updated description (optional)' },
-      },
-      required: ['instance_id', 'id'],
-    },
-  },
-  {
-    name: 'roadmap_list',
-    description:
-      'List all roadmap items, optionally filtered by status, priority, tag, or milestone. ' +
-      'Returns items sorted by priority then creation date. ' +
-      'Called automatically by session_start to show open work.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        instance_id: { type: 'string', description: 'UUID of the cache instance' },
-        status: {
-          type: 'string',
-          enum: ['planned', 'in-progress', 'done', 'blocked', 'cancelled', 'open'],
-          description: 'Filter by status. Use \'open\' to see planned+in-progress+blocked (default: open)',
-        },
-        tag: { type: 'string', description: 'Filter by tag (optional)' },
-        milestone: { type: 'string', description: 'Filter by milestone (optional)' },
-        priority: {
-          type: 'string',
-          enum: ['critical', 'high', 'medium', 'low'],
-          description: 'Filter by minimum priority (optional)',
-        },
-      },
-      required: ['instance_id'],
-    },
-  },
-  {
-    name: 'roadmap_next',
-    description:
-      'Get the single most important next actionable roadmap item. ' +
-      'Returns the highest-priority in-progress item first, then planned items, sorted by priority. ' +
-      'Call at session start to immediately know what to work on next.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        instance_id: { type: 'string', description: 'UUID of the cache instance' },
-        tag: { type: 'string', description: 'Filter by tag (optional)' },
-      },
-      required: ['instance_id'],
-    },
-  },
   {
     name: 'brain_doctor',
     description:
       'Check the health of your AI Brain and get actionable recommendations. ' +
-      'Reports: lesson count, context entries, last session age, open failures, quality score, effective IQ boost, stale index. ' +
+      'Reports: lesson count, context entries, last session age, open failures, quality score. ' +
       'Returns a prioritized list of issues with fix instructions.',
     inputSchema: {
       type: 'object',
       properties: {
         instance_id: { type: 'string', description: 'UUID of the cache instance' },
-        workspace_path: {
-          type: 'string',
-          description: 'Absolute path to workspace root — enables package.json analysis for openclaw cross-promo (optional)',
-        },
       },
       required: ['instance_id'],
     },
@@ -1864,100 +1588,6 @@ const TOOLS = [
       required: ['instance_id', 'framework'],
     },
   },
-  // ── Brain Archaeology + Causal Chain ────────────────────────────────────
-  {
-    name: 'recall_at',
-    description:
-      'Brain Archaeology — see what a lesson looked like at a specific point in time. ' +
-      '"What did we know about deployments 3 months ago?" ' +
-      'Returns the history of a topic filtered to entries before the given date. ' +
-      'Shows how the lesson evolved: failure → partial → success. ' +
-      'Also useful to understand WHY old code decisions were made.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        instance_id: { type: 'string', description: 'UUID of the cache instance' },
-        topic:       { type: 'string', description: 'Topic slug to look up, e.g. "deploy:api"' },
-        date:        { type: 'string', description: 'ISO date string (e.g. "2026-01-15") — returns entries stored BEFORE this date' },
-      },
-      required: ['instance_id', 'topic', 'date'],
-    },
-  },
-  {
-    name: 'trace_dependency',
-    description:
-      'Causal Chain — find all lessons that depend on a given prerequisite. ' +
-      '"What lessons are affected if node version changes?" ' +
-      'When a dependency changes (new version, different provider, new OS), call this to see which lessons need review. ' +
-      'Lessons store dependencies via the depends_on field in learn_from_attempts.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        instance_id: { type: 'string', description: 'UUID of the cache instance' },
-        dependency:  { type: 'string', description: 'Dependency to trace (e.g. "node:>=20", "docker:running", "wireguard:active")' },
-        mark_review: { type: 'boolean', description: 'If true, marks all dependent lessons as needs_review (default: false)' },
-      },
-      required: ['instance_id', 'dependency'],
-    },
-  },
-  // ── Team / Org Management ────────────────────────────────────────────────
-  {
-    name: 'list_orgs',
-    description:
-      'List your Cachly organizations (team/org plans). ' +
-      'Returns each org with plan, seat count, and member info. ' +
-      'Org plans (Team €99, Business €299, Enterprise custom) are billed separately from cache tiers.',
-    inputSchema: {
-      type: 'object',
-      properties: {},
-      required: [],
-    },
-  },
-  {
-    name: 'create_org',
-    description:
-      'Create a new Cachly organization for team collaboration. ' +
-      'After creation, invite team members with invite_member and upgrade the plan via the billing portal. ' +
-      'Org plans: Team (€99/mo, 10 seats), Business (€299/mo, 50 seats), Enterprise (custom).',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        name: { type: 'string', description: 'Organization display name (e.g. "Acme Engineering")' },
-        slug: { type: 'string', description: 'URL-safe slug (e.g. "acme-eng"). Auto-generated from name if omitted.' },
-      },
-      required: ['name'],
-    },
-  },
-  {
-    name: 'invite_member',
-    description:
-      'Invite a team member to a Cachly organization by email. ' +
-      'They will receive an invite email and can join via the dashboard. ' +
-      'Roles: owner (full access), admin (manage members + instances), member (read + cache ops).',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        org_id: { type: 'string', description: 'UUID of the organization' },
-        email:  { type: 'string', description: 'Email address to invite' },
-        role:   { type: 'string', enum: ['admin', 'member'], description: 'Role for the invited member (default: member)' },
-      },
-      required: ['org_id', 'email'],
-    },
-  },
-  {
-    name: 'get_org_plan',
-    description:
-      'Get the current org plan, seat usage, and billing info for an organization. ' +
-      'Shows: plan name, price, seats used/max, next billing date. ' +
-      'To upgrade: use the billing portal URL returned by this tool.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        org_id: { type: 'string', description: 'UUID of the organization' },
-      },
-      required: ['org_id'],
-    },
-  },
   // ── Legacy / Setup ────────────────────────────────────────────────────────
   {
     name: 'setup_ai_memory',
@@ -2055,50 +1685,10 @@ function buildConnectionString(inst: Instance): string {
   return `${scheme}://${pw}${inst.host}:${inst.port}`;
 }
 
-// Fires once per process when no JWT is set (anonymous, opt-out via CACHLY_NO_TELEMETRY=1)
-let _telemetryPingSent = false;
-async function sendAnonymousTelemetry(toolName: string): Promise<void> {
-  if (_telemetryPingSent) return;
-  if (process.env.CACHLY_NO_TELEMETRY === '1') return;
-  _telemetryPingSent = true;
-  // Detect editor from common env vars injected by IDE extensions
-  const editor = process.env.CURSOR_TRACE_ID ? 'cursor'
-    : process.env.WINDSURF_SESSION_ID ? 'windsurf'
-    : process.env.GITHUB_COPILOT_WORKSPACE ? 'copilot'
-    : process.env.CLAUDE_CODE_ENTRYPOINT ? 'claude'
-    : 'unknown';
-  try {
-    await fetch(`${API_URL}/api/v1/telemetry/mcp`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ event: 'first_call_no_jwt', version: CURRENT_VERSION, editor, tool: toolName }),
-      signal: AbortSignal.timeout(3000),
-    });
-  } catch { /* fire-and-forget, never block the user */ }
-}
-
 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) {
-    void sendAnonymousTelemetry(name);
-    return [
-      '🧠 **cachly AI Brain — Setup required**',
-      '',
-      'You have no API credentials configured. Get started in 30 seconds:',
-      '',
-      '**Step 1:** Register for free (no credit card):',
-      '   👉 https://cachly.dev/setup-ai',
-      '',
-      '**Step 2:** Run the setup wizard in your terminal:',
-      '   ```',
-      '   npx @cachly-dev/mcp-server@latest setup',
-      '   ```',
-      '',
-      'The wizard auto-detects your editor (Claude Code, Cursor, Copilot, Windsurf)',
-      'and writes the config file with your credentials.',
-      '',
-      '✨ Free tier includes: 1 Brain instance, persistent memory, semantic search.',
-    ].join('\n');
+  // Default instance_id from env so tools work even if AI omits it
+  if (!args.instance_id && process.env.CACHLY_BRAIN_INSTANCE_ID) {
+    args = { ...args, instance_id: process.env.CACHLY_BRAIN_INSTANCE_ID };
   }
 
   // Delegate v0.2 bulk/lock/stream tools first
@@ -2119,7 +1709,7 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
       const { name: instName, tier } = args as { name: string; tier: string };
       const res = await apiFetch<CreateResponse>('/api/v1/instances', {
         method: 'POST',
-        body: JSON.stringify({ name: instName, tier, created_via: 'api' }),
+        body: JSON.stringify({ name: instName, tier }),
       });
       if (res.checkout_url) {
         return [
@@ -2179,69 +1769,6 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
       return `✅ Instance \`${instance_id}\` has been deleted and all data removed.`;
     }
 
-    // ── Org / Team management ────────────────────────────────────────────
-    case 'list_orgs': {
-      const res = await apiFetch<{ orgs: Array<{ id: string; name: string; slug: string; plan: string; max_members: number; member_count?: number }> }>('/api/v1/orgs');
-      const orgs = res.orgs ?? [];
-      if (orgs.length === 0) return `📭 No organizations yet.\n\nCreate one with \`create_org(name="My Team")\`.\nOrg plans: Team €99/mo (10 seats), Business €299/mo (50 seats), Enterprise custom.`;
-      return [
-        `🏢 **Your organizations (${orgs.length})**\n`,
-        ...orgs.map(o => `• **${o.name}** (\`${o.slug}\`) — plan: ${o.plan} · seats: ${o.member_count ?? '?'}/${o.max_members}\n  ID: \`${o.id}\``),
-        `\n_Manage: \`get_org_plan\`, \`invite_member\`, dashboard → /team_`,
-      ].join('\n');
-    }
-
-    case 'create_org': {
-      const { name: orgName, slug } = args as { name: string; slug?: string };
-      const body: Record<string, string> = { name: orgName };
-      if (slug) body.slug = slug;
-      const res = await apiFetch<{ id: string; name: string; slug: string; plan: string }>('/api/v1/orgs', {
-        method: 'POST',
-        body: JSON.stringify(body),
-      });
-      return [
-        `✅ **Organization created:** ${res.name}`,
-        `   ID: \`${res.id}\` · Slug: \`${res.slug}\` · Plan: ${res.plan}`,
-        ``,
-        `**Next steps:**`,
-        `1. Invite team members: \`invite_member(org_id="${res.id}", email="dev@example.com")\``,
-        `2. Upgrade plan: open billing portal via dashboard → /team`,
-        `   Team: €99/mo (10 seats) · Business: €299/mo (50 seats)`,
-      ].join('\n');
-    }
-
-    case 'invite_member': {
-      const { org_id, email, role = 'member' } = args as { org_id: string; email: string; role?: string };
-      await apiFetch(`/api/v1/orgs/${org_id}/members`, {
-        method: 'POST',
-        body: JSON.stringify({ email, role }),
-      });
-      return `✅ Invite sent to **${email}** as \`${role}\` in org \`${org_id}\`.\n\nThey will receive an email to join the organization.`;
-    }
-
-    case 'get_org_plan': {
-      const { org_id } = args as { org_id: string };
-      const org = await apiFetch<{
-        id: string; name: string; plan: string; max_members: number;
-        members: Array<{ role: string; invite_email: string; accepted_at?: string }>;
-        stripe_customer_id?: string;
-      }>(`/api/v1/orgs/${org_id}`);
-      const accepted = (org.members ?? []).filter(m => m.accepted_at).length;
-      const pending = (org.members ?? []).filter(m => !m.accepted_at).length;
-      const planPrice: Record<string, string> = { free: '€0', team: '€99/mo', business: '€299/mo', enterprise: 'custom' };
-      return [
-        `🏢 **${org.name}** — Plan: **${org.plan}** (${planPrice[org.plan] ?? org.plan})`,
-        `   Seats: ${accepted} active + ${pending} pending / ${org.max_members} max`,
-        ``,
-        `**Members:**`,
-        ...(org.members ?? []).map(m => `  • ${m.invite_email} (${m.role})${m.accepted_at ? '' : ' — pending'}`),
-        ``,
-        org.stripe_customer_id
-          ? `💳 Billing: managed via Stripe. Upgrade/cancel: dashboard → /billing`
-          : `💳 No payment method yet. Upgrade: dashboard → /billing → Team Plans`,
-      ].join('\n');
-    }
-
     // ── Live cache operations ────────────────────────────────────────────
     case 'cache_get': {
       const { instance_id, key } = args as { instance_id: string; key: string };
@@ -2668,7 +2195,6 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
       let skipped = 0;
       let errors = 0;
       let semanticIndexed = 0;
-      let unchanged = 0;
       const details: string[] = [];
       const expiresAt = new Date(Date.now() + ttl * 1000).toISOString();
       const redis = await getConnection(instance_id);
@@ -2676,31 +2202,15 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
       for (const filePath of files) {
         const relPath = relative(dir, filePath);
         let content: string;
-        let fileSize: number;
         try {
           const s = await stat(filePath);
           if (s.size > 200_000) { skipped++; continue; } // skip files >200 KB
-          fileSize = s.size;
           content = await readFile(filePath, 'utf-8');
         } catch {
           errors++;
           continue;
         }
 
-        // ── Smart invalidation: hash-based change detection ──
-        // Compute a simple hash of file content to skip unchanged files
-        const hashKey = `cachly:idx:hash:${relPath}`;
-        const contentHash = `${fileSize}:${content.length}:${simpleHash(content)}`;
-        const existingHash = await redis.get(hashKey);
-        if (existingHash === contentHash) {
-          // File unchanged — refresh TTL but skip re-indexing
-          const idxKey = `cachly:idx:${relPath}`;
-          if (ttl > 0) await redis.expire(idxKey, ttl);
-          if (ttl > 0) await redis.expire(hashKey, ttl);
-          unchanged++;
-          continue;
-        }
-
         const excerpt = content.slice(0, summary_chars).replace(/\s+/g, ' ').trim();
 
         // ── Layer 1: Keyword index in Valkey (always works, no embedding needed) ──
@@ -2711,12 +2221,6 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
         } else {
           await redis.set(idxKey, idxValue);
         }
-        // Store content hash for smart invalidation on next run
-        if (ttl > 0) {
-          await redis.set(hashKey, contentHash, 'EX', ttl);
-        } else {
-          await redis.set(hashKey, contentHash);
-        }
         indexed++;
         details.push(`  ✅ ${relPath}`);
 
@@ -2745,8 +2249,7 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
         `📂 **index_project Complete** — ${mode}`,
         ``,
         `  📁 Dir:       ${dir}`,
-        `  ✅ Indexed:   **${indexed}** files (new/changed)`,
-        `  ♻️  Unchanged: ${unchanged} files (hash match — skipped)`,
+        `  ✅ Indexed:   **${indexed}** files (keyword-searchable via smart_recall)`,
         ...(canEmbed ? [`  🎯 Semantic:  **${semanticIndexed}** files (vector-searchable)`] : []),
         `  ⏭️  Skipped:   ${skipped} (too large or filtered)`,
         `  ❌ Errors:    ${errors}`,
@@ -2969,8 +2472,6 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
         file_paths = [],
         commands = [],
         tags = [],
-        depends_on = [],
-        author = '',
       } = args as {
         instance_id: string;
         topic: string;
@@ -2982,107 +2483,26 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
         file_paths?: string[];
         commands?: string[];
         tags?: string[];
-        depends_on?: string[];
-        author?: string;
       };
 
       const redis = await getConnection(instance_id);
       const ts = new Date().toISOString();
 
-      // ── Structured template hints ──────────────────────────────────────────
-      const category = topic.split(':')[0];
-      const template = STRUCTURED_TEMPLATES[category];
-      const templateWarnings: string[] = [];
-      if (template) {
-        for (const req of template.required) {
-          if (req === 'commands' && commands.length === 0) {
-            templateWarnings.push(`📋 ${template.hint}`);
-          }
-        }
-      }
-
-      // ── Deduplication + audit trail ────────────────────────────────────────
+      // ── Deduplication: check for existing lesson with same topic ─────────────
       let isUpdate = false;
       let recallCount = 0;
-      let auditTrail: Array<{ ts: string; action: string; prev_outcome?: string }> = [];
-      const existingRaw = await redis.get(`cachly:lesson:best:${topic}`);
-      if (existingRaw) {
-        try {
-          const prev = JSON.parse(existingRaw) as {
-            recall_count?: number;
-            outcome?: string;
-            audit_trail?: Array<{ ts: string; action: string; prev_outcome?: string }>;
-          };
-          recallCount = prev.recall_count ?? 0;
-          auditTrail = prev.audit_trail ?? [];
-          auditTrail.push({ ts, action: 'updated', prev_outcome: prev.outcome });
-          if (auditTrail.length > 20) auditTrail = auditTrail.slice(-20);
-          isUpdate = true;
-
-          // ── Contradiction detection ─────────────────────────────────────────
-          const contradictionWarning: string[] = [];
-          if (prev.outcome === 'success' && outcome === 'failure') {
-            contradictionWarning.push(
-              `⚠️ **Contradiction detected!** Existing lesson has outcome: \`success\`, but you're storing \`failure\`.`,
-              `The existing "success" lesson will be preserved. Only the audit trail is updated.`,
-              `If you meant to mark this as failed permanently, store a new lesson with a distinct topic slug.`,
-            );
-          } else if (prev.outcome === 'failure' && outcome === 'success') {
-            contradictionWarning.push(
-              `✅ **Conflict resolved!** Previous lesson was \`failure\` — now overwriting with \`success\`.`,
-            );
-          }
-          if (contradictionWarning.length > 0) {
-            // Store contradiction audit but don't block
-            auditTrail[auditTrail.length - 1].action = 'contradiction-resolved';
-          }
-        } catch { /* ignore parse error */ }
-      } else {
-        auditTrail = [{ ts, action: 'created' }];
-      }
-
-      // ── "I Was Wrong" Protocol — failure attribution ───────────────────────
-      const iWasWrongWarning: string[] = [];
-      if (outcome === 'failure') {
-        // Search for related success lessons that might have prevented this failure
-        const scanKeys: string[] = [];
-        const scanStream = redis.scanStream({ match: 'cachly:lesson:best:*', count: 100 });
-        await new Promise<void>((res, rej) => {
-          scanStream.on('data', (b: string[]) => scanKeys.push(...b));
-          scanStream.on('end', res);
-          scanStream.on('error', rej);
-        });
-        const topicWords = topic.split(/[:\-_]/).filter(w => w.length > 2);
-        for (const k of scanKeys.slice(0, 50)) {
-          const raw = await redis.get(k);
-          if (!raw) continue;
+      if (outcome === 'success') {
+        const existing = await redis.get(`cachly:lesson:best:${topic}`);
+        if (existing) {
           try {
-            const l = JSON.parse(raw) as { outcome?: string; topic?: string; severity?: string };
-            if (l.outcome !== 'success') continue;
-            const lWords = (l.topic ?? '').split(/[:\-_]/).filter(w => w.length > 2);
-            const overlap = topicWords.filter(w => lWords.includes(w)).length;
-            if (overlap >= 1 && l.topic !== topic) {
-              iWasWrongWarning.push(
-                `⚠️ **"I Was Wrong"**: lesson \`${l.topic}\` (success, ${l.severity ?? 'major'}) might have prevented this failure.`,
-                `   → Use \`recall_best_solution(topic="${l.topic}")\` before next attempt.`,
-                `   → To mark it critical: \`learn_from_attempts(topic="${l.topic}", ..., severity="critical")\``,
-              );
-              break; // only show the most relevant match
-            }
-          } catch { /* skip */ }
+            const prev = JSON.parse(existing) as { recall_count?: number };
+            recallCount = (prev.recall_count ?? 0); // preserve existing recall count
+            isUpdate = true;
+          } catch { /* ignore parse error */ }
         }
       }
 
-      // ── Register dependency index for causal chain ─────────────────────────
-      for (const dep of depends_on) {
-        const depKey = `cachly:dep:${dep}`;
-        const existing = await redis.get(depKey);
-        const depTopics: string[] = existing ? JSON.parse(existing) : [];
-        if (!depTopics.includes(topic)) depTopics.push(topic);
-        await redis.set(depKey, JSON.stringify(depTopics));
-      }
-
-      const lessonObj = {
+      const lesson = JSON.stringify({
         topic,
         outcome,
         what_worked,
@@ -3092,36 +2512,20 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
         file_paths,
         commands,
         tags,
-        depends_on,
-        ...(author ? { author } : {}),
         recall_count: recallCount,
         ts,
-        verified_at: outcome === 'success' || outcome === 'partial' ? ts : undefined,
-        confidence: 1.0,
-        audit_trail: auditTrail,
-        version: 3,
-      };
-      const lesson = JSON.stringify(lessonObj);
+        version: 2,
+      });
 
-      // Always append to the history list (audit log)
+      // Always append to the history list
       const listKey = `cachly:lessons:${topic}`;
       await redis.rpush(listKey, lesson);
 
-      // Update best key for success/partial; for failure only update if no success exists
+      // Update best key only for success/partial (not for failures)
       if (outcome === 'success' || outcome === 'partial') {
         await redis.set(`cachly:lesson:best:${topic}`, lesson);
-      } else if (!existingRaw) {
-        await redis.set(`cachly:lesson:best:${topic}`, lesson);
       }
 
-      // Track in decision log for session replay
-      try {
-        const dlKey = 'cachly:session:decision-log';
-        const dlEntry = JSON.stringify({ ts, topic, outcome, what_worked: what_worked.slice(0, 120) });
-        await redis.rpush(dlKey, dlEntry);
-        await redis.ltrim(dlKey, -50, -1);
-      } catch { /* non-critical */ }
-
       const emoji = outcome === 'success' ? '✅' : outcome === 'partial' ? '⚠️' : '❌';
       const sevEmoji = severity === 'critical' ? '🔴' : severity === 'major' ? '🟡' : '🟢';
       const action = isUpdate ? 'updated' : 'stored';
@@ -3136,13 +2540,8 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
         tags.length > 0 ? `**Tags:** ${tags.map(t => `#${t}`).join(' ')}` : '',
         ``,
         isUpdate
-          ? `♻️ Updated (recall count: ${recallCount} · audit entries: ${auditTrail.length})`
+          ? `♻️ Updated existing lesson (preserved recall count: ${recallCount})`
           : `💡 Recall later with \`recall_best_solution(topic="${topic}")\``,
-        depends_on.length > 0
-          ? `🔗 Depends on: ${depends_on.map(d => `\`${d}\``).join(', ')} → trace with \`trace_dependency\``
-          : '',
-        ...templateWarnings,
-        ...iWasWrongWarning,
       ].filter(l => l !== '').join('\n');
     }
 
@@ -3153,47 +2552,43 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
       // Try exact best-solution key first
       const best = await redis.get(`cachly:lesson:best:${topic}`);
       if (best) {
-        const lesson = JSON.parse(best) as {
+        let lesson: {
           topic: string; outcome: string; what_worked: string; what_failed?: string;
-          context?: string; ts: string; verified_at?: string; severity?: string;
-          file_paths?: string[]; commands?: string[]; tags?: string[];
-          recall_count?: number; audit_trail?: unknown[];
-        };
-
-        // ── Confidence decay check ───────────────────────────────────────────
-        const confidence = calculateConfidence(lesson);
-        const ref = lesson.verified_at ?? lesson.ts;
-        const ageDays = (Date.now() - new Date(ref).getTime()) / 86400000;
-        const badge = confidenceBadge(confidence, ageDays);
-
-        // Recall resets verified_at (confidence clock restart)
-        const updatedLesson = {
-          ...lesson,
-          recall_count: (lesson.recall_count ?? 0) + 1,
-          verified_at: new Date().toISOString(),
-          confidence: 1.0,
+          context?: string; ts: string; severity?: string; file_paths?: string[];
+          commands?: string[]; tags?: string[]; recall_count?: number;
         };
+        try { lesson = JSON.parse(best); } catch {
+          return `⚠️ Lesson for \`${topic}\` could not be read (corrupted data). Use \`learn_from_attempts\` to overwrite it.`;
+        }
+        // Increment recall_count
+        const updatedLesson = { ...lesson, recall_count: (lesson.recall_count ?? 0) + 1 };
         await redis.set(`cachly:lesson:best:${topic}`, JSON.stringify(updatedLesson));
 
-        const sevEmoji = lesson.severity === 'critical' ? '🔴' : lesson.severity === 'major' ? '🟡' : lesson.severity ? '🟢' : '';
-        const auditSummary = (lesson.audit_trail ?? []).length > 1
-          ? `_Audit: ${(lesson.audit_trail ?? []).length} changes · stored ${new Date(lesson.ts).toLocaleDateString('de-DE')}_`
-          : '';
-
-        // "Remember when..." — emotional header for lessons > 60 days old
-        const ageFromStoreDays = (Date.now() - new Date(lesson.ts).getTime()) / 86400000;
-        const rememberWhen = ageFromStoreDays > 60
-          ? `💭 _Remember when you solved this ${Math.round(ageFromStoreDays / 30)} months ago? Still works._`
-          : '';
-
-        // "Never Google This Again" — suggest pinning after 3rd recall
-        const suggestPin = updatedLesson.recall_count === 3 && !(lesson as { pinned?: boolean }).pinned
-          ? `📌 **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.`
-          : '';
+        // Fire-and-forget: track Magic Moment in Plausible + API engagement counter
+        const isFirstRecall = (lesson.recall_count ?? 0) === 0;
+        const recallEvent = isFirstRecall ? 'First Brain Recall' : 'Brain Recall Hit';
+        fetch('https://analytics.cachly.dev/api/event', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json', 'User-Agent': 'cachly-mcp/recall' },
+          body: JSON.stringify({
+            domain: 'cachly.dev', name: recallEvent,
+            url: 'https://cachly.dev/mcp/recall', props: { topic },
+          }),
+        }).catch(() => { /* non-critical */ });
+        if (JWT) {
+          fetch(`${API_URL}/api/v1/telemetry/mcp`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ event: isFirstRecall ? 'first_recall' : 'recall', api_key: JWT }),
+          }).catch(() => { /* non-critical */ });
+        }
 
+        const sevEmoji = lesson.severity === 'critical' ? '🔴' : lesson.severity === 'major' ? '🟡' : lesson.severity ? '🟢' : '';
+        const sessionAgeMs = Date.now() - new Date(lesson.ts).getTime();
+        const sessionAgeDays = Math.round(sessionAgeMs / 86_400_000);
+        const ageLabel = sessionAgeDays === 0 ? 'today' : sessionAgeDays === 1 ? 'yesterday' : `${sessionAgeDays} days ago`;
         return [
-          rememberWhen,
-          `${badge} **Best solution for \`${topic}\`** ${sevEmoji}${lesson.severity ? ` (${lesson.severity})` : ''} · recalled ${updatedLesson.recall_count}×`,
+          `✅ **Best solution for \`${topic}\`** ${sevEmoji}${lesson.severity ? ` (${lesson.severity})` : ''} · recalled ${updatedLesson.recall_count}× · stored ${ageLabel}`,
           ``,
           `**What worked:** ${lesson.what_worked}`,
           lesson.what_failed ? `**What failed (avoid this):** ${lesson.what_failed}` : '',
@@ -3201,8 +2596,8 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
           (lesson.file_paths ?? []).length > 0 ? `**Files:** ${(lesson.file_paths ?? []).map((f: string) => `\`${f}\``).join(', ')}` : '',
           (lesson.commands ?? []).length > 0 ? `**Commands:** ${(lesson.commands ?? []).map((c: string) => `\`${c}\``).join(', ')}` : '',
           (lesson.tags ?? []).length > 0 ? `**Tags:** ${(lesson.tags ?? []).map((t: string) => `#${t}`).join(' ')}` : '',
-          auditSummary,
-          suggestPin,
+          ``,
+          `> 🧠 *Your AI remembered this from ${ageLabel} — persistent memory by [cachly.dev](https://cachly.dev)*`,
         ].filter(l => l !== '').join('\n');
       }
 
@@ -3221,7 +2616,7 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
         const histKey = `cachly:lessons:${topic}`;
         const all = await redis.lrange(histKey, -3, -1);
         if (all.length > 0) {
-          const parsed = all.map(e => JSON.parse(e) as { outcome: string; what_worked: string; ts: string });
+          const parsed = all.flatMap(e => { try { return [JSON.parse(e) as { outcome: string; what_worked: string; ts: string }]; } catch { return []; } });
           const lines = parsed.map(p => `- ${p.outcome === 'success' ? '✅' : '❌'} ${p.what_worked.slice(0, 120)} (${new Date(p.ts).toLocaleDateString('de-DE')})`);
           return `⚠️ No successful solution for \`${topic}\` yet. Last attempts:\n\n${lines.join('\n')}`;
         }
@@ -3233,12 +2628,28 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
       for (const k of matching.slice(0, 5)) {
         const raw = await redis.get(k);
         if (!raw) continue;
-        const lesson = JSON.parse(raw) as { topic: string; what_worked: string; context?: string; ts: string };
+        let lesson: { topic: string; what_worked: string; context?: string; ts: string };
+        try { lesson = JSON.parse(raw); } catch { continue; }
         results.push(`**\`${lesson.topic}\`** — ${lesson.what_worked.slice(0, 200)}`);
       }
       return `🔍 **Partial matches for \`${topic}\`:**\n\n${results.join('\n\n')}`;
     }
 
+    case 'forget_lesson': {
+      const { instance_id, topic } = args as { instance_id: string; topic: string };
+      const redis = await getConnection(instance_id);
+      const bestKey = `cachly:lesson:best:${topic}`;
+      const histKey = `cachly:lessons:${topic}`;
+      const [delBest, delHist] = await Promise.all([
+        redis.del(bestKey),
+        redis.del(histKey),
+      ]);
+      if (delBest === 0 && delHist === 0) {
+        return `📭 No lesson found for \`${topic}\` — nothing to delete.`;
+      }
+      return `🗑️ Lesson for \`${topic}\` deleted (best-solution: ${delBest > 0 ? 'removed' : 'not found'}, history: ${delHist > 0 ? 'removed' : 'not found'}). You can now store a corrected lesson with \`learn_from_attempts\`.`;
+    }
+
     case 'smart_recall': {
       const {
         instance_id,
@@ -3353,18 +2764,32 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
 
     // ── get_api_status ────────────────────────────────────────────────────────
     case 'get_api_status': {
-      // Check health
+      // Check API health and auth service in parallel
+      const [healthResult, authServiceResult] = await Promise.allSettled([
+        fetch(`${API_URL}/health`, { signal: AbortSignal.timeout(5000) }),
+        fetch(`${AUTH_URL}/.well-known/openid-configuration`, { signal: AbortSignal.timeout(5000) }),
+      ]);
+
       let healthStatus = 'unknown';
-      try {
-        const healthRes = await fetch(`${API_URL}/health`);
+      if (healthResult.status === 'fulfilled') {
+        const healthRes = healthResult.value;
         if (healthRes.ok) {
-          const body = await healthRes.json() as { status?: string; db?: string };
-          healthStatus = `${body.status ?? 'ok'} (db: ${body.db ?? '?'})`;
+          const body = await healthRes.json().catch(() => ({})) as { status?: string; db?: string };
+          healthStatus = `✅ ${body.status ?? 'ok'}${body.db ? ` (db: ${body.db})` : ''}`;
         } else {
-          healthStatus = `HTTP ${healthRes.status}`;
+          healthStatus = `❌ HTTP ${healthRes.status}`;
         }
-      } catch (e) {
-        healthStatus = `unreachable: ${(e as Error).message}`;
+      } else {
+        healthStatus = `❌ unreachable: ${healthResult.reason?.message ?? 'timeout'}`;
+      }
+
+      let authSvcStatus = 'unknown';
+      if (authServiceResult.status === 'fulfilled') {
+        authSvcStatus = authServiceResult.value.ok
+          ? `✅ reachable (${AUTH_URL})`
+          : `❌ HTTP ${authServiceResult.value.status} — auth service may be down`;
+      } else {
+        authSvcStatus = `❌ unreachable: ${authServiceResult.reason?.message ?? 'timeout'} — auth service may be down`;
       }
 
       // Check JWT / auth
@@ -3372,16 +2797,18 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
         return [
           `📡 **cachly API Status**`,
           ``,
-          `  🌐 API:      ${API_URL}`,
-          `  💓 Health:   ${healthStatus}`,
-          `  🔑 Auth:     ❌ CACHLY_JWT not set`,
+          `  🌐 API:          ${API_URL}`,
+          `  💓 API Health:   ${healthStatus}`,
+          `  🔐 Auth Service: ${authSvcStatus}`,
+          `  🔑 JWT:          ❌ CACHLY_JWT not set`,
           ``,
-          `💡 Get your API token at https://cachly.dev/instances → Settings → API Token`,
+          `💡 Get your API token at https://cachly.dev/settings`,
         ].join('\n');
       }
 
       // Decode JWT claims (inspection only, no verification)
       let authInfo = '❌ invalid JWT format';
+      let isExpired = false;
       try {
         const parts = JWT.split('.');
         if (parts.length === 3) {
@@ -3392,33 +2819,44 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
           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;
+          isExpired = expTs ? expTs < new Date() : false;
           authInfo = [
-            `✅ JWT decoded`,
+            `${isExpired ? '⚠️ ' : '✅'} JWT decoded`,
             `  Sub (user ID): ${sub}`,
             `  Provider:      ${provider}`,
             `  Issuer:        ${iss}`,
-            `  Expires:       ${expTs ? expTs.toISOString() : 'never'} ${expired ? '⚠️  EXPIRED – get a new token!' : '✅'}`,
+            `  Expires:       ${expTs ? expTs.toISOString() : 'never'} ${isExpired ? '⚠️  EXPIRED' : '✅'}`,
           ].join('\n');
         }
       } catch {
         authInfo = '❌ JWT decode failed – check CACHLY_JWT format';
       }
 
-      return [
+      const lines = [
         `📡 **cachly API Status**`,
         ``,
-        `  🌐 API:    ${API_URL}`,
-        `  💓 Health: ${healthStatus}`,
+        `  🌐 API:          ${API_URL}`,
+        `  💓 API Health:   ${healthStatus}`,
+        `  🔐 Auth Service: ${authSvcStatus}`,
         ``,
-        `🔑 **Auth:**`,
+        `🔑 **Auth (JWT):**`,
         authInfo,
-      ].join('\n');
+      ];
+
+      if (isExpired) {
+        lines.push(``, `⚠️  Your token is expired — get a new one at https://cachly.dev/settings`);
+      }
+      if (authSvcStatus.startsWith('❌')) {
+        lines.push(``, `⚠️  Auth service appears down. Registration and login on cachly.dev may be unavailable.`);
+        lines.push(`   Contact support@cachly.dev if this persists.`);
+      }
+
+      return lines.join('\n');
     }
 
     // ── session_start ─────────────────────────────────────────────────────────
     case 'session_start': {
-      const { instance_id, focus = '', author = '' } = args as { instance_id: string; focus?: string; author?: string };
+      const { instance_id, focus = '' } = args as { instance_id: string; focus?: string };
       const redis = await getConnection(instance_id);
 
       // 1. Scan all best-solution lessons
@@ -3433,8 +2871,7 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
       // 2. Fetch all lesson values for recency sorting + focus matching
       type Lesson = {
         topic: string; outcome: string; what_worked: string; what_failed?: string;
-        ts: string; verified_at?: string; severity?: string; recall_count?: number;
-        tags?: string[]; confidence?: number; audit_trail?: unknown[];
+        ts: string; severity?: string; recall_count?: number; tags?: string[];
       };
       const lessons: Lesson[] = [];
       for (const k of lessonKeys) {
@@ -3473,43 +2910,7 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
           )
         : [];
 
-      // 6. Streak tracking
-      let streakDays = 0;
-      let streakRecord = 0;
-      let streakMessage = '';
-      try {
-        const streakRaw = await redis.get('cachly:streak:current');
-        const streak = streakRaw ? JSON.parse(streakRaw) as { days: number; last_date: string; record: number } : null;
-        const today = new Date().toISOString().slice(0, 10);
-        if (streak) {
-          const lastDate = streak.last_date;
-          const yesterday = new Date(Date.now() - 86400000).toISOString().slice(0, 10);
-          if (lastDate === today) {
-            // Already counted today
-            streakDays = streak.days;
-            streakRecord = streak.record;
-          } else if (lastDate === yesterday) {
-            // Continuing streak
-            streakDays = streak.days + 1;
-            streakRecord = Math.max(streakDays, streak.record);
-            await redis.set('cachly:streak:current', JSON.stringify({ days: streakDays, last_date: today, record: streakRecord }));
-          } else {
-            // Streak broken
-            streakDays = 1;
-            streakRecord = streak.record;
-            await redis.set('cachly:streak:current', JSON.stringify({ days: 1, last_date: today, record: streakRecord }));
-          }
-        } else {
-          // First session ever
-          streakDays = 1;
-          streakRecord = 1;
-          await redis.set('cachly:streak:current', JSON.stringify({ days: 1, last_date: today, record: 1 }));
-        }
-        if (streakDays >= 7) streakMessage = `🔥 **${streakDays}-day streak!** ${streakDays === streakRecord ? ' New record!' : `Best: ${streakRecord}d`}`;
-        else if (streakDays > 1) streakMessage = `🔥 ${streakDays}-day streak`;
-      } catch { /* non-critical */ }
-
-      // 7. Save session start marker
+      // 6. Save session start marker
       await redis.set('cachly:session:current', JSON.stringify({
         started: new Date().toISOString(),
         focus,
@@ -3517,38 +2918,6 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
 
       // ── Build briefing ──────────────────────────────────────────────────────
       const lines: string[] = ['🧠 **Session Briefing**', ''];
-      if (streakMessage) lines.push(streakMessage, '');
-
-      // Handoff from previous window (if any)
-      const handoffRaw = await redis.get('cachly:session:handoff');
-      if (handoffRaw) {
-        try {
-          const handoff = JSON.parse(handoffRaw) as {
-            ts: string; completed_tasks: string[]; remaining_tasks: string[];
-            files_changed?: { path: string; status: string; description?: string }[];
-            instructions?: string; context_summary?: string; blocked_on?: string;
-          };
-          const ago = Math.round((Date.now() - new Date(handoff.ts).getTime()) / 60000);
-          const agoStr = ago < 60 ? `${ago}m ago` : ago < 1440 ? `${Math.round(ago / 60)}h ago` : `${Math.round(ago / 1440)}d ago`;
-
-          lines.push(`🤝 **Handoff from previous window** (${agoStr}):`);
-          if (handoff.context_summary) lines.push(`   ${handoff.context_summary}`);
-          if (handoff.remaining_tasks.length > 0) {
-            lines.push(`   ⏳ **Remaining tasks:**`);
-            for (const t of handoff.remaining_tasks) lines.push(`     - ${t}`);
-          }
-          if (handoff.completed_tasks.length > 0) {
-            lines.push(`   ✅ **Already done:** ${handoff.completed_tasks.join(', ')}`);
-          }
-          const brokenFiles = (handoff.files_changed ?? []).filter(f => f.status === 'broken' || f.status === 'partial');
-          if (brokenFiles.length > 0) {
-            lines.push(`   ⚠️ **Needs fix:** ${brokenFiles.map(f => `\`${f.path}\` (${f.status}${f.description ? ': ' + f.description : ''})`).join(', ')}`);
-          }
-          if (handoff.blocked_on) lines.push(`   🚫 **Blocked on:** ${handoff.blocked_on}`);
-          if (handoff.instructions) lines.push(`   📝 **Instructions:** ${handoff.instructions}`);
-          lines.push('');
-        } catch { /* ignore corrupt handoff */ }
-      }
 
       // Last session
       if (lastSession) {
@@ -3600,136 +2969,6 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
         lines.push('');
       }
 
-      // ── Stale / low-confidence lessons (confidence decay) ─────────────────
-      const staleSuccessLessons = lessons.filter(l => {
-        if (l.outcome !== 'success' && l.outcome !== 'partial') return false;
-        return calculateConfidence(l) < CONFIDENCE_WARN_VALUE;
-      });
-      if (staleSuccessLessons.length > 0) {
-        lines.push(`🔴 **Stale lessons** (not recalled in >${CONFIDENCE_WARN_DAYS}d — verify before applying):`);
-        for (const l of staleSuccessLessons.slice(0, 4)) {
-          const conf = calculateConfidence(l);
-          const ageDays = Math.round((Date.now() - new Date(l.verified_at ?? l.ts).getTime()) / 86400000);
-          const flag = conf < CONFIDENCE_STALE_VALUE ? '🔴' : '⚠️';
-          lines.push(`  ${flag} \`${l.topic}\` — ${ageDays}d stale, ${(conf * 100).toFixed(0)}% confidence`);
-        }
-        lines.push(`  _Run \`recall_best_solution\` on these to reset their confidence clock._`);
-        lines.push('');
-      }
-
-      // ── Session Replay: show last session's decision log ──────────────────
-      const lastSessionAny = lastSession as unknown as { decision_log?: Array<{ topic: string; outcome: string; what_worked: string }> } | null;
-      if (lastSessionAny?.decision_log?.length) {
-        const dl = lastSessionAny.decision_log;
-        const successes = dl.filter(d => d.outcome === 'success');
-        const failures  = dl.filter(d => d.outcome === 'failure');
-        lines.push(`🎬 **Last session decisions** (${dl.length} lessons stored):`);
-        if (successes.length > 0) lines.push(`  ✅ Worked: ${successes.slice(0, 3).map(d => `\`${d.topic}\``).join(', ')}`);
-        if (failures.length > 0)  lines.push(`  ❌ Failed: ${failures.slice(0, 3).map(d => `\`${d.topic}\``).join(', ')}`);
-        lines.push('');
-      }
-
-      // ── 🔮 Predictive Pre-Warning — intent-based danger detection ────────────
-      // 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[] };
-        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
-        }
-      }
-
-      // ── 👥 Team Telepathy — what teammates learned this week ─────────────────
-      if (author) {
-        type LessonAny = typeof lessons[0] & { author?: string };
-        const oneWeekAgo = Date.now() - 7 * 86_400_000;
-        const teamLessons = (lessons as LessonAny[]).filter(l =>
-          l.author && l.author !== author && new Date(l.ts).getTime() > oneWeekAgo,
-        );
-        if (teamLessons.length > 0) {
-          // Group by author
-          const byAuthor = new Map<string, LessonAny[]>();
-          for (const l of teamLessons) {
-            const a = l.author!;
-            if (!byAuthor.has(a)) byAuthor.set(a, []);
-            byAuthor.get(a)!.push(l);
-          }
-          lines.push(`👥 **Team this week** (${teamLessons.length} lesson${teamLessons.length > 1 ? 's' : ''} from teammates):`);
-          for (const [teamAuthor, tls] of byAuthor) {
-            lines.push(`  👤 **${teamAuthor}**:`);
-            for (const l of tls.slice(0, 3)) {
-              const emoji = l.outcome === 'success' ? '✅' : l.outcome === 'partial' ? '⚠️' : '❌';
-              lines.push(`    ${emoji} \`${l.topic}\` — ${l.what_worked.slice(0, 80)}`);
-            }
-            if (tls.length > 3) lines.push(`    … and ${tls.length - 3} more`);
-          }
-          lines.push('');
-        }
-      }
-
-      // ── 💎 Memory Crystal — compressed wisdom from old sessions ──────────────
-      try {
-        const crystalRaw = await redis.get('cachly:crystal:latest');
-        if (crystalRaw) {
-          const crystal = JSON.parse(crystalRaw) as {
-            label: string; ts: string; session_count: number;
-            top_patterns: Array<{ category: string; insight: string; count: number }>;
-          };
-          const crystalAge = Math.round((Date.now() - new Date(crystal.ts).getTime()) / 86_400_000);
-          if (crystalAge <= 90) {
-            lines.push(`💎 **Memory Crystal** (${crystal.label} · ${crystal.session_count} sessions compressed):`);
-            for (const p of crystal.top_patterns.slice(0, 3)) {
-              lines.push(`  • **${p.category}** (${p.count}×): ${p.insight.slice(0, 90)}`);
-            }
-            lines.push('');
-          }
-        }
-      } catch { /* non-critical */ }
-
-      // ── 🗺️ Roadmap — open items at session start ────────────────────────────
-      try {
-        const roadmapAll = await redis.hgetall(`cachly:roadmap:${instance_id}`);
-        if (roadmapAll && Object.keys(roadmapAll).length > 0) {
-          const PRIORITY_ORDER: Record<string, number> = { critical: 0, high: 1, medium: 2, low: 3 };
-          const PRIORITY_ICON: Record<string, string> = { critical: '🔴', high: '🟠', medium: '🟡', low: '🔵' };
-          const openStatuses = new Set(['planned', 'in-progress', 'blocked']);
-          const allItems = Object.values(roadmapAll).map(v => JSON.parse(v as string) as Record<string, unknown>);
-          const openItems = allItems
-            .filter(i => openStatuses.has(i.status as string))
-            .sort((a, b) => {
-              if (a.status === 'in-progress' && b.status !== 'in-progress') return -1;
-              if (b.status === 'in-progress' && a.status !== 'in-progress') return 1;
-              return (PRIORITY_ORDER[a.priority as string] ?? 99) - (PRIORITY_ORDER[b.priority as string] ?? 99);
-            });
-          const doneCount = allItems.filter(i => i.status === 'done').length;
-          if (openItems.length > 0) {
-            lines.push(`🗺️ **Roadmap** (${openItems.length} open · ${doneCount} done):`);
-            for (const it of openItems.slice(0, 5)) {
-              const statusIcon = it.status === 'in-progress' ? '⚡' : it.status === 'blocked' ? '🚫' : '📋';
-              lines.push(`  ${statusIcon} ${PRIORITY_ICON[it.priority as string] ?? '⚪'} \`${it.id}\` **${it.title}**`);
-            }
-            if (openItems.length > 5) lines.push(`  … and ${openItems.length - 5} more`);
-            lines.push(`  _Use \`roadmap_next\` for the top priority item · \`roadmap_list\` for full view_`);
-            lines.push('');
-          }
-        }
-      } catch { /* non-critical */ }
-
       return lines.join('\n');
     }
 
@@ -3740,13 +2979,11 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
         summary,
         files_changed = [],
         lessons_learned,
-        workspace_path = '',
       } = args as {
         instance_id: string;
         summary: string;
         files_changed?: string[];
         lessons_learned?: number;
-        workspace_path?: string;
       };
 
       const redis = await getConnection(instance_id);
@@ -3762,21 +2999,12 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
         } catch { /* ignore */ }
       }
 
-      // ── Session Replay: capture decision log ─────────────────────────────
-      let decisionLog: Array<{ ts: string; topic: string; outcome: string; what_worked: string }> = [];
-      try {
-        const dlEntries = await redis.lrange('cachly:session:decision-log', 0, -1);
-        decisionLog = dlEntries.map(e => JSON.parse(e) as { ts: string; topic: string; outcome: string; what_worked: string });
-        await redis.del('cachly:session:decision-log');
-      } catch { /* non-critical */ }
-
       const sessionRecord = {
         ts: now.toISOString(),
         summary,
         files_changed,
         ...(lessons_learned !== undefined ? { lessons_learned } : {}),
         ...(durationMin !== undefined ? { duration_min: durationMin } : {}),
-        ...(decisionLog.length > 0 ? { decision_log: decisionLog } : {}),
       };
 
       // Save as "last session"
@@ -3790,127 +3018,6 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
       // Clean up current session marker
       await redis.del('cachly:session:current');
 
-      // ── AUTO-LEARN from session summary (no manual call needed) ─────────────
-      // Parse the summary for actionable lessons and store them automatically.
-      const autoLearned: string[] = [];
-      try {
-        // Extract key sentences from the summary that contain action verbs
-        const actionVerbs = /\b(fixed|deployed|added|removed|refactored|migrated|updated|resolved|implemented|improved|optimized|configured|created|deleted|disabled|enabled|discovered|found|learned|debugged|patched|upgraded|installed|tested|built|rewrote|moved|renamed|split|merged|extracted)\b/i;
-        const sentences = summary
-          .split(/[.!\n]+/)
-          .map(s => s.trim())
-          .filter(s => s.length > 20 && actionVerbs.test(s));
-
-        for (const sentence of sentences.slice(0, 6)) {
-          // Build a topic slug from the first meaningful words
-          const words = sentence.toLowerCase()
-            .replace(/[^a-z0-9\s]/g, ' ')
-            .split(/\s+/)
-            .filter(w => w.length > 3 && !['that', 'this', 'with', 'from', 'have', 'been', 'were', 'they', 'then', 'when', 'also', 'into', 'will', 'would', 'could', 'should'].includes(w));
-          const slug = words.slice(0, 4).join('-');
-          if (!slug) continue;
-          const topic = `auto:${slug}`;
-          const key = `cachly:lesson:best:${topic}`;
-
-          // Don't overwrite existing successful lessons
-          const existing = await redis.get(key);
-          if (existing) {
-            try {
-              const ex = JSON.parse(existing) as { outcome: string };
-              if (ex.outcome === 'success') continue;
-            } catch { /* ignore */ }
-          }
-
-          const lesson = {
-            topic,
-            outcome: 'success',
-            what_worked: sentence,
-            context: `Auto-learned from session summary. Full summary: ${summary.slice(0, 300)}`,
-            severity: 'minor',
-            ts: now.toISOString(),
-            recall_count: 0,
-            auto_learned: true,
-            session_ts: now.toISOString(),
-            version: 2,
-          };
-          await redis.set(key, JSON.stringify(lesson));
-          // 90-day TTL for auto-learned lessons
-          await redis.expire(key, 90 * 86400);
-          autoLearned.push(topic);
-        }
-
-        // Also store a lesson per changed file area if files were changed
-        if (files_changed.length > 0) {
-          const areas = [...new Set(files_changed.map(f => f.split('/').slice(0, 2).join('/')))].slice(0, 3);
-          for (const area of areas) {
-            const slug = area.replace(/[^a-z0-9]/gi, '-').toLowerCase().replace(/-+/g, '-').slice(0, 30);
-            const topic = `auto:changed:${slug}`;
-            const key = `cachly:lesson:best:${topic}`;
-            const lesson = {
-              topic,
-              outcome: 'success',
-              what_worked: `Files changed in ${area}: ${files_changed.filter(f => f.startsWith(area.split('/')[0])).slice(0, 5).join(', ')}`,
-              context: summary.slice(0, 200),
-              severity: 'minor',
-              ts: now.toISOString(),
-              recall_count: 0,
-              auto_learned: true,
-              version: 2,
-            };
-            await redis.set(key, JSON.stringify(lesson));
-            await redis.expire(key, 90 * 86400);
-            autoLearned.push(topic);
-          }
-        }
-      } catch { /* auto-learn errors must never break session_end */ }
-
-      // ── 🌿 Ambient Git Learning ────────────────────────────────────────────────
-      // Read git commits since session start → auto-learn each meaningful commit.
-      const ambientLearned: string[] = [];
-      if (workspace_path) {
-        try {
-          // Get the session start time (stored by session_start)
-          const sessionStartTs = currentRaw
-            ? (() => { try { return (JSON.parse(currentRaw) as { started?: string }).started ?? ''; } catch { return ''; } })()
-            : '';
-          const sinceArg = sessionStartTs ? `--since="${sessionStartTs}"` : '--since="1 hour ago"';
-          const gitOut = execSync(
-            `git -C "${workspace_path}" log ${sinceArg} --oneline --format="%H|||%s|||%ai"`,
-            { timeout: 5000, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] },
-          ).trim();
-          if (gitOut) {
-            const commitActionRe = /\b(fix|add|remove|refactor|migrate|update|resolve|implement|improve|optimize|configure|create|delete|disable|enable|debug|patch|upgrade|build|rewrite|deploy|feat|chore|docs|test|perf|ci)\b/i;
-            for (const line of gitOut.split('\n').slice(0, 10)) {
-              const [hash, msg, dateStr] = line.split('|||');
-              if (!msg || !commitActionRe.test(msg)) continue;
-              const slug = msg
-                .toLowerCase().replace(/^(fix|feat|chore|docs|test|ci|perf|refactor|build|revert)[:(\s]/i, '')
-                .replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 40);
-              if (!slug) continue;
-              const topic = `git:${slug}`;
-              const key = `cachly:lesson:best:${topic}`;
-              const existing = await redis.get(key);
-              if (existing) continue; // don't overwrite existing
-              const commitLesson = {
-                topic,
-                outcome: 'success' as const,
-                what_worked: msg.slice(0, 200),
-                context: `Auto-learned from git commit ${(hash ?? '').slice(0, 7)} at ${dateStr ?? ''} in ${workspace_path}`,
-                severity: 'minor' as const,
-                ts: now.toISOString(),
-                recall_count: 0,
-                auto_learned: true,
-                source: 'ambient-git',
-                version: 3,
-              };
-              await redis.set(key, JSON.stringify(commitLesson));
-              await redis.expire(key, 60 * 86400); // 60 day TTL for git lessons
-              ambientLearned.push(topic);
-            }
-          }
-        } catch { /* git not available or not a repo — silent skip */ }
-      }
-
       const durationStr = durationMin !== undefined ? ` · ${durationMin} min` : '';
       return [
         `✅ **Session saved**${durationStr}`,
@@ -3918,70 +3025,11 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
         `📋 **Summary:** ${summary}`,
         files_changed.length > 0 ? `📁 **Files changed:** ${files_changed.map(f => `\`${f}\``).join(', ')}` : '',
         lessons_learned !== undefined ? `🧠 **Lessons stored:** ${lessons_learned}` : '',
-        autoLearned.length > 0 ? `🤖 **Auto-learned:** ${autoLearned.length} lessons extracted from summary (${autoLearned.slice(0, 3).map(t => `\`${t}\``).join(', ')}${autoLearned.length > 3 ? '…' : ''})` : '',
-        ambientLearned.length > 0 ? `🌿 **Ambient git learning:** ${ambientLearned.length} commit${ambientLearned.length > 1 ? 's' : ''} auto-learned (${ambientLearned.slice(0, 3).map(t => `\`${t}\``).join(', ')}${ambientLearned.length > 3 ? '…' : ''})` : '',
         ``,
         `💡 Next session: \`session_start(focus="...")\` to see this summary.`,
       ].filter(l => l !== '').join('\n');
     }
 
-    // ── session_handoff — cross-window continuity ─────────────────────────────
-    case 'session_handoff': {
-      const {
-        instance_id,
-        completed_tasks = [],
-        remaining_tasks = [],
-        files_changed = [],
-        instructions = '',
-        context_summary = '',
-        blocked_on = '',
-      } = args as {
-        instance_id: string;
-        completed_tasks: string[];
-        remaining_tasks: string[];
-        files_changed?: { path: string; status: string; description?: string }[];
-        instructions?: string;
-        context_summary?: string;
-        blocked_on?: string;
-      };
-
-      const redis = await getConnection(instance_id);
-      const now = new Date();
-
-      const handoff = {
-        ts: now.toISOString(),
-        completed_tasks,
-        remaining_tasks,
-        files_changed,
-        instructions,
-        context_summary,
-        blocked_on,
-      };
-
-      // Store handoff — never expires until next handoff overwrites it
-      await redis.set('cachly:session:handoff', JSON.stringify(handoff));
-
-      // Also append to history
-      await redis.lpush('cachly:session:handoff:history', JSON.stringify(handoff));
-      await redis.ltrim('cachly:session:handoff:history', 0, 19);
-
-      const totalTasks = completed_tasks.length + remaining_tasks.length;
-      const pct = totalTasks > 0 ? Math.round((completed_tasks.length / totalTasks) * 100) : 0;
-      const brokenFiles = files_changed.filter(f => f.status === 'broken' || f.status === 'partial');
-
-      return [
-        `🤝 **Handoff saved** — ${completed_tasks.length}/${totalTasks} tasks done (${pct}%)`,
-        ``,
-        completed_tasks.length > 0 ? `✅ **Completed:**\n${completed_tasks.map(t => `  - ${t}`).join('\n')}` : '',
-        remaining_tasks.length > 0 ? `\n⏳ **Remaining for next window:**\n${remaining_tasks.map(t => `  - ${t}`).join('\n')}` : '',
-        brokenFiles.length > 0 ? `\n⚠️ **Needs attention:** ${brokenFiles.map(f => `\`${f.path}\` (${f.status})`).join(', ')}` : '',
-        blocked_on ? `\n🚫 **Blocked on:** ${blocked_on}` : '',
-        instructions ? `\n📝 **Instructions:** ${instructions}` : '',
-        ``,
-        `💡 The next \`session_start\` will include this handoff automatically.`,
-      ].filter(l => l !== '').join('\n');
-    }
-
     // ── auto_learn_session ────────────────────────────────────────────────────
     case 'auto_learn_session': {
       const { instance_id, observations } = args as {
@@ -4209,153 +3257,9 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
       return lines.join('\n');
     }
 
-    // ── team_synthesize — Team Brain Synthesis ────────────────────────────────
-    case 'team_synthesize': {
-      const { instance_id, topic } = args as { instance_id: string; topic: string };
-      const redis = await getConnection(instance_id);
-
-      // Load history list for this topic (all authors' contributions)
-      const listKey = `cachly:lessons:${topic}`;
-      const all = await redis.lrange(listKey, 0, -1);
-      if (all.length < 2) {
-        return `📭 Need at least 2 entries for topic \`${topic}\` to synthesize.\n\nCurrently: ${all.length} entr${all.length === 1 ? 'y' : 'ies'}.\n\nHave team members store lessons via \`learn_from_attempts(topic="${topic}", ...)\`.`;
-      }
-
-      type Entry = { outcome: string; what_worked: string; what_failed?: string; author?: string; ts: string; severity?: string };
-      const entries: Entry[] = all.map(r => { try { return JSON.parse(r) as Entry; } catch { return null; } }).filter((e): e is Entry => e !== null);
-
-      // Group by outcome
-      const successes = entries.filter(e => e.outcome === 'success');
-      const failures  = entries.filter(e => e.outcome === 'failure');
-      const partials  = entries.filter(e => e.outcome === 'partial');
-
-      const authors = [...new Set(entries.map(e => e.author).filter(Boolean))];
-      const hasMultiAuthor = authors.length > 1;
-
-      // Build canonical merged version
-      // what_worked: pick the most recent success, or longest for most detail
-      const bestSuccess = successes.sort((a, b) => new Date(b.ts).getTime() - new Date(a.ts).getTime())[0];
-      const whatWorkedCandidates = successes.map(e => e.what_worked).filter(w => w && w.length > 10);
-      const canonicalWorked = whatWorkedCandidates.sort((a, b) => b.length - a.length)[0] ?? bestSuccess?.what_worked ?? '';
-
-      // what_failed: union of all unique failure reasons
-      const allFailed = [...new Set(
-        [...failures, ...partials].map(e => e.what_failed).filter((w): w is string => !!w && w.length > 5)
-      )];
-
-      const severities = entries.map(e => e.severity).filter(Boolean);
-      const canonicalSeverity = severities.includes('critical') ? 'critical' : severities.includes('major') ? 'major' : 'minor';
-
-      const lines = [
-        `🧬 **Team Brain Synthesis: \`${topic}\`**`,
-        `_${entries.length} entries from ${authors.length} author${authors.length === 1 ? '' : 's'}${hasMultiAuthor ? ` (${authors.join(', ')})` : ''} · ${successes.length} success · ${failures.length} failure · ${partials.length} partial_`,
-        '',
-        `**Canonical "what worked":**`,
-        `> ${canonicalWorked}`,
-        '',
-        allFailed.length > 0 ? `**Avoid (combined failures):**` : '',
-        ...allFailed.map(f => `> ❌ ${f}`),
-        allFailed.length > 0 ? '' : '',
-        `**Suggested canonical lesson:**`,
-        '```',
-        `learn_from_attempts(`,
-        `  topic       = "${topic}",`,
-        `  outcome     = "success",`,
-        `  what_worked = "${canonicalWorked.replace(/"/g, "'")}",`,
-        allFailed.length > 0 ? `  what_failed = "${allFailed[0].replace(/"/g, "'")}",` : '',
-        `  severity    = "${canonicalSeverity}",`,
-        `)`,
-        '```',
-        '',
-        hasMultiAuthor
-          ? `💡 _${authors.length} team members contributed to this synthesis. Store the canonical version to replace individual entries._`
-          : `💡 _Single author — more value when multiple team members contribute to the same topic._`,
-      ].filter(l => l !== undefined).join('\n');
-      return lines;
-    }
-
     // ── brain_doctor ──────────────────────────────────────────────────────────
-    // ── memory_crystalize ─────────────────────────────────────────────────────
-    case 'memory_crystalize': {
-      const { instance_id, label: crystalLabel = '' } = args as { instance_id: string; label?: string };
-      const redis = await getConnection(instance_id);
-      const now = new Date();
-      const week = `${now.getFullYear()}-W${String(Math.ceil((now.getDate() - now.getDay() + 10) / 7)).padStart(2, '0')}`;
-      const effectiveLabel = crystalLabel || `${now.toISOString().slice(0, 7)} Crystal`;
-
-      // Read session history
-      const sessionHistory = await redis.lrange('cachly:session:history', 0, 49);
-
-      // Read all auto-learned lessons
-      const allLessonKeys: string[] = [];
-      const ls = redis.scanStream({ match: 'cachly:lesson:best:*', count: 200 });
-      await new Promise<void>((res, rej) => {
-        ls.on('data', (b: string[]) => allLessonKeys.push(...b));
-        ls.on('end', res);
-        ls.on('error', rej);
-      });
-
-      type RawLesson = { topic: string; outcome: string; what_worked: string; severity?: string; ts: string; auto_learned?: boolean };
-      const allLessons: RawLesson[] = [];
-      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
-      const categoryMap = new Map<string, RawLesson[]>();
-      for (const l of allLessons) {
-        const cat = l.topic.split(':')[0] || 'misc';
-        if (!categoryMap.has(cat)) categoryMap.set(cat, []);
-        categoryMap.get(cat)!.push(l);
-      }
-
-      // Build top patterns (most frequent categories with a representative insight)
-      const topPatterns: Array<{ category: string; insight: string; count: number }> = [];
-      for (const [cat, catLessons] of [...categoryMap.entries()].sort((a, b) => b[1].length - a[1].length).slice(0, 8)) {
-        const successLessons = catLessons.filter(l => l.outcome === 'success');
-        const best = successLessons[0] ?? catLessons[0];
-        if (!best) continue;
-        topPatterns.push({
-          category: cat,
-          insight: best.what_worked.slice(0, 120),
-          count: catLessons.length,
-        });
-      }
-
-      const crystal = {
-        label: effectiveLabel,
-        ts: now.toISOString(),
-        session_count: sessionHistory.length,
-        lesson_count: allLessons.length,
-        top_patterns: topPatterns,
-        categories: [...categoryMap.keys()],
-        created_from: `${sessionHistory.length} sessions, ${allLessons.length} lessons`,
-      };
-
-      const crystalJson = JSON.stringify(crystal);
-      await redis.set('cachly:crystal:latest', crystalJson);
-      await redis.expire('cachly:crystal:latest', 90 * 86400);
-      await redis.set(`cachly:crystal:${week}`, crystalJson);
-      await redis.expire(`cachly:crystal:${week}`, 365 * 86400);
-
-      const lines = [
-        `💎 **Memory Crystal created: ${effectiveLabel}**`,
-        ``,
-        `📊 Compressed: **${sessionHistory.length} sessions** + **${allLessons.length} lessons** → ${topPatterns.length} top patterns`,
-        ``,
-        `**Top patterns by category:**`,
-        ...topPatterns.slice(0, 6).map(p => `  • **${p.category}** (${p.count}×): ${p.insight.slice(0, 90)}`),
-        ``,
-        `💡 This crystal will appear in every future \`session_start\` briefing.`,
-        `💡 Re-run \`memory_crystalize\` monthly to keep it fresh.`,
-      ];
-      return lines.join('\n');
-    }
-
     case 'brain_doctor': {
-      const { instance_id, workspace_path: drWorkspacePath = '' } = args as { instance_id: string; workspace_path?: string };
+      const { instance_id } = args as { instance_id: string };
       const redis = await getConnection(instance_id);
       const issues: string[] = [];
       const checks: string[] = [];
@@ -4381,15 +3285,12 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
       });
 
       // Load lessons for analysis
-      type DrLesson = {
-        topic: string; outcome: string; recall_count?: number; ts: string;
-        verified_at?: string; severity?: string; audit_trail?: unknown[];
-      };
-      const lessons: DrLesson[] = [];
+      type Lesson = { topic: string; outcome: string; recall_count?: number; ts: string; severity?: string };
+      const lessons: Lesson[] = [];
       for (const k of lessonKeys) {
         const raw = await redis.get(k);
         if (!raw) continue;
-        try { lessons.push(JSON.parse(raw) as DrLesson); } catch { /* skip */ }
+        try { lessons.push(JSON.parse(raw) as Lesson); } catch { /* skip */ }
       }
 
       // Last session
@@ -4405,17 +3306,6 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
       const unusedLessons = lessons.filter(l => (l.recall_count ?? 0) === 0);
       // Critical lessons
       const criticalLessons = lessons.filter(l => l.severity === 'critical');
-      // Confidence decay analysis
-      const staleLessons  = lessons.filter(l => l.outcome === 'success' && calculateConfidence(l) < CONFIDENCE_STALE_VALUE);
-      const warnLessons   = lessons.filter(l => l.outcome === 'success' && calculateConfidence(l) >= CONFIDENCE_STALE_VALUE && calculateConfidence(l) < CONFIDENCE_WARN_VALUE);
-      const withAudit     = lessons.filter(l => (l.audit_trail ?? []).length > 1);
-      // Team lessons
-      type DrLessonWithAuthor = DrLesson & { author?: string };
-      const teamLessons = (lessons as DrLessonWithAuthor[]).filter(l => l.author);
-      const uniqueAuthors = new Set((lessons as DrLessonWithAuthor[]).map(l => l.author).filter(Boolean));
-      // Effective IQ boost: total recalls / lessons (how much the brain actually helped)
-      const totalRecalls = lessons.reduce((sum, l) => sum + (l.recall_count ?? 0), 0);
-      const iqBoostPct = lessons.length > 0 ? Math.min(100, Math.round((totalRecalls / lessons.length) * 10)) : 0;
 
       // Quality score (0-100)
       let score = 50;
@@ -4427,67 +3317,12 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
       if (openFailures.length === 0) score += 5;
       const unusedRatio = lessons.length > 0 ? unusedLessons.length / lessons.length : 0;
       if (unusedRatio < 0.5)       score += 10;
-      if (staleLessons.length === 0) score += 5;
-      if (uniqueAuthors.size >= 2) score += 5; // team collaboration bonus
 
       const scoreEmoji = score >= 80 ? '🟢' : score >= 50 ? '🟡' : '🔴';
-      const iqEmoji = iqBoostPct >= 50 ? '🚀' : iqBoostPct >= 20 ? '📈' : '💤';
 
       checks.push(`${scoreEmoji} **Brain Quality Score: ${score}/100**`);
-      checks.push(`${iqEmoji} **Effective IQ Boost: ${iqBoostPct}%** (${totalRecalls} recalls across ${lessons.length} lessons)`);
-      checks.push(`📚 **Lessons:** ${lessonKeys.length} (${criticalLessons.length} critical · ${withAudit.length} with audit trail · ${teamLessons.length} from team)`);
+      checks.push(`📚 **Lessons:** ${lessonKeys.length} (${criticalLessons.length} critical)`);
       checks.push(`💾 **Context entries:** ${ctxCount}`);
-      checks.push(`🎯 **Confidence:** ${lessons.length - staleLessons.length - warnLessons.length} fresh · ${warnLessons.length} warn · ${staleLessons.length} stale`);
-      checks.push(`⏱️ **Decay config:** warn after ${CONFIDENCE_WARN_DAYS}d · stale after ${CONFIDENCE_STALE_DAYS}d`);
-      if (uniqueAuthors.size >= 2) {
-        checks.push(`👥 **Team:** ${uniqueAuthors.size} contributors (${[...uniqueAuthors].join(', ')})`);
-      }
-
-      // Stale index detection
-      try {
-        const lastIndexRaw = await redis.get('cachly:index:last_run');
-        if (lastIndexRaw) {
-          const lastIndexAge = Math.round((Date.now() - new Date(lastIndexRaw).getTime()) / 86_400_000);
-          if (lastIndexAge > 7) {
-            issues.push(`🔄 Index is ${lastIndexAge}d stale — run \`index_project\` to re-sync semantic search`);
-          } else {
-            checks.push(`🗂️ **Semantic index:** ${lastIndexAge}d old (fresh)`);
-          }
-        } else {
-          issues.push(`💡 No semantic index — run \`index_project(dir="<your-src>")\` to enable semantic search`);
-        }
-      } catch { /* non-critical */ }
-
-      // Memory crystal status
-      try {
-        const crystalRaw = await redis.get('cachly:crystal:latest');
-        if (crystalRaw) {
-          const crystal = JSON.parse(crystalRaw) as { ts: string; label: string };
-          const crystalAge = Math.round((Date.now() - new Date(crystal.ts).getTime()) / 86_400_000);
-          checks.push(`💎 **Memory Crystal:** ${crystal.label} (${crystalAge}d ago)`);
-          if (crystalAge > 30) issues.push(`💡 Memory Crystal is ${crystalAge}d old — re-run \`memory_crystalize\` to compress new sessions`);
-        } else if (lessonKeys.length >= 10) {
-          issues.push(`💡 ${lessonKeys.length} lessons but no Memory Crystal — run \`memory_crystalize\` to compress wisdom`);
-        }
-      } catch { /* non-critical */ }
-
-      // openclaw cross-promo (check package.json in workspace)
-      if (drWorkspacePath) {
-        try {
-          const pkgPath = drWorkspacePath.replace(/\/$/, '') + '/package.json';
-          const pkgRaw = readFileSync(pkgPath, 'utf-8');
-          const pkg = JSON.parse(pkgRaw) as { dependencies?: Record<string, string>; devDependencies?: Record<string, string> };
-          const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-          const hasLLMDep = ['openai', '@anthropic-ai/sdk', '@google/generative-ai', 'mistralai', 'cohere-ai'].some(d => d in allDeps);
-          const hasOpenclaw = '@cachly-dev/openclaw' in allDeps;
-          if (hasLLMDep && !hasOpenclaw) {
-            issues.push(`💡 **openclaw missing:** you use LLM APIs (${Object.keys(allDeps).filter(d => ['openai','@anthropic-ai/sdk'].includes(d)).join(', ')}) but not \`@cachly-dev/openclaw\``);
-            issues.push(`   → \`npm install @cachly-dev/openclaw\` cuts LLM costs 60–90% with 3 lines of code`);
-          } else if (hasOpenclaw) {
-            checks.push(`✅ **@cachly-dev/openclaw installed** (LLM cost caching active)`);
-          }
-        } catch { /* no package.json or unreadable */ }
-      }
 
       if (lastSession) {
         const ageMin = Math.round((Date.now() - new Date(lastSession.ts).getTime()) / 60000);
@@ -4503,10 +3338,6 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
         issues.push(`💡 Only ${lessonKeys.length} lessons — add more after each problem solved`);
       }
 
-      if (iqBoostPct === 0 && lessons.length >= 5) {
-        issues.push(`💤 **IQ Boost is 0%** — lessons exist but are never recalled. Use \`recall_best_solution\` BEFORE tasks.`);
-      }
-
       if (ctxCount === 0) {
         issues.push('💡 No context — use `remember_context` to cache architecture docs, ADRs, etc.');
       }
@@ -4515,15 +3346,6 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
         issues.push(`⚠️ ${openFailures.length} unresolved failure${openFailures.length > 1 ? 's' : ''}: ${openFailures.slice(0, 3).map(l => `\`${l.topic}\``).join(', ')}`);
       }
 
-      if (staleLessons.length > 0) {
-        issues.push(`🔴 ${staleLessons.length} STALE lesson${staleLessons.length > 1 ? 's' : ''} (>${CONFIDENCE_STALE_DAYS}d, confidence <${CONFIDENCE_STALE_VALUE * 100}%): ${staleLessons.slice(0, 3).map(l => `\`${l.topic}\``).join(', ')}`);
-        issues.push(`   → Re-verify with \`recall_best_solution\` to reset confidence clock`);
-      }
-
-      if (warnLessons.length > 0) {
-        issues.push(`⚠️ ${warnLessons.length} lesson${warnLessons.length > 1 ? 's' : ''} aging (>${CONFIDENCE_WARN_DAYS}d): ${warnLessons.slice(0, 3).map(l => `\`${l.topic}\``).join(', ')}`);
-      }
-
       if (unusedRatio > 0.7 && lessons.length > 5) {
         issues.push(`💡 ${unusedLessons.length} lessons never recalled — verify topics match your workflow`);
       }
@@ -4539,77 +3361,6 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
       return lines.join('\n');
     }
 
-    // ── recall_at — Brain Archaeology ────────────────────────────────────────
-    case 'recall_at': {
-      const { instance_id, topic, date } = args as { instance_id: string; topic: string; date: string };
-      const redis = await getConnection(instance_id);
-      const cutoff = new Date(date).getTime();
-      if (isNaN(cutoff)) return `❌ Invalid date "${date}". Use ISO format: "2026-01-15"`;
-
-      const listKey = `cachly:lessons:${topic}`;
-      const all = await redis.lrange(listKey, 0, -1);
-      if (all.length === 0) return `📭 No history found for \`${topic}\`. Lessons are stored via \`learn_from_attempts\`.`;
-
-      const before = all
-        .map(raw => { try { return JSON.parse(raw) as { ts: string; outcome?: string; what_worked?: string; what_failed?: string }; } catch { return null; } })
-        .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) 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}**`,
-        `_${before.length} of ${all.length} total entries shown_`,
-        '',
-      ];
-      for (const l of before.slice(-10)) {
-        const emoji = l.outcome === 'success' ? '✅' : l.outcome === 'partial' ? '⚠️' : '❌';
-        const d = new Date(l.ts).toLocaleDateString('de-DE');
-        lines.push(`**${d}** ${emoji} ${l.outcome}`);
-        if (l.what_worked) lines.push(`  → ${l.what_worked.slice(0, 100)}`);
-        lines.push('');
-      }
-      lines.push(`_Full evolution: ${all.map(r => { try { const l = JSON.parse(r) as { outcome?: string }; return l.outcome === 'success' ? '✅' : l.outcome === 'partial' ? '⚠️' : '❌'; } catch { return '?'; } }).join(' → ')}_`);
-      return lines.join('\n');
-    }
-
-    // ── trace_dependency — Causal Chain ──────────────────────────────────────
-    case 'trace_dependency': {
-      const { instance_id, dependency, mark_review = false } = args as { instance_id: string; dependency: string; mark_review?: boolean };
-      const redis = await getConnection(instance_id);
-
-      const depKey = `cachly:dep:${dependency}`;
-      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[] = JSON.parse(raw);
-      const lines = [
-        `🔗 **Causal Chain: \`${dependency}\`** — ${topics.length} dependent lesson${topics.length === 1 ? '' : 's'}`,
-        '',
-      ];
-
-      for (const t of topics) {
-        const lessonRaw = await redis.get(`cachly:lesson:best:${t}`);
-        if (!lessonRaw) { lines.push(`  • \`${t}\` _(lesson deleted)_`); 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}`);
-
-        if (mark_review) {
-          const updated = { ...lesson, needs_review: true };
-          await redis.set(`cachly:lesson:best:${t}`, JSON.stringify(updated));
-        }
-      }
-
-      if (mark_review) {
-        lines.push('', `🔍 All ${topics.length} lessons marked as **needs_review** — verify they still work with the changed dependency.`);
-      } else {
-        lines.push('', `_Run with \`mark_review: true\` to flag all dependent lessons for re-verification._`);
-      }
-      return lines.join('\n');
-    }
-
     // ── global_learn ──────────────────────────────────────────────────────────
     case 'global_learn': {
       const { instance_id, topic, lesson, severity = 'minor', tags = [] } = args as {
@@ -4891,148 +3642,65 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
       // Generate copilot-instructions.md content
       const tier = inst.tier.toUpperCase();
       const smartRecallNote = hasVector
-        ? '- `smart_recall("natural language query")` — semantic search (finds by meaning)'
-        : '- `recall_context("arch:*")` — exact/glob key lookup (upgrade to Speed/Business for smart_recall)';
+        ? '3. Call `smart_recall` with keywords for semantic context search'
+        : '3. Call `recall_context` with relevant key patterns like "arch:*" or "file:*"';
       const layerNote = hasVector
-        ? `Layer 3 (Semantic): smart_recall uses pgvector HNSW on your ${tier} instance`
-        : `Layer 3 (Autopilot): this file — upgrade to Speed/Business tier to unlock smart_recall`;
-
-      const copilotInstructions = `# cachly AI Brain — ${project_description}
-
-> AI memory system powered by [cachly.dev](https://cachly.dev). Works with GitHub Copilot, Claude Code, Cursor, Windsurf, Continue.dev, and any MCP-compatible editor.
-
----
-
-## 🔴 MANDATORY RULES — Always enforced, no exceptions
-
-### Rule 1 — Session Start (FIRST thing in every window)
-Call \`session_start\` **before reading any source files or making any changes**:
-
-\`\`\`
-session_start(
-  instance_id = "${instance_id}",
-  focus       = "<what you plan to work on today>",
-)
-\`\`\`
-
-Returns: last session summary, handoff from previous window, recent lessons, open failures, brain health.
-
-**If \`session_start\` is unavailable**, fall back:
-1. \`smart_recall("recent lessons <topic>")\`
-2. \`recall_best_solution("<topic>")\`
-
-### Rule 2 — Learn After Every Fix/Deploy/Discovery (AUTOMATIC — no prompting needed)
-After **every** bug fix, deployment, failed attempt, or discovery — call \`learn_from_attempts\` immediately:
-
-\`\`\`
-learn_from_attempts(
-  instance_id = "${instance_id}",
-  topic       = "category:keyword",   # deploy:web | fix:auth | debug:db | infra:docker
-  outcome     = "success" | "failure" | "partial",
-  what_worked = "exact approach or command that worked",
-  what_failed = "what did NOT work (prevents future wasted time)",
-  severity    = "critical" | "major" | "minor",
-  commands    = ["exact command that worked"],
-  file_paths  = ["path/to/changed/file"],
-)
-\`\`\`
-
-**These events MUST automatically trigger \`learn_from_attempts\`:**
-- ✅ Successfully deployed → \`topic="deploy:<component>", outcome="success"\`
-- ✅ Fixed a bug → \`topic="fix:<description>", outcome="success"\`
-- ✅ Discovered root cause → \`topic="debug:<area>", outcome="partial"\`
-- ✅ Tried something that failed → \`topic="<area>", outcome="failure", what_failed="..."\`
-- ✅ Found a config quirk → \`topic="infra:<topic>", outcome="success"\`
-- ✅ Ran a working command → store it in \`commands=[...]\`
+        ? `Layer 3 (Semantic): smart_recall uses pgvector HNSW on your ${tier} instance for meaning-based search`
+        : `Layer 3 (Autopilot): This file — upgrade to Speed/Business tier to unlock smart_recall`;
 
-### Rule 3 — Session Handoff (when closing window or task list > 3 items)
-\`\`\`
-session_handoff(
-  instance_id     = "${instance_id}",
-  completed_tasks = ["what was done"],
-  remaining_tasks = ["what is still to do"],
-  files_changed   = [{"path": "src/...", "status": "modified", "description": "what changed"}],
-  instructions    = "IMPORTANT: what the next window MUST know to not break things",
-  context_summary = "current state of the system",
-)
-\`\`\`
-
-The next \`session_start\` automatically includes this handoff. The new window sees exactly what's done, what remains, and what NOT to break.
+      const copilotInstructions = `# cachly AI Memory — ${project_description}
 
-### Rule 4 — Session End (LAST thing before closing)
-\`\`\`
-session_end(
-  instance_id     = "${instance_id}",
-  summary         = "What was accomplished (2-3 sentences with specifics)",
-  files_changed   = ["list", "of", "changed", "files"],
-  lessons_learned = <number of learn_from_attempts calls made>,
-)
-\`\`\`
+## 3-Layer AI Memory System
 
-> \`session_end\` **automatically extracts and stores lessons** from the summary text — no manual calls needed.
+- **Layer 1 — Storage:** cachly instance \`${inst.name}\` (${tier}) — persistent Valkey brain, survives restarts
+- **Layer 2 — Tools:** learn_from_attempts · recall_best_solution · smart_recall — the memory API
+- **Layer 3 — Autopilot (this file):** instructs the AI to run memory tools automatically
 
-### Rule 5 — Code Index Invalidation (AUTOMATIC)
-- \`index_project\` tracks MD5 hashes per file — **skips unchanged files automatically**
-- After code changes: next \`index_project\` run re-indexes only modified files
-- After delete/rename: run \`index_project\` again to sync
-- No manual invalidation needed
+## BEFORE every task — check memory first
 
----
+1. Call \`recall_best_solution\` with the task topic to get known solutions
+   - \`recall_best_solution("deploy:web")\` → returns working deploy command
+   - \`recall_best_solution("debug:redis-tls")\` → returns root cause + fix
+   - If a solution exists, use it — do NOT re-discover from scratch
 
-## Task-type trigger table
+2. Call \`recall_context\` with the area you're working in
+   - \`recall_context("arch:*")\` → cached architecture decisions
+   - \`recall_context("file:src/auth*")\` → cached file summaries
 
-| You're about to... | Call BEFORE | Call AFTER |
-|---|---|---|
-| Deploy anything | \`recall_best_solution("deploy:<component>")\` | \`learn_from_attempts(topic="deploy:...")\` |
-| Fix a bug | \`recall_best_solution("fix:<area>")\` | \`learn_from_attempts(topic="fix:...")\` |
-| Add a feature | \`session_start(focus="feat:<area>")\` | \`learn_from_attempts(topic="feat:...")\` |
-| Infra/server work | \`recall_best_solution("infra:<topic>")\` | \`learn_from_attempts(topic="infra:...")\` |
-| Debug an issue | \`smart_recall("<error message or symptom>")\` | \`learn_from_attempts(topic="debug:...")\` |
+${smartRecallNote}
+   - \`smart_recall("how does authentication work")\` → returns cached auth notes
 
----
+4. If nothing is found, proceed normally — then save (see below)
 
-## Available Brain Tools
+## AFTER every non-trivial task — save to memory
 
-| Tool | When to use |
-|------|-------------|
-| \`session_start\` | **FIRST** — mandatory at start of every session |
-| \`session_end\` | **LAST** — mandatory at end, auto-learns from summary |
-| \`session_handoff\` | When closing window with remaining tasks |
-| \`learn_from_attempts\` | **AUTOMATIC** after every fix/deploy/discovery |
-| \`recall_best_solution\` | Before any non-trivial task |
-| \`remember_context\` | After analyzing code — save findings for future sessions |
-${smartRecallNote ? `| \`smart_recall\` | Search brain by meaning/keywords |\n` : ''}\
-| \`recall_context\` | Get exact key (supports glob: \`arch:*\`, \`file:*\`) |
-| \`brain_search\` | BM25+ full-text search over all brain data |
-| \`auto_learn_session\` | Batch-learn from a list of observations (optional) |
-| \`index_project\` | Index source files (smart hash, skips unchanged files) |
-| \`list_remembered\` | See what's cached in the brain |
-| \`forget_context\` | Remove stale context |
+1. Call \`learn_from_attempts\` for deploy/debug/fix tasks:
+   - Always set outcome = "success" | "failure" | "partial"
+   - Always include what_failed — it prevents future wasted time
+   - Example: \`learn_from_attempts(topic="deploy:api", outcome="success", what_worked="nohup docker compose up -d --build", what_failed="direct docker compose hangs on SSH timeout")\`
 
----
+2. Call \`remember_context\` for code/architecture findings:
+   - \`remember_context("arch:auth", "Uses Keycloak with JWT...", category="architecture")\`
+   - \`remember_context("file:src/index.ts", "Entry point, registers routes...", category="file_summary")\`
 
 ## Instance Details
 
-- **Instance ID:** \`${instance_id}\`
-- **Instance name:** ${inst.name}
-- **Tier:** ${tier}
-- **${layerNote}**
-- **Embedding provider:** ${providerArg}
+- Instance ID: \`${instance_id}\`
+- Instance name: ${inst.name}
+- Tier: ${tier}
+- ${layerNote}
+- Embedding provider: ${providerArg}
 
----
-
-## How the 3-layer system works
+## Quick reference
 
 \`\`\`
-Layer 1 — Storage:  Your cachly Valkey instance (${inst.name}) — persists forever
-Layer 2 — Tools:    learn_from_attempts · recall_best_solution · brain_search · session_start/end
-Layer 3 — Autopilot: This file — AI reads it and runs tools automatically every session
+recall_best_solution("topic")        # before task
+smart_recall("natural language")     # find by meaning
+learn_from_attempts(...)             # after task
+remember_context("key", "content")   # save analysis
 \`\`\`
-
-Result: Your AI **never solves the same problem twice** and always picks up exactly where it left off. 🚀
 `;
 
-
       const lines: string[] = [
         `🧠 **cachly AI Memory Setup Complete**`,
         ``,
@@ -5056,8 +3724,8 @@ Result: Your AI **never solves the same problem twice** and always picks up exac
         `**Step 3 — copilot-instructions.md (Layer 3 Autopilot):**`,
         ``,
         ...(project_dir
-          ? [`🔍 Detecting IDEs in \`${project_dir}\`…`]
-          : [`Copy this to \`.github/copilot-instructions.md\` (Copilot), \`CLAUDE.md\` (Claude Code), or \`.cursor/rules\` (Cursor) in your project:`]),
+          ? [`Writing to \`${project_dir}/.github/copilot-instructions.md\`…`]
+          : [`Copy this to \`.github/copilot-instructions.md\` in your project:`]),
         ``,
         `\`\`\`markdown`,
         copilotInstructions,
@@ -5072,71 +3740,16 @@ Result: Your AI **never solves the same problem twice** and always picks up exac
         `Result: Your AI never solves the same problem twice. 🚀`,
       ];
 
-      // ── IDE auto-detection + file writing ────────────────────────────────
+      // Optionally write the file
       if (project_dir) {
-        const { mkdir, writeFile, access } = await import('node:fs/promises');
-        const { constants } = await import('node:fs');
-
-        const exists = async (p: string) => access(p, constants.F_OK).then(() => true).catch(() => false);
-
-        // Detect which IDEs are present based on marker files/dirs
-        interface IdeTarget { ide: string; path: string; content: string }
-        const targets: IdeTarget[] = [];
-
-        // GitHub Copilot — always write (universal fallback)
-        targets.push({
-          ide: 'GitHub Copilot',
-          path: join(project_dir, '.github', 'copilot-instructions.md'),
-          content: copilotInstructions,
-        });
-
-        // Claude Code — CLAUDE.md in project root
-        if (await exists(join(project_dir, 'CLAUDE.md')) || await exists(join(project_dir, '.claude'))) {
-          targets.push({
-            ide: 'Claude Code',
-            path: join(project_dir, 'CLAUDE.md'),
-            content: copilotInstructions,
-          });
-        }
-
-        // Cursor — .cursor/rules (new format) or .cursorrules (legacy)
-        if (
-          await exists(join(project_dir, '.cursor')) ||
-          await exists(join(project_dir, '.cursorrules'))
-        ) {
-          const cursorDir = join(project_dir, '.cursor');
-          await mkdir(cursorDir, { recursive: true });
-          targets.push({
-            ide: 'Cursor',
-            path: join(cursorDir, 'rules'),
-            content: copilotInstructions,
-          });
-        }
-
-        // Windsurf — .windsurfrules
-        if (
-          await exists(join(project_dir, '.windsurfrules')) ||
-          await exists(join(project_dir, '.windsurf'))
-        ) {
-          targets.push({
-            ide: 'Windsurf',
-            path: join(project_dir, '.windsurfrules'),
-            content: copilotInstructions,
-          });
-        }
-
-        // VS Code (Copilot) — already covered by .github/copilot-instructions.md above
-        // Continue.dev — .continue/config.json is JSON, not markdown — skip, copilot-instructions handles it
-
-        const written: string[] = [];
-        for (const target of targets) {
-          const dir = target.path.substring(0, target.path.lastIndexOf('/'));
-          await mkdir(dir, { recursive: true });
-          await writeFile(target.path, target.content, 'utf-8');
-          written.push(`✅ [${target.ide}] → \`${target.path.replace(project_dir, '.')}\``);
-        }
-
-        lines.push(...written);
+        const { mkdir, writeFile } = await import('node:fs/promises');
+        const githubDir = join(project_dir, '.github');
+        await mkdir(githubDir, { recursive: true });
+        const filePath = join(githubDir, 'copilot-instructions.md');
+        await writeFile(filePath, copilotInstructions, 'utf-8');
+        lines.splice(lines.indexOf(`Writing to \`${project_dir}/.github/copilot-instructions.md\`…`) + 1, 0,
+          `✅ Written to \`${project_dir}/.github/copilot-instructions.md\``
+        );
       }
 
       return lines.join('\n');
@@ -5264,178 +3877,6 @@ async function handleBulkLockStream(name: string, args: Record<string, unknown>)
       );
     }
 
-    // ── Roadmap ──────────────────────────────────────────────────────────────
-
-    case 'roadmap_add': {
-      const {
-        instance_id: rid,
-        title,
-        description: desc = '',
-        priority = 'medium',
-        tags: rtags = [],
-        milestone = '',
-      } = args as {
-        instance_id: string; title: string; description?: string;
-        priority?: string; tags?: string[]; milestone?: string;
-      };
-      const redis = await getConnection(rid);
-      const id = `rm_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 6)}`;
-      const item = {
-        id, title, description: desc, priority, tags: rtags, milestone,
-        status: 'planned',
-        created: new Date().toISOString(),
-        updated: new Date().toISOString(),
-        notes: '',
-      };
-      await redis.hset(`cachly:roadmap:${rid}`, id, JSON.stringify(item));
-      const PRIORITY_ICON: Record<string, string> = { critical: '🔴', high: '🟠', medium: '🟡', low: '🔵' };
-      return [
-        `📋 **Roadmap item added**`,
-        ``,
-        `  ID:       \`${id}\``,
-        `  Title:    ${title}`,
-        `  Priority: ${PRIORITY_ICON[priority] ?? '⚪'} ${priority}`,
-        `  Status:   planned`,
-        milestone ? `  Milestone: ${milestone}` : '',
-        rtags.length ? `  Tags:     ${rtags.join(', ')}` : '',
-        ``,
-        `💡 Use \`roadmap_update(id: "${id}", status: "in-progress")\` when you start working on it.`,
-      ].filter(Boolean).join('\n');
-    }
-
-    case 'roadmap_update': {
-      const {
-        instance_id: rid,
-        id: itemId,
-        status: newStatus,
-        priority: newPriority,
-        notes: newNotes,
-        title: newTitle,
-        description: newDesc,
-      } = args as {
-        instance_id: string; id: string; status?: string; priority?: string;
-        notes?: string; title?: string; description?: string;
-      };
-      const redis = await getConnection(rid);
-      const raw = await redis.hget(`cachly:roadmap:${rid}`, itemId);
-      if (!raw) return `⚠️ **roadmap_update** – Item \`${itemId}\` not found. Use \`roadmap_list\` to see all items.`;
-      const item = JSON.parse(raw) as Record<string, unknown>;
-      const oldStatus = item.status as string;
-      if (newStatus) item.status = newStatus;
-      if (newPriority) item.priority = newPriority;
-      if (newTitle) item.title = newTitle;
-      if (newDesc) item.description = newDesc;
-      if (newNotes) item.notes = item.notes ? `${item.notes}\n[${new Date().toISOString().slice(0, 10)}] ${newNotes}` : `[${new Date().toISOString().slice(0, 10)}] ${newNotes}`;
-      item.updated = new Date().toISOString();
-      await redis.hset(`cachly:roadmap:${rid}`, itemId, JSON.stringify(item));
-      const statusEmoji: Record<string, string> = { planned: '📋', 'in-progress': '⚡', done: '✅', blocked: '🚫', cancelled: '🗑️' };
-      return [
-        `${statusEmoji[newStatus ?? oldStatus] ?? '📋'} **Roadmap updated** \`${itemId}\``,
-        ``,
-        `  Title:  ${item.title}`,
-        oldStatus !== newStatus ? `  Status: ${oldStatus} → ${newStatus}` : `  Status: ${item.status}`,
-        newNotes ? `  Notes:  ${newNotes}` : '',
-      ].filter(Boolean).join('\n');
-    }
-
-    case 'roadmap_list': {
-      const {
-        instance_id: rid,
-        status: filterStatus = 'open',
-        tag: filterTag,
-        milestone: filterMilestone,
-        priority: filterPriority,
-      } = args as {
-        instance_id: string; status?: string; tag?: string;
-        milestone?: string; priority?: string;
-      };
-      const redis = await getConnection(rid);
-      const all = await redis.hgetall(`cachly:roadmap:${rid}`);
-      if (!all || Object.keys(all).length === 0) {
-        return '📋 **Roadmap is empty.**\n\nUse `roadmap_add` to create your first item.';
-      }
-      const PRIORITY_ORDER: Record<string, number> = { critical: 0, high: 1, medium: 2, low: 3 };
-      const PRIORITY_ICON: Record<string, string> = { critical: '🔴', high: '🟠', medium: '🟡', low: '🔵' };
-      const STATUS_ICON: Record<string, string> = { planned: '📋', 'in-progress': '⚡', done: '✅', blocked: '🚫', cancelled: '🗑️' };
-      const openStatuses = new Set(['planned', 'in-progress', 'blocked']);
-      let items = Object.values(all).map(v => JSON.parse(v as string) as Record<string, string | string[]>);
-      // Filter
-      if (filterStatus === 'open') items = items.filter(i => openStatuses.has(i.status as string));
-      else if (filterStatus) items = items.filter(i => i.status === filterStatus);
-      if (filterTag) items = items.filter(i => (i.tags as string[]).includes(filterTag));
-      if (filterMilestone) items = items.filter(i => i.milestone === filterMilestone);
-      if (filterPriority) items = items.filter(i => (PRIORITY_ORDER[i.priority as string] ?? 99) <= (PRIORITY_ORDER[filterPriority] ?? 99));
-      // Sort: priority asc, then created asc
-      items.sort((a, b) => {
-        const pa = PRIORITY_ORDER[a.priority as string] ?? 99;
-        const pb = PRIORITY_ORDER[b.priority as string] ?? 99;
-        return pa !== pb ? pa - pb : (a.created as string).localeCompare(b.created as string);
-      });
-      if (items.length === 0) return `📋 **No roadmap items** match the current filter (status: ${filterStatus}).`;
-      const grouped: Record<string, typeof items> = {};
-      for (const it of items) {
-        const st = it.status as string;
-        if (!grouped[st]) grouped[st] = [];
-        grouped[st].push(it);
-      }
-      const lines: string[] = [`📋 **Roadmap** (${items.length} item${items.length !== 1 ? 's' : ''})`, ''];
-      for (const [st, grp] of Object.entries(grouped)) {
-        lines.push(`**${STATUS_ICON[st] ?? '•'} ${st.toUpperCase()}** (${grp.length})`);
-        for (const it of grp) {
-          const tags = (it.tags as string[]).length ? ` [${(it.tags as string[]).join(', ')}]` : '';
-          const milestone = it.milestone ? ` · ${it.milestone}` : '';
-          lines.push(`  ${PRIORITY_ICON[it.priority as string] ?? '⚪'} \`${it.id}\` **${it.title}**${tags}${milestone}`);
-          if (it.description) lines.push(`      ${(it.description as string).slice(0, 120)}`);
-          if (it.notes) lines.push(`      📝 ${(it.notes as string).split('\n').pop()?.slice(0, 100)}`);
-        }
-        lines.push('');
-      }
-      lines.push(`💡 \`roadmap_update(id, status: "in-progress")\` to start · \`roadmap_next\` for top priority item`);
-      return lines.join('\n');
-    }
-
-    case 'roadmap_next': {
-      const { instance_id: rid, tag: filterTag } = args as { instance_id: string; tag?: string };
-      const redis = await getConnection(rid);
-      const all = await redis.hgetall(`cachly:roadmap:${rid}`);
-      if (!all || Object.keys(all).length === 0) {
-        return '📋 **Roadmap is empty.** Use `roadmap_add` to plan your first task.';
-      }
-      const PRIORITY_ORDER: Record<string, number> = { critical: 0, high: 1, medium: 2, low: 3 };
-      const PRIORITY_ICON: Record<string, string> = { critical: '🔴', high: '🟠', medium: '🟡', low: '🔵' };
-      let items = Object.values(all)
-        .map(v => JSON.parse(v as string) as Record<string, unknown>)
-        .filter(i => i.status === 'in-progress' || i.status === 'planned')
-        .filter(i => !filterTag || (i.tags as string[]).includes(filterTag));
-      if (items.length === 0) return '🎉 **No open roadmap items!** All tasks are done (or use `roadmap_list` to check).';
-      // in-progress first, then by priority
-      items.sort((a, b) => {
-        if (a.status === 'in-progress' && b.status !== 'in-progress') return -1;
-        if (b.status === 'in-progress' && a.status !== 'in-progress') return 1;
-        return (PRIORITY_ORDER[a.priority as string] ?? 99) - (PRIORITY_ORDER[b.priority as string] ?? 99);
-      });
-      const next = items[0];
-      const remaining = items.length - 1;
-      const tags = (next.tags as string[]).length ? `\nTags:      ${(next.tags as string[]).join(', ')}` : '';
-      const milestone = next.milestone ? `\nMilestone: ${next.milestone}` : '';
-      const notes = next.notes ? `\nNotes:     ${(next.notes as string).split('\n').pop()?.slice(0, 120)}` : '';
-      return [
-        `${next.status === 'in-progress' ? '⚡' : '📋'} **Next up: ${next.title}**`,
-        ``,
-        `ID:        \`${next.id}\``,
-        `Priority:  ${PRIORITY_ICON[next.priority as string] ?? '⚪'} ${next.priority}`,
-        `Status:    ${next.status}`,
-        next.description ? `\nWhat to do:\n${next.description}` : '',
-        tags, milestone, notes,
-        ``,
-        remaining > 0 ? `(+${remaining} more open item${remaining !== 1 ? 's' : ''} in roadmap)` : '(last open item)',
-        ``,
-        next.status === 'planned'
-          ? `💡 Start with: \`roadmap_update(id: "${next.id}", status: "in-progress")\``
-          : `💡 Finish with: \`roadmap_update(id: "${next.id}", status: "done", notes: "...")\``,
-      ].filter(s => s !== undefined).join('\n');
-    }
-
     default:
       return null;
   }
@@ -5444,81 +3885,14 @@ async function handleBulkLockStream(name: string, args: Record<string, unknown>)
 // ── Server setup ──────────────────────────────────────────────────────────────
 
 const server = new Server(
-  { name: 'cachly-mcp', version: CURRENT_VERSION },
+  { name: 'cachly-mcp', version: '0.4.0' },
   { capabilities: { tools: {} } }
 );
 
 server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
 
-// ── Auto-session management ───────────────────────────────────────────────────
-// Transparently starts a Brain session on the first tool call of a process
-// and saves a session_end summary on SIGTERM/exit so users never have to call
-// session_start/session_end manually.
-
-let _autoSessionInstanceId: string | null = null;
-let _autoSessionStarted = false;
-let _autoSessionToolCount = 0;
-
-async function autoStartSession(instanceId: string): Promise<void> {
-  if (_autoSessionStarted) return;
-  _autoSessionStarted = true;
-  _autoSessionInstanceId = instanceId;
-  try {
-    await handleTool('session_start', { instance_id: instanceId, focus: 'auto (MCP session)' });
-  } catch { /* non-fatal — session tracking is a best-effort feature */ }
-
-  // Auto-index the project if it hasn't been indexed in the last 24h.
-  // This is the main lever for growing token savings: more indexed code →
-  // more semantic cache hits → fewer LLM calls for repeated questions.
-  if (process.env.CACHLY_AUTO_INDEX !== 'false') {
-    try {
-      const redis = await getConnection(instanceId);
-      const lastIndexed = await redis.get(`cachly:index:last_indexed:${instanceId}`);
-      const staleMs = 24 * 60 * 60 * 1000;
-      const isStale = !lastIndexed || (Date.now() - parseInt(lastIndexed, 10)) > staleMs;
-      if (isStale) {
-        // Mark as indexing now to prevent concurrent re-runs.
-        await redis.set(`cachly:index:last_indexed:${instanceId}`, String(Date.now()), 'EX', 90000);
-        // Run in background — don't block the first tool call.
-        handleTool('index_project', {
-          instance_id: instanceId,
-          dir: process.cwd(),
-          max_files: 150,
-          ttl: 86400 * 7, // cache for 7 days
-          namespace: 'cachly:sem:code',
-        }).catch(() => undefined);
-      }
-    } catch { /* never block the session on indexing errors */ }
-  }
-}
-
-async function autoEndSession(): Promise<void> {
-  if (!_autoSessionStarted || !_autoSessionInstanceId) return;
-  _autoSessionStarted = false;
-  try {
-    await handleTool('session_end', {
-      instance_id: _autoSessionInstanceId,
-      summary: `Auto-ended after ${_autoSessionToolCount} tool call(s). Session was started automatically.`,
-      files_changed: [],
-      lessons_learned: 0,
-    });
-  } catch { /* non-fatal */ }
-}
-
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
   const { name, arguments: args } = request.params;
-
-  // Auto-start brain session on first tool call that has an instance_id.
-  // Skip session management tools to avoid recursion.
-  const sessionTools = new Set(['session_start', 'session_end', 'auto_learn_session']);
-  if (!sessionTools.has(name) && !_autoSessionStarted) {
-    const instanceId = (args as Record<string, unknown>)?.instance_id as string | undefined;
-    if (instanceId) {
-      await autoStartSession(instanceId).catch(() => undefined);
-    }
-  }
-  if (!sessionTools.has(name)) _autoSessionToolCount++;
-
   try {
     const text = await handleTool(name, (args ?? {}) as Record<string, unknown>);
     return { content: [{ type: 'text', text }] };
@@ -5528,15 +3902,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   }
 });
 
-// Graceful shutdown – close all Redis connections + auto-end brain session
+// Graceful shutdown – close all Redis connections
 process.on('SIGTERM', async () => {
-  await autoEndSession().catch(() => undefined);
-  for (const [, client] of pool) await client.quit().catch(() => undefined);
-  process.exit(0);
-});
-
-process.on('SIGINT', async () => {
-  await autoEndSession().catch(() => undefined);
   for (const [, client] of pool) await client.quit().catch(() => undefined);
   process.exit(0);
 });
@@ -5557,8 +3924,6 @@ const EDITOR_FILES: Record<string, string> = {
   windsurf: '.windsurf/mcp.json',
   copilot:  '.vscode/mcp.json',
   continue: '.continue/config.json',
-  cline:    '.vscode/mcp.json',              // Cline respects VS Code project MCP config
-  zed:      '.zed/settings.json',            // Zed project-level context_servers
 };
 
 const CLAUDE_MD_MARKER_START = '<!-- cachly-brain-start -->';
@@ -5575,20 +3940,6 @@ function buildMcpConfig(apiKey: string, instanceId: string, editor: string): str
       },
     }, null, 2);
   }
-  if (editor === 'zed') {
-    return JSON.stringify({
-      context_servers: {
-        cachly: {
-          command: {
-            path: 'npx',
-            args: ['-y', '@cachly-dev/mcp-server@latest'],
-            env: { CACHLY_API_URL: 'https://api.cachly.dev', CACHLY_JWT: apiKey, CACHLY_BRAIN_INSTANCE_ID: instanceId },
-          },
-          settings: {},
-        },
-      },
-    }, null, 2);
-  }
   return JSON.stringify({
     mcpServers: {
       cachly: {
@@ -5602,54 +3953,48 @@ function buildMcpConfig(apiKey: string, instanceId: string, editor: string): str
 
 function buildClaudeMdBlock(instanceId: string): string {
   return `${CLAUDE_MD_MARKER_START}
-## Cachly AI Brain
+## Cachly AI Brain — Persistent Memory
 
-The Cachly MCP server is available as tool \`cachly\`.
-Your instance ID: \`${instanceId}\`
+Your AI Brain instance ID: \`${instanceId}\`
 
-> **Sessions are fully automatic** (MCP ≥ 0.5.3).
-> The Brain starts tracking when you call any tool for the first time and saves a summary when your editor closes. You never need to call \`session_start\` or \`session_end\` manually.
+> The Brain gives you persistent memory across sessions. Every lesson you learn,
+> every bug you fix, every architecture decision — recalled instantly next time.
+> instance_id is pre-filled below. Do NOT ask the user for it.
 
----
+### MANDATORY: Call at the START of every session
+\`\`\`
+session_start(instance_id="${instanceId}", focus="<what you're working on today>")
+\`\`\`
+This loads your previous context, recent lessons, and open tasks automatically.
 
-### Before editing any file — WIP-registry (prevents half-finished code across sessions):
+### MANDATORY: Call at the END of every session
 \`\`\`
-remember_context(
-  instance_id = "${instanceId}",
-  key         = "wip-registry",
-  content     = "EDITING: <file:line> — goal: <what you are implementing>",
-  category    = "bug",
-  ttl         = 86400,
-)
+session_end(instance_id="${instanceId}", summary="<2-3 sentences on what was done>", files_changed=["src/..."], lessons_learned=1)
 \`\`\`
-After the edit is complete, update \`content\` to \`"DONE: <file> — <what was completed>"\`.
 
-### After fixing any bug or solving a tricky problem:
+### After fixing ANY bug or solving a hard problem
 \`\`\`
 learn_from_attempts(
-  instance_id = "${instanceId}",
-  topic       = "category:keyword",
-  outcome     = "success",
-  what_worked = "...",
-  what_failed = "...",
-  severity    = "critical" | "major" | "minor",
-  file_paths  = ["path/to/file"],
-  commands    = ["the command that worked"],
-  tags        = ["tag1"],
+  instance_id="${instanceId}",
+  topic="category:keyword",   # e.g. "deploy:web", "bug:redis-timeout", "arch:auth"
+  outcome="success",
+  what_worked="exact solution",
+  what_failed="what didn't work (optional)",
+  commands=["the command that worked"],
+  file_paths=["relevant/file.ts"],
+  severity="critical"|"major"|"minor",
 )
 \`\`\`
 
-### Before starting any task — recall relevant lessons first:
+### Before starting any non-trivial task
 \`\`\`
-smart_recall(
-  instance_id = "${instanceId}",
-  query       = "<describe what you are about to do>",
-)
+recall_best_solution(instance_id="${instanceId}", topic="relevant:topic")
 \`\`\`
 
-### Half-finished code rule:
-Never commit code that does not compile. Run \`tsc --noEmit\` / \`go build ./...\` before every commit.
-If a session ends mid-task, save the WIP-registry entry so the next session picks up exactly where you left off.
+### If a stored lesson is wrong
+\`\`\`
+forget_lesson(instance_id="${instanceId}", topic="wrong:topic")
+\`\`\`
 ${CLAUDE_MD_MARKER_END}`;
 }
 
@@ -5740,9 +4085,8 @@ 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');
+    console.log('Step 1: Sign in to cachly (free — no credit card required)\n');
 
-    // Start device flow
     let deviceCode = '', userCode = '', verifyUri = '', pollInterval = 5000;
     try {
       const deviceRes = await fetch(`${AUTH_BASE}/auth/device`, {
@@ -5750,91 +4094,92 @@ if (process.argv[2] === 'setup') {
         headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
         body: `client_id=${CLIENT_ID}&scope=openid`,
       });
-      if (!deviceRes.ok) throw new Error(`Device flow error: HTTP ${deviceRes.status}`);
+      if (!deviceRes.ok) throw new Error(`HTTP ${deviceRes.status}`);
       const data = await deviceRes.json() as {
         device_code: string; user_code: string;
         verification_uri_complete: string; interval: number;
       };
-      deviceCode    = data.device_code;
-      userCode      = data.user_code;
-      verifyUri     = data.verification_uri_complete;
-      pollInterval  = (data.interval ?? 5) * 1000;
+      deviceCode   = data.device_code;
+      userCode     = data.user_code;
+      verifyUri    = data.verification_uri_complete;
+      pollInterval = (data.interval ?? 5) * 1000;
     } catch (e) {
-      console.error(`\nFailed to start device flow: ${(e as Error).message}`);
-      console.error('Falling back: sign in at https://cachly.dev/setup-ai and paste your API token.\n');
+      console.error(`\nCould not reach auth service: ${(e as Error).message}`);
+      console.error('Fallback: sign in at https://cachly.dev 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); }
-      console.log('');
-      deviceCode = ''; // mark as fallback so we skip polling
+      if (!token) { console.error('\nToken required. Aborting.\n'); rl.close(); process.exit(1); }
+      deviceCode = '';
     }
 
-    if (deviceCode!) {
-      // Open browser
-      console.log(`   Code: \x1b[1;33m${userCode!}\x1b[0m`);
-      console.log(`   URL:  ${verifyUri!}\n`);
+    if (deviceCode) {
+      console.log(`   Code: \x1b[1;33m${userCode}\x1b[0m`);
+      console.log(`   URL:  ${verifyUri}\n`);
       try {
         const { execSync } = await import('node:child_process');
         const openCmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
-        execSync(`${openCmd} "${verifyUri!}"`, { stdio: 'ignore' });
+        execSync(`${openCmd} "${verifyUri}"`, { stdio: 'ignore' });
         console.log('   ✓  Browser opened — confirm the code above to continue...\n');
       } catch {
-        console.log('   👉  Open the URL above in your browser and enter the code.\n');
+        console.log('   👉  Open the URL above in your browser and confirm the code.\n');
       }
 
-      // Poll for token
       process.stdout.write('   Waiting for authorization');
-      const deadline = Date.now() + 10 * 60 * 1000; // 10 min
+      const deadline = Date.now() + 10 * 60 * 1000;
       while (Date.now() < deadline) {
-        await new Promise(r => setTimeout(r, pollInterval!));
+        await new Promise(r => setTimeout(r, pollInterval));
         process.stdout.write('.');
         try {
           const tokenRes = await fetch(`${AUTH_BASE}/token`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-            body: `client_id=${CLIENT_ID}&grant_type=urn:ietf:params:oauth:grant-type:device_code&device_code=${deviceCode!}`,
+            body: `client_id=${CLIENT_ID}&grant_type=urn:ietf:params:oauth:grant-type:device_code&device_code=${deviceCode}`,
           });
-          const tokenData = await tokenRes.json() as { access_token?: string; error?: string };
-          if (tokenData.access_token) {
-            token = tokenData.access_token;
+          const td = await tokenRes.json() as { access_token?: string; error?: string };
+          if (td.access_token) {
+            token = td.access_token;
             console.log(' \x1b[32m✓ Authorized!\x1b[0m\n');
             break;
           }
-          // authorization_pending = keep polling; slow_down = increase interval
-          if (tokenData.error === 'slow_down') pollInterval = Math.min(pollInterval! + 2000, 15000);
-          else if (tokenData.error && tokenData.error !== 'authorization_pending') {
-            console.error(`\nAuth error: ${tokenData.error}. Aborting.\n`);
+          if (td.error === 'slow_down') pollInterval = Math.min(pollInterval + 2000, 15000);
+          else if (td.error && td.error !== 'authorization_pending') {
+            console.error(`\nAuth error: ${td.error}. Aborting.\n`);
             rl.close(); process.exit(1);
           }
         } catch { /* network hiccup — keep polling */ }
       }
-      if (!token) { console.error('\nTimed out waiting for authorization. Aborting.\n'); rl.close(); process.exit(1); }
-      console.log('');
+      if (!token) { console.error('\nTimed out. Aborting.\n'); rl.close(); process.exit(1); }
     }
-  }
 
-  // ── Step 1b: Exchange Keycloak JWT → long-lived cky_live_ API key ──────────
-  // Only do this when the token looks like a Keycloak JWT (starts with "eyJ"),
-  // not when the user already pasted a cky_live_ key directly.
-  if (token.startsWith('eyJ')) {
-    process.stdout.write('⏳ Generating your API key...');
-    try {
-      const keyRes = await fetch(`${API_URL}/api/v1/api-keys`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` },
-        body: JSON.stringify({ name: 'cachly-mcp-setup', scope: 'read_write' }),
-      });
-      if (!keyRes.ok) throw new Error(`HTTP ${keyRes.status}`);
-      const keyBody = await keyRes.json() as { key: string };
-      if (!keyBody.key) throw new Error('no key in response');
-      token = keyBody.key; // swap JWT → cky_live_...
-      console.log(' ✓\n');
-    } catch (e) {
-      console.log(' (skipped)\n');
-      // Non-fatal: fall back to using the Keycloak JWT directly.
-      // It will expire but setup still works for now.
+    // Exchange short-lived Keycloak JWT → long-lived cky_live_ API key
+    if (token.startsWith('eyJ')) {
+      process.stdout.write('⏳ Generating your API key...');
+      try {
+        const keyRes = await fetch(`${API_URL}/api/v1/api-keys`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` },
+          body: JSON.stringify({ name: 'cachly-mcp-setup', scope: 'read_write' }),
+        });
+        if (!keyRes.ok) throw new Error(`HTTP ${keyRes.status}`);
+        const keyBody = await keyRes.json() as { key?: string };
+        if (keyBody.key) { token = keyBody.key; console.log(' ✓\n'); }
+        else throw new Error('no key in response');
+      } catch (e) {
+        console.log(` (skipped — JWT will be used directly)\n`);
+      }
     }
   }
 
+  // ── Step 1b: Auto-provision a Brain instance if none exist ─────────────────
+  // POST /api/v1/instances/auto is idempotent — returns existing or creates free Brain
+  let autoProvisioned = false;
+  try {
+    const autoRes = await fetch(`${API_URL}/api/v1/instances/auto`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` },
+    });
+    if (autoRes.ok) autoProvisioned = true;
+  } catch { /* non-fatal */ }
+
   // ── Step 2: Fetch & pick instance ─────────────────────────────────────────
   process.stdout.write('⏳ Fetching your instances...');
   let instances: Array<{ id: string; name: string; status: string; tier: string; region: string }> = [];
@@ -5846,62 +4191,31 @@ if (process.argv[2] === 'setup') {
     const body = await res.json() as { data: typeof instances };
     instances = (body.data ?? []).filter(i => i.status === 'running');
   } catch (e) {
-    const msg = (e as Error).message;
-    console.error(`\n\nFailed to fetch instances: ${msg}`);
-    if (msg.includes('401')) {
-      console.error('Token rejected. Get a valid token at https://cachly.dev/setup-ai\n');
-      try {
-        const { execSync } = await import('node:child_process');
-        const openCmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
-        execSync(`${openCmd} https://cachly.dev/setup-ai`, { stdio: 'ignore' });
-      } catch { /* ignore */ }
-    }
+    console.error(`\n\nFailed to fetch instances: ${(e as Error).message}`);
+    console.error('Check your token and try again.\n');
     rl.close(); process.exit(1);
   }
   console.log(` found ${instances.length}\n`);
 
   if (instances.length === 0) {
-    // Auto-provision a free Brain instance so users don't have to visit the website.
-    process.stdout.write('⏳ Creating your free Brain instance...');
-    try {
-      const autoRes = await fetch(`${API_URL}/api/v1/instances/auto`, {
-        method: 'POST',
-        headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
-      });
-      if (!autoRes.ok) throw new Error(`HTTP ${autoRes.status}`);
-      const autoBody = await autoRes.json() as { instance?: { id: string; name: string; status: string; tier: string; region: string }; instance_id?: string; status?: string; created?: boolean };
-      if (autoBody.instance) {
-        // Returned an existing instance.
-        instances = [autoBody.instance];
-      } else if (autoBody.instance_id) {
-        // Newly created — poll until running or give up after 30 s.
-        const newId = autoBody.instance_id;
-        console.log(` ✓ created (${newId.slice(0, 8)}…)\n`);
-        process.stdout.write('⏳ Waiting for instance to start');
-        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}` } });
-            if (checkRes.ok) {
-              const inst = await checkRes.json() as { id: string; name: string; status: string; tier: string; region: string };
-              if (inst.status === 'running') { instances = [inst]; break; }
-            }
-          } catch { /* keep polling */ }
-        }
-        console.log('');
+    if (autoProvisioned) {
+      // Poll up to 10× every 3s (30s total) waiting for the Brain to start
+      process.stdout.write(' waiting for Brain to start');
+      for (let attempt = 0; attempt < 10 && instances.length === 0; attempt++) {
+        await new Promise(r => setTimeout(r, 3000));
+        process.stdout.write('.');
+        try {
+          const retry = await fetch(`${API_URL}/api/v1/instances`, { headers: { Authorization: `Bearer ${token}` } });
+          if (retry.ok) {
+            const b = await retry.json() as { data: typeof instances };
+            instances = (b.data ?? []).filter(i => i.status === 'running');
+          }
+        } catch { /* ignore */ }
       }
-    } catch (e) {
-      console.log(` failed: ${(e as Error).message}\n`);
+      process.stdout.write(instances.length > 0 ? ' ready!\n' : '\n');
     }
-
     if (instances.length === 0) {
-      console.error('\nCould not create an instance automatically. Opening https://cachly.dev/instances …\n');
-      try {
-        const { execSync } = await import('node:child_process');
-        const openCmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
-        execSync(`${openCmd} https://cachly.dev/instances`, { stdio: 'ignore' });
-      } catch { /* ignore */ }
+      console.error('\nBrain provisioning is taking longer than expected. Run setup again in a minute.\n');
       rl.close(); process.exit(1);
     }
   }
@@ -5921,28 +4235,15 @@ if (process.argv[2] === 'setup') {
   // ── Step 3: Detect editors ────────────────────────────────────────────────
   const cwd = process.cwd();
   const detected: string[] = [];
-  const { homedir } = await import('node:os');
-  const home = homedir();
   // Claude Code: always include (CLAUDE.md is universal)
   detected.push('claude');
   if (existsSync(resolve(cwd, '.cursor')))   detected.push('cursor');
   if (existsSync(resolve(cwd, '.windsurf'))) detected.push('windsurf');
   if (existsSync(resolve(cwd, '.vscode')))   detected.push('copilot');
   if (existsSync(resolve(cwd, '.continue'))) detected.push('continue');
-  // Cline: VS Code extension — detect via globalStorage on the machine
-  const clineGlobalDir = process.platform === 'darwin'
-    ? resolve(home, 'Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev')
-    : resolve(home, '.vscode/extensions');
-  if (existsSync(clineGlobalDir) && !detected.includes('copilot')) detected.push('cline');
-  else if (existsSync(clineGlobalDir)) detected.push('cline'); // both copilot + cline share .vscode/mcp.json — fine
-  // Zed editor — detect via app data dir
-  const zedDir = process.platform === 'darwin'
-    ? resolve(home, 'Library/Application Support/Zed')
-    : resolve(home, '.config/zed');
-  if (existsSync(zedDir)) detected.push('zed');
 
   const editorLabel = (e: string) =>
-    ({ claude: 'Claude Code', cursor: 'Cursor', windsurf: 'Windsurf', copilot: 'GitHub Copilot', continue: 'Continue.dev', cline: 'Cline (VSCode)', zed: 'Zed' })[e] ?? e;
+    ({ claude: 'Claude Code', cursor: 'Cursor', windsurf: 'Windsurf', copilot: 'GitHub Copilot', continue: 'Continue.dev' })[e] ?? e;
 
   console.log(`Step 3: Detected editors: ${detected.map(editorLabel).join(', ')}`);
   const editorsRaw = await ask(`   Configure for which? [all / ${detected.join('/')}] (Enter = all): `);
@@ -5951,21 +4252,7 @@ if (process.argv[2] === 'setup') {
     : editorsRaw.split(/[,\s]+/).map(s => s.toLowerCase()).filter(s => EDITOR_FILES[s]);
   console.log('');
 
-  // ── Step 4: Email opt-in ──────────────────────────────────────────────────
-  console.log('Step 4: Stay in the loop (optional)');
-  const email = await ask('   Email for release notes & tips? [Enter to skip]: ');
-  if (email && email.includes('@')) {
-    try {
-      await fetch(`${API_URL}/api/newsletter/subscribe`, {
-        method: 'POST', headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ email: email.trim().toLowerCase(), source: 'mcp-setup' }),
-        signal: AbortSignal.timeout(5000),
-      });
-      console.log('✅ Subscribed — you\'ll only hear from us when it matters.\n');
-    } catch { console.log('⚠️  Could not subscribe (no internet?). Continuing...\n'); }
-  } else { console.log('   Skipped.\n'); }
-
-  // ── Step 5: Write editor configs ──────────────────────────────────────────
+  // ── Step 4: Write editor configs ──────────────────────────────────────────
   for (const editor of editorsToSetup) {
     const configFile = EDITOR_FILES[editor] ?? '.mcp.json';
     const configPath = resolve(cwd, configFile);
@@ -5974,7 +4261,7 @@ if (process.argv[2] === 'setup') {
     console.log(`✅ Written: ${configFile}`);
   }
 
-  // ── Step 6: CLAUDE.md (always — idempotent) ───────────────────────────────
+  // ── Step 5: CLAUDE.md (always — idempotent) ───────────────────────────────
   const mdResult = await writeClaudeMd(cwd, instance.id);
   const mdLabel = mdResult === 'updated' ? '✅ Updated' : mdResult === 'appended' ? '✅ Appended to' : '✅ Written';
   console.log(`${mdLabel}: CLAUDE.md`);
@@ -5982,172 +4269,11 @@ if (process.argv[2] === 'setup') {
   rl.close();
   console.log(`\n🧠  Done! Restart your editor — the \`cachly\` MCP tools will appear.`);
   console.log(`    Your AI now has persistent memory across every session.\n`);
-
-  // ── Step 7: Show first session_start preview (Aha moment) ────────────────
-  // Fetch brain health from the API to show the user what their agent will see.
-  process.stdout.write('\n⏳ Fetching your Brain health preview...');
-  try {
-    const brainRes = await fetch(`${API_URL}/api/v1/instances/${instance.id}/brain/stats`, {
-      headers: { Authorization: `Bearer ${token}` },
-      signal: AbortSignal.timeout(6000),
-    });
-    if (brainRes.ok) {
-      const brainData = await brainRes.json() as {
-        lesson_count?: number; context_count?: number;
-        open_failures?: number; quality_score?: number;
-      };
-      const lessons = brainData.lesson_count ?? 0;
-      const contexts = brainData.context_count ?? 0;
-      const score = brainData.quality_score ?? 0;
-      const level = lessons === 0 ? 'Intern 🌱' :
-        lessons < 10  ? 'Junior Dev 🔧' :
-        lessons < 30  ? 'Mid Dev ⚡' :
-        lessons < 60  ? 'Senior Dev 🧠' :
-        lessons < 100 ? 'Staff Eng 🚀' : 'Principal Eng 🏆';
-      console.log(' ✓\n');
-      console.log('┌──────────────────────────────────────────────────────┐');
-      console.log(`│  🧠  Brain Health Report                            │`);
-      console.log('├──────────────────────────────────────────────────────┤');
-      console.log(`│  Lessons stored    : ${String(lessons).padEnd(6)} │  Level: ${level.padEnd(20)}│`);
-      console.log(`│  Context entries   : ${String(contexts).padEnd(6)} │  Quality score: ${String(Math.round(score * 100)).padEnd(3)}%       │`);
-      if (lessons === 0) {
-        console.log('├──────────────────────────────────────────────────────┤');
-        console.log('│  Your Brain is empty and ready to learn.            │');
-        console.log('│  After your first coding session it will contain:   │');
-        console.log('│    • Lessons from every bug you fixed               │');
-        console.log('│    • Your project\'s indexed files                   │');
-        console.log('│    • A session summary for next time                │');
-      }
-      console.log('└──────────────────────────────────────────────────────┘');
-    } else {
-      console.log(' (skipped)');
-    }
-  } catch { console.log(' (skipped)'); }
-
-  console.log(`\n   Your AI will call session_start automatically when it uses the first tool.`);
-  console.log(`   To see your Brain at any time: https://cachly.dev/instances/${instance.id}\n`);
-  process.exit(0);
-}
-
-// ── CLI: cachly index <dir> ───────────────────────────────────────────────────
-// Usage: npx @cachly-dev/mcp-server@latest index [./path/to/project]
-// Indexes the project directory into the Brain — perfect for CI/CD cron jobs.
-
-if (process.argv[2] === 'index') {
-  const { resolve } = await import('node:path');
-  const argv = process.argv.slice(3);
-  const flag = (name: string) => { const i = argv.indexOf(`--${name}`); return i !== -1 ? argv[i + 1] : undefined; };
-
-  const dir        = resolve(flag('dir') ?? argv.find(a => !a.startsWith('--')) ?? '.');
-  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) {
-    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_...>');
-    console.error('   npx @cachly-dev/mcp-server@latest index ./my-project\n');
-    process.exit(1);
-  }
-
-  console.log(`\n📂  Indexing: ${dir}`);
-  console.log(`    Instance: ${instanceId.slice(0, 8)}…  Max files: ${maxFiles}\n`);
-
-  try {
-    const result = await handleTool('index_project', {
-      instance_id: instanceId,
-      dir,
-      max_files: maxFiles,
-      ttl: 86400 * 7,
-      namespace,
-    });
-    console.log(result);
-    console.log('\n✅  Indexing complete.\n');
-  } catch (err) {
-    console.error(`\n❌  Indexing failed: ${(err as Error).message}\n`);
-    process.exit(1);
-  }
   process.exit(0);
 }
 
 // ── Start ─────────────────────────────────────────────────────────────────────
 
-// Warn on stderr when credentials are missing so the user sees a clear
-// actionable message in their editor's MCP log instead of silent failures.
-if (!JWT) {
-  process.stderr.write(
-    '\n' +
-    '╔══════════════════════════════════════════════════════════════════╗\n' +
-    '║  🧠  cachly AI Brain — Setup required                           ║\n' +
-    '╠══════════════════════════════════════════════════════════════════╣\n' +
-    '║                                                                  ║\n' +
-    '║  CACHLY_JWT is not set. Get your free credentials at:           ║\n' +
-    '║                                                                  ║\n' +
-    '║    👉  https://cachly.dev/setup-ai                              ║\n' +
-    '║                                                                  ║\n' +
-    '║  Then run the interactive setup wizard:                         ║\n' +
-    '║                                                                  ║\n' +
-    '║    npx @cachly-dev/mcp-server@latest setup                      ║\n' +
-    '║                                                                  ║\n' +
-    '║  Free tier — no credit card required.                           ║\n' +
-    '╚══════════════════════════════════════════════════════════════════╝\n' +
-    '\n',
-  );
-}
-
-// ── Update nudge (non-blocking, fire-and-forget) ─────────────────────────────
-// Check npm registry once per process start; if outdated, log to stderr so
-// the editor's MCP log shows an actionable one-liner. Skipped if opted out.
-if (!process.env.CACHLY_NO_UPDATE_CHECK) {
-  (async () => {
-    try {
-      const res = await fetch(
-        `https://registry.npmjs.org/@cachly-dev/mcp-server/latest`,
-        { signal: AbortSignal.timeout(4000) },
-      );
-      if (res.ok) {
-        const data = await res.json() as { version: string };
-        const latest = data?.version ?? '';
-        if (latest && latest !== CURRENT_VERSION) {
-          process.stderr.write(
-            `\n⚡ cachly update available: ${CURRENT_VERSION} → ${latest}\n` +
-            `   Run: npx @cachly-dev/mcp-server@latest setup\n\n`,
-          );
-        }
-      }
-    } catch { /* ignore – network unavailable or timeout */ }
-  })();
-}
-
-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
-  const { createServer } = await import('node:http');
-  const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
-  await server.connect(transport);
-  const httpServer = createServer((req, res) => {
-    const url = new URL(req.url ?? '/', `http://localhost:${httpPort}`);
-    if (url.pathname === '/health') {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ status: 'ok', version: CURRENT_VERSION }));
-      return;
-    }
-    if (url.pathname === '/mcp' || url.pathname === '/') {
-      transport.handleRequest(req, res);
-      return;
-    }
-    res.writeHead(404);
-    res.end('not found');
-  });
-  httpServer.listen(httpPort, () => {
-    process.stderr.write(`cachly-mcp HTTP server listening on :${httpPort}\n`);
-  });
-} else {
-  // ── stdio mode (default for local editor use) ───────────────────────────
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-}
+const transport = new StdioServerTransport();
+await server.connect(transport);