@cachly-dev/mcp-server 0.10.49 → 0.10.56

package/src/handlers/brain.ts

@@ -6,24 +6,68 @@ import { ckgSlug, extractProblemConcept, ckgUpsertNode, ckgUpdateEdge } from '..
 import { safeJsonParse } from '../utils.js';
 import type { CKGEdge, CKGNode } from '../ckg.js';
 import { keywordSearch, tokenize, splitMultiQuery, levenshtein,
-         ZERO_RESULTS_LOG, zeroResultsTotal, indexVocab as _indexVocab } from '../search.js';
+         indexVocab as _indexVocab } from '../search.js';
 import type { KeywordMatch } from '../search.js';
-import { computeEmbedding, hasEmbedProvider, embedProviderHint, EMBED_PROVIDER } from '../embeddings.js';
-import { detectNamespace } from '../namespace.js';
+import { computeEmbedding, hasEmbedProvider } from '../embeddings.js';
 
 // ── Changelog (shown once per version in session_start) ──────────────────────
-const MCP_VERSION = '0.10.49';
+const MCP_VERSION = '0.10.56';
 const WHATS_NEW: Record<string, string[]> = {
-  '0.10.49': [
-    `🆕 **What's new in v${MCP_VERSION}:**`,
-    `  ✅ \`brain_from_git\` — auto-seed your Brain from git history in seconds`,
-    `  ✅ \`brain_predict_failures\` — predict CI/build failures before they happen`,
-    `  ✅ \`smart_recall\` — semantic + keyword hybrid recall, now in every CLAUDE.md`,
-    `  ✅ VS Code extension — Brain status bar, ambient learning, CodeLens hints`,
-    `  ✅ Team Brain — share lessons across your whole engineering team`,
-    `  ✅ 89 MCP tools — roadmap, A/B tests, cache, index, predict, syndicate`,
-    `  🔧 Stability — auto-expiring memory keys, longer provisioning wait, robust recall`,
-    `  💡 Run \`brain_from_git\` to seed your Brain from existing commits instantly`,
+  '0.10.56': [
+    `🆕 **What's new in cachly MCP v0.10.56:**`,
+    `  🎉 session_start now shows a "🎉 Your Brain bootstrapped from X commits" wow moment on second session`,
+    `  📣 Setup flow now surfaces a teammate invite nudge — helps you loop in your team`,
+    `  📝 Smithery listing rewritten: clearer value prop, better first-impression`,
+  ],
+  '0.10.55': [
+    `🆕 **What's new in cachly MCP v0.10.55:**`,
+    `  ⚡ UX: API failure now shows a clear error instead of silently blocking for 30s`,
+    `  ⚡ UX: provisioning wait reduced from 25s → 8s (Brain is usually ready sooner)`,
+    `  🔧 VS Code: setup spinner is now cancellable — dismiss and MCP auto-connects later`,
+    `  🧠 VS Code: Brain Health panel shows offline-queued lessons with pending sync count`,
+  ],
+  '0.10.54': [
+    `🆕 **What's new in cachly MCP v${MCP_VERSION}:**`,
+    `  👀 Perf: first tool call no longer blocked by auto-session (was freezing for 30-120s on large repos)`,
+    `  👀 Perf: git history bootstrap runs in background — session_start responds instantly`,
+    `  🐞 Fixed: VS Code lessons now include author attribution (broken since launch)`,
+  ],
+  '0.10.53': [
+    `🆕 **What's new in cachly MCP v${MCP_VERSION}:**`,
+    `  🐛 Fixed: Brain bootstrap summary now visible in session_start (was silently discarded)`,
+    `  🐛 Fixed: team lessons now indexed correctly (\`ts\` field was stored as \`timestamp\`)`,
+    `  ✨ New: proactive follow-up hints after \`learn_from_attempts\` (CKG co-occurrence patterns)`,
+    `  ✨ New: author name attribution for VS Code lessons (set \`cachly.authorName\` in VS Code settings)`,
+  ],
+  '0.10.52': [
+    `🆕 **What's new in cachly MCP v0.10.52:**`,
+    `  🚀 Zero-click setup: Brain activates automatically on first call (no auth prompt needed)`,
+    `  🐛 Fixed: all Brain connections now use decrypted passwords (resolves AUTH errors for all users)`,
+  ],
+  '0.10.50': [
+    `🆕 **What's new in cachly MCP v0.10.50:**`,
+    `  🐛 Fixed: Brain connection now works out of the box (was failing with AUTH error)`,
+    `  🐛 Fixed: TLS defaults to off for free-tier instances (no more TLS handshake failure)`,
+    `  ✅ \`get_api_status\` correctly shows API key type instead of "invalid JWT format"`,
+  ],
+  '0.10.46': [
+    `🆕 **What's new in v0.10.46:**`,
+    `  ✅ \`brain_from_git\` — auto-learns from your full git history on setup`,
+    `  ✅ \`smart_recall\` — semantic + keyword hybrid search, 3× more relevant results`,
+    `  ✅ VS Code Extension — Brain persists across all projects, zero config`,
+    `  ✅ Device-flow auth — zero-config login, no JWT needed in editor config`,
+    `  ✅ Auto-provision — Brain instance created automatically after first login`,
+    `  ✅ JWT now persisted to ~/.claude/mcp.json — survives editor restarts`,
+    `  ✅ Confidence scoring — every recalled fact shows staleness + reliability`,
+    `  ✅ CKG (Causal Knowledge Graph) — root-cause chains between bugs + fixes`,
+  ],
+  '0.10.0': [
+    `🆕 **What's new in v0.10.0:**`,
+    `  ✅ Zero-friction setup — auto-provisions your Brain, no manual config needed`,
+    `  ✅ 10× faster briefings — batch Redis fetches replace per-key loops`,
+    `  ✅ Crash-proof data reads — corrupted cache entries no longer break tools`,
+    `  ✅ \`session_end\` warns when called without an active session`,
+    `  ✅ \`get_api_status\` now shows live Redis ping + all instance statuses`,
   ],
 };
 
@@ -186,7 +230,7 @@ export async function handleBrainTool(
         const existing = await redis.get(depKey);
         const depTopics: string[] = safeJsonParse<string[]>(existing, []);
         if (!depTopics.includes(topic)) depTopics.push(topic);
-        await redis.set(depKey, JSON.stringify(depTopics), 'EX', 90 * 86400);
+        await redis.set(depKey, JSON.stringify(depTopics), 'EX', 365 * 86400); // 1-year TTL
       }
 
       const lessonObj = {
@@ -210,11 +254,11 @@ export async function handleBrainTool(
       };
       const lesson = JSON.stringify(lessonObj);
 
-      // Always append to the history list (audit log); keep last 100 entries, 90-day TTL
+      // Always append to the history list (audit log); cap at 200 entries to prevent unbounded growth
       const listKey = `cachly:lessons:${topic}`;
       await redis.rpush(listKey, lesson);
-      await redis.ltrim(listKey, -100, -1);
-      await redis.expire(listKey, 90 * 86400);
+      await redis.ltrim(listKey, -200, -1);
+      await redis.expire(listKey, 365 * 86400); // 1-year TTL
 
       // Update best key for success/partial; for failure only update if no success exists
       if (outcome === 'success' || outcome === 'partial') {
@@ -347,6 +391,44 @@ export async function handleBrainTool(
         }
       } catch { /* CKG updates are non-critical */ }
 
+      // ── Proactive follow-up suggestion (CKG co-occurrence patterns) ─────────
+      // After a successful fix, check if related concepts commonly follow it.
+      // Uses CKG co-occurs edges with confidence > 0.4 and at least 2 trials.
+      const proactiveSuggestions: string[] = [];
+      if (outcome === 'success' || outcome === 'partial') {
+        try {
+          const conceptId = ckgSlug(topic);
+          const fromEdgeKeys = await redis.smembers(`cachly:ckg:idx:from:${conceptId}`);
+          for (const ek of fromEdgeKeys.slice(0, 20)) {
+            const er = await redis.get(ek);
+            if (!er) continue;
+            const edge = safeJsonParse<CKGEdge | null>(er, null);
+            if (!edge || edge.confidence < 0.4 || (edge.trials ?? 0) < 2) continue;
+            if (edge.edgeType !== 'co-occurs' && edge.edgeType !== 'causes') continue;
+            // Resolve related concept to a lesson key
+            const relTopic = edge.to
+              .replace(/^cause:/, '')
+              .replace(/^tag:/, '')
+              .replace(/^problem:/, '')
+              .replace(/-/g, ':')
+              .replace(/_/g, '-');
+            const relRaw = await redis.get(`cachly:lesson:best:${relTopic}`);
+            if (!relRaw) continue;
+            const relLesson = safeJsonParse<{ topic?: string; what_worked?: string } | null>(relRaw, null);
+            const displayTopic = relLesson?.topic ?? relTopic;
+            if (!relLesson || !relLesson.what_worked || displayTopic === topic) continue;
+            const pct = Math.round(edge.confidence * 100);
+            if (proactiveSuggestions.length === 0) proactiveSuggestions.push('');
+            proactiveSuggestions.push(
+              `🔮 **Pattern detected:** \`${displayTopic}\` tends to follow this (${pct}% co-occurrence across ${edge.trials} sessions)`,
+              `   → ${relLesson.what_worked.slice(0, 100)}${relLesson.what_worked.length > 100 ? '…' : ''}`,
+              `   → Pre-empt it now: \`recall_best_solution(topic="${displayTopic}")\``,
+            );
+            break; // one proactive hint is enough
+          }
+        } catch { /* non-critical */ }
+      }
+
       const emoji = outcome === 'success' ? '✅' : outcome === 'partial' ? '⚠️' : '❌';
       const sevEmoji = severity === 'critical' ? '🔴' : severity === 'major' ? '🟡' : '🟢';
       const action = isUpdate ? 'updated' : 'stored';
@@ -369,6 +451,7 @@ export async function handleBrainTool(
           : '',
         ...templateWarnings,
         ...iWasWrongWarning,
+        ...proactiveSuggestions,
       ].filter(l => l !== '').join('\n');
     }
 
@@ -422,27 +505,8 @@ export async function handleBrainTool(
           ? `📌 **You've looked this up 3 times.** Consider pinning it for instant access: add \`pinned: true\` via \`learn_from_attempts\` to always surface it first.`
           : '';
 
-        // ── Trust signal (today-safe consensus layer) ───────────────────────
-        // A lesson recalled many times — or confirmed by multiple distinct
-        // authors — has proven its value. Surface that as social proof.
-        const lessonAuthors = (lesson as { authors?: string[]; author?: string }).authors
-          ?? ((lesson as { author?: string }).author ? [(lesson as { author?: string }).author!] : []);
-        const distinctAuthors = [...new Set(lessonAuthors.filter(Boolean))];
-        const rc = updatedLesson.recall_count;
-        let trustBadge = '';
-        if (distinctAuthors.length >= 2 && rc >= 5) {
-          trustBadge = `🏆 **Battle-tested** — recalled ${rc}× · verified by ${distinctAuthors.length} developers. Trust this.`;
-        } else if (rc >= 10) {
-          trustBadge = `🏆 **Battle-tested** — recalled ${rc}×. This is one of your most-proven solutions.`;
-        } else if (distinctAuthors.length >= 2) {
-          trustBadge = `✅ **Team-verified** — confirmed by ${distinctAuthors.length} developers.`;
-        } else if (rc >= 5) {
-          trustBadge = `✅ **Proven** — recalled ${rc}× without contradiction.`;
-        }
-
         return [
           rememberWhen,
-          trustBadge,
           `${badge} **Best solution for \`${topic}\`** ${sevEmoji}${lesson.severity ? ` (${lesson.severity})` : ''} · recalled ${updatedLesson.recall_count}×`,
           ``,
           `**What worked:** ${lesson.what_worked}`,
@@ -507,22 +571,6 @@ export async function handleBrainTool(
         10,
       );
 
-      // Increment recall_count on matched lessons (fire-and-forget — same as recall_best_solution).
-      // This ensures the dashboard metric, Proven Laws, and trust badges reflect real smart_recall usage.
-      const lessonMatches = kwMatches.filter(m => m.key.startsWith('cachly:lesson:best:'));
-      for (const m of lessonMatches.slice(0, 5)) {
-        const existing = await redis.get(m.key).catch(() => null);
-        if (existing) {
-          const lesson = safeJsonParse(existing, null as null | { recall_count?: number; [k: string]: unknown });
-          if (lesson) {
-            const updated = { ...lesson, recall_count: (lesson.recall_count ?? 0) + 1, verified_at: new Date().toISOString() };
-            redis.set(m.key, JSON.stringify(updated)).catch(() => {});
-            const savedMins = (lesson.severity as string) === 'critical' ? 240 : (lesson.severity as string) === 'major' ? 60 : 30;
-            redis.incrbyfloat(`cachly:stats:time_saved_mins:${instance_id}`, savedMins).catch(() => {});
-          }
-        }
-      }
-
       const lines: string[] = [`🧠 **Smart Recall** for: _"${query}"_\n`];
 
       // Show sub-query info if multi-topic was detected
@@ -794,6 +842,25 @@ export async function handleBrainTool(
         lines.push('');
       }
 
+      // ── Bootstrap wow moment (shown once after first auto git-bootstrap) ──────
+      // brain_from_git fires in the background on the first session_start with
+      // workspace_path. The result count is stored under a well-known key so the
+      // NEXT session can celebrate it — "🎉 Your Brain bootstrapped from 87 commits!"
+      if (!isFirstSession) {
+        try {
+          const bootstrapRaw = await redis.get('cachly:brain_from_git:auto_bootstrap_result');
+          if (bootstrapRaw) {
+            const br = safeJsonParse<{ count: number; ts: string } | null>(bootstrapRaw, null);
+            if (br && br.count > 0) {
+              await redis.del('cachly:brain_from_git:auto_bootstrap_result'); // show once
+              lines.push(`🎉 **Your Brain bootstrapped from your git history — ${br.count} patterns learned automatically.**`);
+              lines.push(`   Arrives pre-briefed. No setup needed. Share with a teammate: \`npx @cachly-dev/mcp-server@latest invite\``);
+              lines.push('');
+            }
+          }
+        } catch { /* non-critical */ }
+      }
+
       // ── Team-virality: first-team-briefing wow moment ────────────────────
       // When a user joins a team brain (has team lessons from colleagues but
       // has never been briefed on them), show a dedicated "Welcome to your
@@ -937,31 +1004,6 @@ export async function handleBrainTool(
       // Brain health
       lines.push(`📊 **Brain:** ${lessons.length} lessons · ${ctxCount} context entries`, '');
 
-      // ── 📌 Proven Laws — auto-crystallized lessons (quick win 3) ─────────────
-      // A lesson that has proven itself (recalled ≥ CRYSTALLIZE_RECALLS times) or
-      // was explicitly pinned becomes a "law" — surfaced at the top of every
-      // briefing so the most battle-tested knowledge is never buried. This is
-      // the today-safe version of swarm crystallization: enough confirmations
-      // auto-promote a lesson without any manual step.
-      {
-        type LessonPin = typeof lessons[0] & { pinned?: boolean };
-        const CRYSTALLIZE_RECALLS = 5;
-        const laws = (lessons as LessonPin[])
-          .filter(l => l.outcome === 'success' && (l.pinned === true || (l.recall_count ?? 0) >= CRYSTALLIZE_RECALLS))
-          .sort((a, b) => (b.recall_count ?? 0) - (a.recall_count ?? 0))
-          .slice(0, 5);
-        if (laws.length > 0) {
-          lines.push(`📌 **Proven Laws** (auto-crystallized — your most-trusted knowledge):`);
-          for (const l of laws) {
-            const sev = l.severity === 'critical' ? '🔴' : l.severity === 'major' ? '🟡' : '';
-            const rc  = l.recall_count ?? 0;
-            const why = l.pinned === true ? 'pinned' : `recalled ${rc}×`;
-            lines.push(`  🏆${sev} \`${l.topic}\` _(${why})_ — ${l.what_worked.slice(0, 100)}`);
-          }
-          lines.push('');
-        }
-      }
-
       // ── Layer 7: MCM Domain Coverage Map ────────────────────────────────────
       if (lessons.length >= 3) {
         const domainMap = new Map<string, { total: number; success: number; critical: number }>();
@@ -1061,14 +1103,8 @@ export async function handleBrainTool(
           for (const l of topRecalled) {
             const emoji = l.outcome === 'success' ? '✅' : l.outcome === 'partial' ? '⚠️' : '❌';
             const sev   = l.severity === 'critical' ? '🔴' : l.severity === 'major' ? '🟡' : '';
-            const rc    = l.recall_count ?? 0;
-            const la     = (l as { authors?: string[]; author?: string }).authors
-              ?? ((l as { author?: string }).author ? [(l as { author?: string }).author!] : []);
-            const nAuthors = new Set(la.filter(Boolean)).size;
-            const trust  = (nAuthors >= 2 && rc >= 5) || rc >= 10 ? ' 🏆'
-              : nAuthors >= 2 || rc >= 5 ? ' ✅' : '';
-            const rct   = rc > 1 ? ` _(${rc}× recalled)_` : '';
-            lines.push(`  ${emoji}${sev}${trust} \`${l.topic}\`${rct} — ${l.what_worked.slice(0, 100)}`);
+            const rct   = l.recall_count && l.recall_count > 1 ? ` _(${l.recall_count}× recalled)_` : '';
+            lines.push(`  ${emoji}${sev} \`${l.topic}\`${rct} — ${l.what_worked.slice(0, 100)}`);
           }
           lines.push('');
         }
@@ -1136,63 +1172,27 @@ export async function handleBrainTool(
       }
 
       // ── 🔮 Predictive Pre-Warning — intent-based danger detection ────────────
-      // Fires BEFORE work starts. Uses explicit focus when given; otherwise
-      // derives the likely work area from the last session's changed files +
-      // summary (you usually keep working where you left off). This makes the
-      // warning fire even when the caller forgets to pass `focus`.
-      {
+      // Fires BEFORE work starts. If focus area has known failure patterns → warn loudly.
+      if (focusTerms.length > 0) {
         type LessonAny = typeof lessons[0] & { author?: string; tags?: string[] };
-
-        // Common path noise / extensions to drop when deriving terms from files.
-        const PATH_NOISE = new Set([
-          'src', 'lib', 'test', 'tests', 'dist', 'index', 'main', 'app',
-          'internal', 'pkg', 'cmd', 'node_modules', 'components', 'utils',
-          'ts', 'tsx', 'js', 'jsx', 'go', 'py', 'rs', 'java', 'json', 'yaml', 'yml',
-        ]);
-        const deriveTermsFromFiles = (files: string[]): string[] => {
-          const terms = new Set<string>();
-          for (const f of files) {
-            for (const seg of f.toLowerCase().split(/[/\\._-]/)) {
-              if (seg.length > 3 && !PATH_NOISE.has(seg)) terms.add(seg);
-            }
-          }
-          return [...terms];
-        };
-
-        let warnTerms = focusTerms;
-        let warnLabel = focus;
-        let derived = false;
-        if (warnTerms.length === 0 && lastSession) {
-          const fromFiles = deriveTermsFromFiles(lastSession.files_changed ?? []);
-          const fromSummary = (lastSession.summary ?? '').toLowerCase()
-            .replace(/[^a-z0-9\s:_-]/g, ' ').split(/\s+/).filter(t => t.length > 3 && !PATH_NOISE.has(t));
-          warnTerms = [...new Set([...fromFiles, ...fromSummary])];
-          warnLabel = 'where you left off last session';
-          derived = true;
-        }
-
-        if (warnTerms.length > 0) {
-          const dangerLessons = (lessons as LessonAny[]).filter(l => {
-            if (l.outcome === 'success') return false;
-            const topicCategory = l.topic.split(':')[0];
-            return warnTerms.some(term =>
-              l.topic.toLowerCase().includes(term) ||
-              topicCategory === term ||
-              (l.tags ?? []).some((t: string) => t.toLowerCase() === term),
-            );
-          });
-          if (dangerLessons.length >= 1) {
-            const headline = derived
-              ? `  You're likely to continue **${warnLabel}** — ${dangerLessons.length} known pitfall${dangerLessons.length > 1 ? 's' : ''} there:`
-              : `  Known pitfalls for **"${warnLabel}"** (${dangerLessons.length} past failure${dangerLessons.length > 1 ? 's' : ''}):`;
-            const warning = [
-              `🚨 **PRE-WARNING** — Read this BEFORE starting:`,
-              headline,
-              ...dangerLessons.slice(0, 3).map(l => `  ❌ \`${l.topic}\` — ${(l.what_failed ?? l.what_worked).slice(0, 80)}`),
-              '',
-            ];
-            lines.splice(2, 0, ...warning); // after '🧠 **Session Briefing**' + empty line
-          }
+        const dangerLessons = (lessons as LessonAny[]).filter(l => {
+          if (l.outcome === 'success') return false;
+          const topicCategory = l.topic.split(':')[0];
+          return focusTerms.some(term =>
+            l.topic.toLowerCase().includes(term) ||
+            topicCategory === term ||
+            (l.tags ?? []).some((t: string) => t.toLowerCase() === term),
+          );
+        });
+        if (dangerLessons.length >= 1) {
+          // Insert warning block right after the title line (index 1 = blank line after title)
+          const warning = [
+            `🚨 **PRE-WARNING** — Read this BEFORE starting:`,
+            `  Known pitfalls for **"${focus}"** (${dangerLessons.length} past failure${dangerLessons.length > 1 ? 's' : ''}):`,
+            ...dangerLessons.slice(0, 3).map(l => `  ❌ \`${l.topic}\` — ${(l.what_failed ?? l.what_worked).slice(0, 80)}`),
+            '',
+          ];
+          lines.splice(2, 0, ...warning); // after '🧠 **Session Briefing**' + empty line
         }
       }
 

package/src/handlers/context.ts

@@ -64,18 +64,13 @@ export async function handleContextTool(
           if (ttl && ttl > 0) {
             body['expires_at'] = new Date(Date.now() + ttl * 1000).toISOString();
           }
-          const res = await fetch(`${vectorUrl}/entries`, {
+          await fetch(`${vectorUrl}/entries`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify(body),
-            signal: AbortSignal.timeout(8000),
-          });
-          if (!res.ok) {
-            process.stderr.write(`[cachly] semantic index skipped (HTTP ${res.status}) — smart_recall on this context will be keyword-only\n`);
-          }
-        } catch (e) {
-          // Embedding is optional — keyword recall still works. Log so it's debuggable.
-          process.stderr.write(`[cachly] semantic index failed: ${e instanceof Error ? e.message : String(e)} — smart_recall on this context will be keyword-only\n`);
+          }).catch(() => undefined);
+        } catch {
+          // Embedding optional — continue silently
         }
       }
 

package/src/handlers/fedbrain.ts

@@ -9,9 +9,6 @@ import { keywordSearch, tokenize } from '../search.js';
 import { safeJsonParse } from '../utils.js';
 import { computeEmbedding, hasEmbedProvider } from '../embeddings.js';
 
-// Last brain_from_git category counts — set after each run so index.ts can include them in telemetry
-export let _lastBrainFromGitCounts: { fixes: number; features: number; refactors: number; total: number } | null = null;
-
 // Git concurrency semaphore (for brain_from_git parallel workers)
 let _gitSemCount = 0;
 const _GIT_SEM_MAX = 10;
@@ -366,6 +363,8 @@ export async function handleFedbrainTool(
 
       if (hooksArr.includes('ci')) {
         lines.push(`### GitHub Actions CI outcome hook`);
+        lines.push(`**Setup:** add a repo secret \`CACHLY_CACHE_TOKEN\` = your instance's cache token`);
+        lines.push(`(find it via \`get_connection_string\` — the token in the cache URL).`);
         lines.push(`**Add at the end of each job** (after build/test steps):`);
         lines.push('```yaml');
         lines.push(`- name: cachly CLS — record CI outcome`);
@@ -373,15 +372,14 @@ export async function handleFedbrainTool(
         lines.push(`  run: |`);
         lines.push(`    node -e "`);
         lines.push(`    const r=require('https');`);
-        lines.push(`    const d=JSON.stringify({instance_id:'${instance_id}',source:'ci_outcome',payload:{`);
+        lines.push(`    const d=JSON.stringify({source:'ci_outcome',payload:{`);
         lines.push(`      status:'\${{ job.status }}',prev_status:'unknown',job:'\${{ github.job }}',`);
         lines.push(`      context:'github-actions run \${{ github.run_number }}'}});`);
-        lines.push(`    r.request({hostname:'api.cachly.dev',path:'/api/v1/cls/ingest',method:'POST',`);
-        lines.push(`      headers:{'Content-Type':'application/json','Authorization':'Bearer $CACHLY_JWT',`);
-        lines.push(`        'Content-Length':d.length}},()=>{}).end(d);`);
+        lines.push(`    r.request({hostname:'api.cachly.dev',path:'/v1/cache/'+process.env.CACHLY_CACHE_TOKEN+'/cls/ingest',method:'POST',`);
+        lines.push(`      headers:{'Content-Type':'application/json','Content-Length':d.length}},()=>{}).end(d);`);
         lines.push(`    " 2>/dev/null || true`);
         lines.push(`  env:`);
-        lines.push(`    CACHLY_JWT: \${{ secrets.CACHLY_JWT }}`);
+        lines.push(`    CACHLY_CACHE_TOKEN: \${{ secrets.CACHLY_CACHE_TOKEN }}`);
         lines.push('```');
         lines.push('');
       }
@@ -1015,16 +1013,11 @@ export async function handleFedbrainTool(
         // Only store if no existing lesson for this topic (avoid overwriting higher-confidence lessons)
         const existing = await redis.get(`cachly:lesson:best:${topic}`);
         if (!existing) {
-          // Auto-inferred git lessons get a 90-day TTL — they self-refresh on the next
-          // brain_from_git run, and shouldn't pin memory forever if the repo goes stale.
-          await redis.set(`cachly:lesson:best:${topic}`, JSON.stringify(lessonObj), 'EX', 90 * 86400);
+          await redis.set(`cachly:lesson:best:${topic}`, JSON.stringify(lessonObj));
           await redis.rpush(`cachly:lessons:${topic}`, JSON.stringify(lessonObj));
-          await redis.ltrim(`cachly:lessons:${topic}`, -100, -1);
-          await redis.expire(`cachly:lessons:${topic}`, 90 * 86400);
         }
         await redis.rpush('cachly:lessons:brain_from_git:all', JSON.stringify({ topic, sha: commit.sha.slice(0, 8), subject: commit.subject.slice(0, 60) }));
         await redis.ltrim('cachly:lessons:brain_from_git:all', -500, -1);
-        await redis.expire('cachly:lessons:brain_from_git:all', 90 * 86400);
 
         // Update CKG
         const conceptId = ckgSlug(topic);
@@ -1041,13 +1034,6 @@ export async function handleFedbrainTool(
 
       const categoryBreakdown = [...categoryCount.entries()].sort((a, b) => b[1] - a[1]).map(([k, v]) => `  • **${k}** (${v})`).join('\n');
 
-      _lastBrainFromGitCounts = {
-        fixes: categoryCount.get('fix') ?? 0,
-        features: categoryCount.get('feat') ?? 0,
-        refactors: categoryCount.get('refactor') ?? 0,
-        total: ingested,
-      };
-
       return [
         `🔁 **brain_from_git: ${repoDir}**`,
         isIncremental ? `🔄 Incremental mode — only new commits since \`${lastSha.slice(0, 8)}\` were processed` : '',

package/src/handlers/roadmap.ts

@@ -157,12 +157,9 @@ export async function handleRoadmapTool(
       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 items = Object.values(all)
-        .flatMap(v => {
-          const item = safeJsonParse<Record<string, unknown> | null>(v as string, null);
-          return item ? [item] : [];
-        })
+        .map(v => JSON.parse(v as string) as Record<string, unknown>)
         .filter(i => i.status === 'in-progress' || i.status === 'planned')
-        .filter(i => !filterTag || (Array.isArray(i.tags) ? i.tags : []).includes(filterTag));
+        .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) => {
@@ -172,8 +169,7 @@ export async function handleRoadmapTool(
       });
       const next = items[0];
       const remaining = items.length - 1;
-      const nextTags = Array.isArray(next.tags) ? next.tags as string[] : [];
-      const tags = nextTags.length ? `\nTags:      ${nextTags.join(', ')}` : '';
+      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 [

package/src/handlers/team.ts

@@ -109,7 +109,9 @@ export async function handleTeamTool(
         file_paths: file_paths ?? [],
         commands: commands ?? [],
         tags: [...(tags ?? []), 'team'],
-        timestamp: new Date().toISOString(),
+        ts: new Date().toISOString(),
+        verified_at: outcome === 'success' ? new Date().toISOString() : undefined,
+        confidence: 1.0,
         recall_count: 0,
         version: 2,
       };