@cachly-dev/mcp-server 0.10.59 → 0.10.61

package/src/handlers/brain.ts

@@ -12,14 +12,27 @@ import { rerankByQuality } from '../rerank.js';
 import { computeEmbedding, hasEmbedProvider } from '../embeddings.js';
 
 // ── Changelog (shown once per version in session_start) ──────────────────────
-const MCP_VERSION = '0.10.59';
+const MCP_VERSION = '0.10.61';
 const WHATS_NEW: Record<string, string[]> = {
+  '0.10.61': [
+    `🎯 **Phase 3C: 100 MCP tools milestone — zero-setup knowledge graph**`,
+    `  🔄 \`brain_from_git\` now auto-builds Person+File nodes from git history (zero setup!)`,
+    `  🔍 \`skill_gaps()\` — find domains with unresolved failures, missing attribution`,
+    `  📊 \`brain_coverage()\` — scored 0-100 health report: lessons · attribution · file coverage`,
+  ],
+  '0.10.60': [
+    `🆕 **Phase 3B: File map + team overview + visibility**`,
+    `  📁 \`brain_file_map(file_paths=[...])\` — experts + lessons per file before you touch it`,
+    `  🗺️ \`team_expertise_map()\` — full team skills matrix in one table`,
+    `  🔒 \`visibility: "private"\` on \`learn_from_attempts\` — private notes never leak to smart_recall`,
+    `  📊 98 MCP tools`,
+  ],
   '0.10.59': [
     `🆕 **Phase 3A: Org-wide knowledge graph**`,
     `  👥 \`brain_who_knows(topic="...")\` — find your team's experts on any topic instantly`,
     `  🕸️ Person + File nodes auto-built from \`learn_from_attempts(author="...", file_paths=[...])\``,
     `  👤 Author attribution now shown inline in \`smart_recall\` results`,
-    `  📊 96 MCP tools · 379 tests green`,
+    `  📊 96 MCP tools · 386 tests green`,
   ],
   '0.10.58': [
     `🧹 Zero lint warnings — all unused imports cleaned across every handler`,
@@ -80,7 +93,8 @@ type ApiFetch = <T>(path: string, options?: RequestInit) => Promise<T>;
 export const BRAIN_TOOL_NAMES = new Set([
   'learn_from_attempts', 'recall_best_solution', 'smart_recall',
   'session_start', 'session_end', 'session_ping', 'session_handoff', 'auto_learn_session',
-  'brain_who_knows',
+  'brain_who_knows', 'brain_file_map', 'team_expertise_map',
+  'skill_gaps', 'brain_coverage',
 ]);
 
 export async function handleBrainTool(
@@ -104,6 +118,7 @@ export async function handleBrainTool(
         tags = [],
         depends_on = [],
         author = '',
+        visibility = 'team',
       } = args as {
         instance_id: string;
         topic: string;
@@ -117,6 +132,7 @@ export async function handleBrainTool(
         tags?: string[];
         depends_on?: string[];
         author?: string;
+        visibility?: 'public' | 'team' | 'private';
       };
 
       const redis = await getConnection(instance_id);
@@ -246,6 +262,7 @@ export async function handleBrainTool(
         tags,
         depends_on,
         ...(author ? { author } : {}),
+        visibility,
         recall_count: recallCount,
         ts,
         verified_at: outcome === 'success' || outcome === 'partial' ? ts : undefined,
@@ -625,13 +642,13 @@ export async function handleBrainTool(
       }
 
       // ── Layer 2: Semantic search (parallel, optional) ────────────────────────
-      const inst = await apiFetch<Instance>(`/api/v1/instances/${instance_id}`);
+      const inst = await apiFetch<Instance | null>(`/api/v1/instances/${instance_id}`).catch(() => null);
       type SemHit = { key: string; similarity: number; content: string };
       const semHits: SemHit[] = [];
-      if (inst.vector_token && hasEmbedProvider()) {
+      if (inst?.vector_token && hasEmbedProvider()) {
         try {
           const embedding = await computeEmbedding(query);
-          const vectorUrl = `https://api.cachly.dev/v1/sem/${inst.vector_token}`;
+          const vectorUrl = `https://api.cachly.dev/v1/sem/${inst!.vector_token}`;
           const searchRes = await fetch(`${vectorUrl}/search`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
@@ -736,7 +753,14 @@ export async function handleBrainTool(
         }
       } catch { /* non-critical — keyword + semantic always available */ }
 
-      const hybridResults = [...hybridMap.values()].sort((a, b) => b.hybridScore - a.hybridScore);
+      // Filter private lessons — they are only accessible via exact recall_best_solution
+      const hybridResults = [...hybridMap.values()]
+        .filter(r => {
+          if (!r.key.startsWith('cachly:lesson:best:')) return true;
+          const ld = safeJsonParse<{ visibility?: string }>(r.content, {});
+          return ld.visibility !== 'private';
+        })
+        .sort((a, b) => b.hybridScore - a.hybridScore);
 
       // ── Build output ──────────────────────────────────────────────────────────
       const lines: string[] = [`🧠 **Smart Recall** for: _"${query}"_\n`];
@@ -2123,6 +2147,403 @@ export async function handleBrainTool(
       return lines.join('\n');
     }
 
+    // ── brain_file_map ────────────────────────────────────────────────────────
+    // Phase 3B: "What do we know about these files?" — experts + lessons per file.
+    case 'brain_file_map': {
+      const {
+        instance_id,
+        file_paths = [],
+      } = args as { instance_id: string; file_paths: string[] };
+
+      if (!file_paths.length) return '⚠️ Pass at least one file path.';
+
+      const redis = await getConnection(instance_id);
+      const lines: string[] = [
+        `## 📁 File Knowledge Map`,
+        ``,
+        `_What cachly knows about the files you're about to touch:_`,
+        ``,
+      ];
+
+      for (const fp of file_paths.slice(0, 10)) {
+        lines.push(`### \`${fp}\``);
+
+        // ── Experts via CKG file nodes ─────────────────────────────────────
+        const fileId = `file:${ckgSlug(fp)}`;
+        const inbound = await redis.smembers(`cachly:ckg:idx:to:${fileId}`);
+        type ExpertEntry = { handle: string; touches: number; lastSeen: string };
+        const experts: ExpertEntry[] = [];
+        for (const ek of inbound) {
+          const er = await redis.get(ek);
+          if (!er) continue;
+          const edge = safeJsonParse<CKGEdge | null>(er, null);
+          if (!edge || edge.edgeType !== 'touched') continue;
+          const personRaw = await redis.get(`cachly:ckg:node:${edge.from}`);
+          if (!personRaw) continue;
+          const pn = safeJsonParse<PersonNode | null>(personRaw, null);
+          if (!pn || pn.type !== 'person') continue;
+          experts.push({ handle: pn.handle, touches: edge.trials, lastSeen: edge.last_updated });
+        }
+        experts.sort((a, b) => b.touches - a.touches);
+
+        if (experts.length > 0) {
+          const expLine = experts.slice(0, 5).map((e, i) => {
+            const medal = i === 0 ? '🥇' : i === 1 ? '🥈' : i === 2 ? '🥉' : `${i + 1}.`;
+            const days = Math.floor((Date.now() - new Date(e.lastSeen).getTime()) / 86400000);
+            const ago = days < 1 ? 'today' : days < 7 ? `${days}d ago` : `${Math.floor(days / 7)}w ago`;
+            return `${medal} **${e.handle}** (${e.touches}× · ${ago})`;
+          }).join(' · ');
+          lines.push(`**Experts:** ${expLine}`);
+        } else {
+          lines.push(`**Experts:** _None yet — add \`author\` to \`learn_from_attempts\` calls_`);
+        }
+
+        // ── Related lessons via BM25 on filename tokens ────────────────────
+        const tokens = fp.replace(/[^a-z0-9]/gi, ' ').split(/\s+/).filter(t => t.length >= 4);
+        const lessonQuery = tokens.slice(0, 3).join(' ');
+        const relatedLessons: string[] = [];
+        if (lessonQuery) {
+          try {
+            const hits = await keywordSearch(redis, ['cachly:lesson:best:*'], lessonQuery, 4);
+            for (const h of hits) {
+              const ld = safeJsonParse<{
+                topic?: string; outcome?: string; what_worked?: string;
+                severity?: string; author?: string; visibility?: string;
+              }>(h.content, {});
+              if (ld.visibility === 'private') continue;
+              const emoji = ld.outcome === 'success' ? '✅' : ld.outcome === 'partial' ? '⚠️' : '❌';
+              const sev = ld.severity === 'critical' ? ' 🔴' : ld.severity === 'major' ? ' 🟡' : '';
+              const by = ld.author ? ` · 👤 ${ld.author}` : '';
+              const topic = h.key.replace('cachly:lesson:best:', '');
+              relatedLessons.push(`  - ${emoji} \`${topic}\`${sev}${by} — ${(ld.what_worked ?? '').slice(0, 100)}`);
+            }
+          } catch { /* non-critical */ }
+        }
+        // Also: exact file_paths match via lesson scan
+        if (relatedLessons.length < 2) {
+          const scanKeys: string[] = [];
+          const stream = redis.scanStream({ match: 'cachly:lesson:best:*', count: 200 });
+          await new Promise<void>((res, rej) => {
+            stream.on('data', (b: string[]) => scanKeys.push(...b));
+            stream.on('end', res); stream.on('error', rej);
+          });
+          for (const k of scanKeys.slice(0, 300)) {
+            const raw = await redis.get(k);
+            if (!raw) continue;
+            const ld = safeJsonParse<{
+              topic?: string; outcome?: string; what_worked?: string;
+              severity?: string; author?: string; visibility?: string; file_paths?: string[];
+            }>(raw, {});
+            if (ld.visibility === 'private') continue;
+            if (!(ld.file_paths ?? []).includes(fp)) continue;
+            const topic = k.replace('cachly:lesson:best:', '');
+            if (relatedLessons.some(l => l.includes(`\`${topic}\``))) continue;
+            const emoji = ld.outcome === 'success' ? '✅' : ld.outcome === 'partial' ? '⚠️' : '❌';
+            const sev = ld.severity === 'critical' ? ' 🔴' : ld.severity === 'major' ? ' 🟡' : '';
+            const by = ld.author ? ` · 👤 ${ld.author}` : '';
+            relatedLessons.push(`  - ${emoji} \`${topic}\`${sev}${by} — ${(ld.what_worked ?? '').slice(0, 100)}`);
+          }
+        }
+
+        if (relatedLessons.length > 0) {
+          lines.push(`**Related lessons:**`);
+          lines.push(...relatedLessons.slice(0, 5));
+        } else {
+          lines.push(`**Related lessons:** _None yet_`);
+        }
+        lines.push(``);
+      }
+
+      lines.push(
+        `---`,
+        `_Attribution builds with \`learn_from_attempts(file_paths=[...], author="...")\`. Run this before committing to track what changed and why._`,
+      );
+      return lines.join('\n');
+    }
+
+    // ── team_expertise_map ────────────────────────────────────────────────────
+    // Phase 3B: Full team expertise overview — who knows what, at a glance.
+    case 'team_expertise_map': {
+      const {
+        instance_id,
+        top_n = 20,
+      } = args as { instance_id: string; top_n?: number };
+
+      const redis = await getConnection(instance_id);
+
+      // Scan all person nodes
+      const personKeys: string[] = [];
+      const pStream = redis.scanStream({ match: 'cachly:ckg:node:person:*', count: 200 });
+      await new Promise<void>((res, rej) => {
+        pStream.on('data', (b: string[]) => personKeys.push(...b));
+        pStream.on('end', res); pStream.on('error', rej);
+      });
+
+      if (personKeys.length === 0) {
+        return [
+          `## 🗺️ Team Expertise Map`,
+          ``,
+          `No contributors yet.`,
+          ``,
+          `Add \`author="handle"\` to any \`learn_from_attempts\` call to start building the map.`,
+        ].join('\n');
+      }
+
+      type PersonEntry = { handle: string; lessonCount: number; domains: Map<string, number>; lastActive: string };
+      const people: PersonEntry[] = [];
+
+      for (const pk of personKeys) {
+        const raw = await redis.get(pk);
+        if (!raw) continue;
+        const pn = safeJsonParse<PersonNode | null>(raw, null);
+        if (!pn || pn.type !== 'person') continue;
+
+        // Count authored lessons + collect domains from authored edges
+        const outEdgeKeys = await redis.smembers(`cachly:ckg:idx:from:${pn.id}`);
+        const domainCounts = new Map<string, number>();
+        let lessonCount = 0;
+        for (const ek of outEdgeKeys) {
+          const er = await redis.get(ek);
+          if (!er) continue;
+          const edge = safeJsonParse<CKGEdge | null>(er, null);
+          if (!edge || edge.edgeType !== 'authored') continue;
+          lessonCount++;
+          const domain = edge.to.split(':')[0] ?? 'unknown';
+          domainCounts.set(domain, (domainCounts.get(domain) ?? 0) + 1);
+        }
+        people.push({ handle: pn.handle, lessonCount, domains: domainCounts, lastActive: pn.last_active });
+      }
+
+      people.sort((a, b) => b.lessonCount - a.lessonCount);
+      const topPeople = people.slice(0, top_n);
+
+      const lines = [
+        `## 🗺️ Team Expertise Map`,
+        ``,
+        `**${topPeople.length}** contributor${topPeople.length !== 1 ? 's' : ''} tracked:`,
+        ``,
+        `| # | Handle | Lessons | Top domains | Last active |`,
+        `|---|--------|---------|-------------|-------------|`,
+      ];
+
+      for (const [i, p] of topPeople.entries()) {
+        const medal = i === 0 ? '🥇' : i === 1 ? '🥈' : i === 2 ? '🥉' : `${i + 1}`;
+        const days = Math.floor((Date.now() - new Date(p.lastActive).getTime()) / 86400000);
+        const ago = days < 1 ? 'today' : days < 7 ? `${days}d ago` : days < 30 ? `${Math.floor(days / 7)}w ago` : `${Math.floor(days / 30)}mo ago`;
+        const domainStr = [...p.domains.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([d, c]) => `${d}(${c})`).join(', ') || '—';
+        lines.push(`| ${medal} | **${p.handle}** | ${p.lessonCount} | ${domainStr} | ${ago} |`);
+      }
+
+      lines.push(
+        ``,
+        `---`,
+        `_Use \`brain_who_knows(topic="...")\` to find the expert for a specific problem._`,
+      );
+      return lines.join('\n');
+    }
+
+    // ── skill_gaps ────────────────────────────────────────────────────────────
+    // Phase 3C: Show knowledge blind spots — domains/files with no success lessons,
+    // no attribution, or only failures.
+    case 'skill_gaps': {
+      const {
+        instance_id,
+        min_failures = 1,
+      } = args as { instance_id: string; min_failures?: number };
+
+      const redis = await getConnection(instance_id);
+
+      // Scan all best lessons
+      const lessonKeys: string[] = [];
+      const lStream = redis.scanStream({ match: 'cachly:lesson:best:*', count: 500 });
+      await new Promise<void>((res, rej) => {
+        lStream.on('data', (b: string[]) => lessonKeys.push(...b));
+        lStream.on('end', res); lStream.on('error', rej);
+      });
+
+      type DomainStats = { successes: number; failures: number; attributed: number; topics: string[] };
+      const domainMap = new Map<string, DomainStats>();
+      let totalAttributed = 0;
+      let totalPrivate = 0;
+
+      for (const k of lessonKeys) {
+        const raw = await redis.get(k);
+        if (!raw) continue;
+        const l = safeJsonParse<{
+          topic?: string; outcome?: string; author?: string; visibility?: string;
+        }>(raw, {});
+        const domain = (l.topic ?? '').split(':')[0] ?? 'unknown';
+        const s = domainMap.get(domain) ?? { successes: 0, failures: 0, attributed: 0, topics: [] };
+        if (l.outcome === 'success' || l.outcome === 'partial') s.successes++;
+        else s.failures++;
+        if (l.author) { s.attributed++; totalAttributed++; }
+        if (l.visibility === 'private') totalPrivate++;
+        s.topics.push(l.topic ?? '');
+        domainMap.set(domain, s);
+      }
+
+      // Identify gaps
+      type Gap = { domain: string; type: string; severity: string; detail: string };
+      const gaps: Gap[] = [];
+
+      for (const [domain, s] of domainMap) {
+        if (s.failures >= min_failures && s.successes === 0) {
+          gaps.push({
+            domain, type: 'unresolved failures',
+            severity: s.failures >= 3 ? '🔴 critical' : '🟡 warn',
+            detail: `${s.failures} failure${s.failures !== 1 ? 's' : ''}, 0 solutions — use \`learn_from_attempts\` to store what fixed it`,
+          });
+        }
+        if (s.successes + s.failures >= 3 && s.attributed === 0) {
+          gaps.push({
+            domain, type: 'no attribution',
+            severity: '🔵 info',
+            detail: `${s.successes + s.failures} lessons with no \`author\` field — attribution lost, \`brain_who_knows\` can't help here`,
+          });
+        }
+      }
+
+      // Check for domains with person nodes but no lessons (contributors without lessons)
+      const personKeys: string[] = [];
+      const pStream = redis.scanStream({ match: 'cachly:ckg:node:person:*', count: 200 });
+      await new Promise<void>((res, rej) => {
+        pStream.on('data', (b: string[]) => personKeys.push(...b));
+        pStream.on('end', res); pStream.on('error', rej);
+      });
+
+      const lines = [
+        `## 🔍 Skill Gaps — Knowledge Blind Spots`,
+        ``,
+        `**${lessonKeys.length}** lessons scanned · **${totalAttributed}** attributed · **${gaps.length}** gap${gaps.length !== 1 ? 's' : ''} found`,
+        totalPrivate > 0 ? `_(${totalPrivate} private lessons excluded from gap analysis)_` : '',
+        ``,
+      ].filter(Boolean);
+
+      if (gaps.length === 0) {
+        lines.push(`✅ No significant knowledge gaps detected. All domains with failures have at least one success lesson.`);
+      } else {
+        const bySev = [
+          ...gaps.filter(g => g.severity.includes('critical')),
+          ...gaps.filter(g => g.severity.includes('warn')),
+          ...gaps.filter(g => g.severity.includes('info')),
+        ];
+        for (const g of bySev.slice(0, 15)) {
+          lines.push(`${g.severity} **\`${g.domain}\`** — ${g.type}`);
+          lines.push(`  ${g.detail}`);
+          lines.push(``);
+        }
+        if (gaps.length > 15) lines.push(`_…and ${gaps.length - 15} more gaps. Fix critical ones first._`);
+      }
+
+      lines.push(
+        `---`,
+        `_Fix gaps with \`learn_from_attempts(topic="${gaps[0]?.domain ?? 'your:topic'}", outcome="success", what_worked="...")\`_`,
+        `_Add \`author="name"\` to every call to enable \`brain_who_knows\` + \`team_expertise_map\`._`,
+      );
+
+      return lines.join('\n');
+    }
+
+    // ── brain_coverage ────────────────────────────────────────────────────────
+    // Phase 3C: Knowledge-coverage health score for the repository.
+    case 'brain_coverage': {
+      const {
+        instance_id,
+        repo_path = '.',
+      } = args as { instance_id: string; repo_path?: string };
+
+      const redis = await getConnection(instance_id);
+
+      // Count lessons
+      const lessonKeys: string[] = [];
+      const lStream = redis.scanStream({ match: 'cachly:lesson:best:*', count: 500 });
+      await new Promise<void>((res, rej) => {
+        lStream.on('data', (b: string[]) => lessonKeys.push(...b));
+        lStream.on('end', res); lStream.on('error', rej);
+      });
+
+      // Count person nodes
+      const personKeys: string[] = [];
+      const pStream = redis.scanStream({ match: 'cachly:ckg:node:person:*', count: 200 });
+      await new Promise<void>((res, rej) => {
+        pStream.on('data', (b: string[]) => personKeys.push(...b));
+        pStream.on('end', res); pStream.on('error', rej);
+      });
+
+      // Count file nodes in CKG
+      const fileKeys: string[] = [];
+      const fStream = redis.scanStream({ match: 'cachly:ckg:node:file:*', count: 500 });
+      await new Promise<void>((res, rej) => {
+        fStream.on('data', (b: string[]) => fileKeys.push(...b));
+        fStream.on('end', res); fStream.on('error', rej);
+      });
+
+      // Get git file count for comparison (optional — non-critical if not a git repo)
+      let gitFileCount = 0;
+      let _gitFileCountLabel = 'n/a';
+      try {
+        const { execSync } = await import('node:child_process');
+        const { resolve } = await import('node:path');
+        const repoDir = resolve(repo_path);
+        const output = execSync('git ls-files', { cwd: repoDir, encoding: 'utf-8', stdio: 'pipe' });
+        gitFileCount = output.trim().split('\n').filter(Boolean).length;
+        _gitFileCountLabel = String(gitFileCount);
+      } catch { /* not a git repo — skip */ }
+
+      // Lesson quality breakdown
+      let successCount = 0; let failureCount = 0; let attributedCount = 0;
+      const domainSet = new Set<string>();
+      for (const k of lessonKeys) {
+        const raw = await redis.get(k);
+        if (!raw) continue;
+        const l = safeJsonParse<{ outcome?: string; author?: string; topic?: string }>(raw, {});
+        if (l.outcome === 'success' || l.outcome === 'partial') successCount++;
+        else failureCount++;
+        if (l.author) attributedCount++;
+        domainSet.add((l.topic ?? '').split(':')[0] ?? 'unknown');
+      }
+
+      const fileCoverage = gitFileCount > 0
+        ? `${Math.round((fileKeys.length / gitFileCount) * 100)}% (${fileKeys.length}/${gitFileCount} files)`
+        : `${fileKeys.length} files tracked`;
+
+      const attributionPct = lessonKeys.length > 0
+        ? Math.round((attributedCount / lessonKeys.length) * 100)
+        : 0;
+
+      const overallScore = Math.round(
+        (Math.min(1, lessonKeys.length / 50) * 25) +          // lesson volume (25 pts)
+        (Math.min(1, successCount / Math.max(1, lessonKeys.length)) * 25) + // success ratio (25 pts)
+        (Math.min(1, attributionPct / 100) * 25) +            // attribution completeness (25 pts)
+        (Math.min(1, personKeys.length / 5) * 25)             // team engagement (25 pts)
+      );
+
+      const scoreEmoji = overallScore >= 80 ? '🟢' : overallScore >= 50 ? '🟡' : '🔴';
+
+      return [
+        `## 📊 Brain Coverage Report`,
+        ``,
+        `${scoreEmoji} **Overall score: ${overallScore}/100**`,
+        ``,
+        `| Metric | Value |`,
+        `|--------|-------|`,
+        `| Total lessons | **${lessonKeys.length}** (${successCount} success · ${failureCount} failure) |`,
+        `| Problem domains | **${domainSet.size}** |`,
+        `| Attribution | **${attributedCount}/${lessonKeys.length}** (${attributionPct}%) |`,
+        `| Contributors | **${personKeys.length}** tracked in knowledge graph |`,
+        `| File coverage | **${fileCoverage}** |`,
+        ``,
+        `**Score breakdown (each 0–25):**`,
+        `- Lesson volume: **${Math.round(Math.min(1, lessonKeys.length / 50) * 25)}/25** _(target: 50+ lessons)_`,
+        `- Success ratio: **${Math.round(Math.min(1, successCount / Math.max(1, lessonKeys.length)) * 25)}/25** _(target: all lessons resolved)_`,
+        `- Attribution: **${Math.round(Math.min(1, attributionPct / 100) * 25)}/25** _(target: 100% attributed)_`,
+        `- Team engagement: **${Math.round(Math.min(1, personKeys.length / 5) * 25)}/25** _(target: 5+ contributors)_`,
+        ``,
+        `---`,
+        `_Boost score: run \`brain_from_git\` · add \`author\` to \`learn_from_attempts\` · fix gaps with \`skill_gaps\`_`,
+      ].join('\n');
+    }
+
     // ── sync_file_changes ─────────────────────────────────────────────────────
 
     default:

package/src/handlers/fedbrain.ts

@@ -1,6 +1,7 @@
 import { createHmac } from 'node:crypto';
 import type { Redis } from 'ioredis';
-import { ckgSlug, extractProblemConcept, ckgUpsertNode, ckgUpdateEdge } from '../ckg.js';
+import { ckgSlug, extractProblemConcept, ckgUpsertNode, ckgUpdateEdge,
+         ckgUpsertPersonNode, ckgUpsertFileNode } from '../ckg.js';
 import type { CKGEdge, CKGNode } from '../ckg.js';
 import { safeJsonParse } from '../utils.js';
 
@@ -920,12 +921,11 @@ export async function handleFedbrainTool(
         isIncremental = Boolean(lastSha);
       }
 
-      // Build git log command
-      // In incremental mode, only fetch commits after the last processed SHA
+      // Build git log command — use --name-only to get changed files per commit
       const sinceFlag = since ? `--since="${since}"` : '';
       const afterFlag = isIncremental ? `${lastSha}..HEAD` : '';
       const revRange = afterFlag || branch;
-      const logCmd = `git log ${revRange} ${sinceFlag} --pretty=format:"%H|||%s|||%ad|||%an" --date=short --no-merges -n ${maxCommits}`;
+      const logCmd = `git log ${revRange} ${sinceFlag} --pretty=format:"COMMIT|||%H|||%s|||%ad|||%an" --date=short --no-merges --name-only -n ${maxCommits}`;
 
       let logOutput = '';
       try {
@@ -934,10 +934,21 @@ export async function handleFedbrainTool(
         return `❌ git log failed: ${(e as Error).message}. Check \`repo_path\` and \`branch\`.`;
       }
 
-      const commits = logOutput.trim().split('\n').filter(Boolean).map(line => {
-        const [sha, subject, date, author] = line.split('|||');
-        return { sha: (sha ?? '').trim(), subject: (subject ?? '').trim(), date: (date ?? '').trim(), author: (author ?? '').trim() };
-      });
+      // Parse multi-line output: each commit block = header line + blank line + file lines
+      type CommitEntry = { sha: string; subject: string; date: string; author: string; files: string[] };
+      const commits: CommitEntry[] = [];
+      let current: CommitEntry | null = null;
+      for (const raw of logOutput.split('\n')) {
+        const line = raw.trim();
+        if (line.startsWith('COMMIT|||')) {
+          if (current) commits.push(current);
+          const [, sha, subject, date, author] = line.split('|||');
+          current = { sha: (sha ?? '').trim(), subject: (subject ?? '').trim(), date: (date ?? '').trim(), author: (author ?? '').trim(), files: [] };
+        } else if (line && current) {
+          current.files.push(line);
+        }
+      }
+      if (current) commits.push(current);
 
       if (commits.length === 0) {
         if (isIncremental) {
@@ -994,13 +1005,17 @@ export async function handleFedbrainTool(
         const topic = `${category}:${domain}`;
         categoryCount.set(category, (categoryCount.get(category) ?? 0) + 1);
 
+        const commitFiles = commit.files.filter(f => f.length > 0).slice(0, 12);
         const lessonObj = {
           topic, outcome, severity,
           what_worked: commit.subject.slice(0, 200),
           what_failed: '',
           context: `git:${commit.sha.slice(0, 8)} by ${commit.author} on ${commit.date}`,
-          file_paths: [], commands: [`git show ${commit.sha.slice(0, 8)}`],
+          author: commit.author || undefined,
+          file_paths: commitFiles,
+          commands: [`git show ${commit.sha.slice(0, 8)}`],
           tags: ['brain_from_git', category, 'git-history'],
+          visibility: 'team',
           depends_on: [], recall_count: 0, ts, verified_at: ts,
           confidence: 0.55, // lower confidence for auto-inferred lessons
           audit_trail: [{ ts, action: 'brain_from_git', sha: commit.sha.slice(0, 8) }],
@@ -1021,9 +1036,22 @@ export async function handleFedbrainTool(
         await redis.ltrim('cachly:lessons:brain_from_git:all', -500, -1);
         await redis.expire('cachly:lessons:brain_from_git:all', 90 * 86400);
 
-        // Update CKG
+        // Update CKG — concept node + person node + file nodes
         const conceptId = ckgSlug(topic);
         await ckgUpsertNode(redis, conceptId, category, 'git-derived');
+
+        // Phase 3A: auto-build person + file nodes from git history
+        if (commit.author) {
+          try {
+            const personId = await ckgUpsertPersonNode(redis, commit.author, category);
+            await ckgUpdateEdge(redis, personId, 'authored', conceptId, outcome === 'success', outcome === 'partial');
+            for (const fp of commitFiles.slice(0, 8)) {
+              const fileId = await ckgUpsertFileNode(redis, fp);
+              await ckgUpdateEdge(redis, personId, 'touched', fileId, true);
+            }
+          } catch { /* non-critical */ }
+        }
+
         ingested++;
       }
 

package/src/index.ts

@@ -73,7 +73,7 @@ import { Redis } from 'ioredis';
 const API_URL = process.env.CACHLY_API_URL ?? 'https://api.cachly.dev';
 let JWT = process.env.CACHLY_JWT ?? '';
 const _EMBED_MODEL = process.env.CACHLY_EMBED_MODEL ?? '';
-const CURRENT_VERSION = '0.10.59';
+const CURRENT_VERSION = '0.10.61';
 
 // Max time to wait for a freshly-provisioned instance to become "running" before
 // giving up. Free-tier provisioning in high-latency regions can take 45–90s, so the
@@ -572,7 +572,7 @@ async function handleTool(name: string, args: Record<string, unknown>): Promise<
         '',
         'After sign-in: call **any tool again** — your Brain activates instantly.',
         '',
-        '✨ Free forever · No credit card · 96 MCP tools · GDPR · EU servers',
+        '✨ Free forever · No credit card · 100 MCP tools · GDPR · EU servers',
       ].join('\n');
     }
 
@@ -1816,7 +1816,7 @@ if (!process.argv[2] && process.stdout.isTTY) {
   console.log('  \x1b[36m  npx @cachly-dev/mcp-server@latest upgrade\x1b[0m  ← Check for updates');
   console.log('');
   console.log('  \x1b[90mWorks with: Claude Code · Cursor · Windsurf · GitHub Copilot · Cline · Zed\x1b[0m');
-  console.log('  \x1b[90mFree forever · GDPR · German servers · 96 MCP tools\x1b[0m');
+  console.log('  \x1b[90mFree forever · GDPR · German servers · 100 MCP tools\x1b[0m');
   console.log('');
   process.exit(0);
 }