@cachly-dev/mcp-server 0.10.129 → 0.10.130

package/dist/src/handlers/fedbrain.js

@@ -1,1436 +1,40 @@
-import { createHmac } from 'node:crypto';
-import { ckgSlug, extractProblemConcept, ckgUpsertNode, ckgUpdateEdge, ckgUpsertPersonNode, ckgUpsertFileNode, ckgRecordCollaboration } from '../ckg.js';
-import { safeJsonParse, normalizeGitPath } from '../utils.js';
-import { buildClsPostCommitHook } from '../cls-hook.js';
-import { installBrainWatchHook } from '../brain-watch-hook.js';
-import { keywordSearch } from '../search.js';
-import { buildFirstContactReport, suggestRecallQueries } from '../first-contact.js';
-// Last brain_from_git category counts — set after each run so index.ts can include them in telemetry
-export let _lastBrainFromGitCounts = null;
-// Last brain_from_ci counts — set after each run so index.ts can include them in telemetry
-export let _lastBrainFromCiCounts = null;
-// Git concurrency semaphore (for brain_from_git parallel workers)
-let _gitSemCount = 0;
-const _GIT_SEM_MAX = 10;
-const _gitSemQueue = [];
-function _gitSemAcquire() {
-    if (_gitSemCount < _GIT_SEM_MAX) {
-        _gitSemCount++;
-        return Promise.resolve();
-    }
-    return new Promise(resolve => _gitSemQueue.push(resolve));
-}
-function _gitSemRelease() {
-    const next = _gitSemQueue.shift();
-    if (next) {
-        next();
-    }
-    else {
-        _gitSemCount--;
-    }
-}
-export const FEDBRAIN_TOOL_NAMES = new Set([
-    'madc_deliberate', 'cls_ingest', 'cls_install_hooks', 'fedbrain_contribute', 'fedbrain_search',
-    'fedbrain_confirm', 'fedbrain_status', 'brain_federate', 'crystal_view', 'compact_recover',
-    'brain_from_git', 'brain_from_ci', 'brain_predict_failures',
-    'brain_contribute_signal', 'brain_import_meta', 'brain_watch',
-]);
-export async function handleFedbrainTool(name, args, getConnection, apiFetch) {
-    switch (name) {
-        case 'madc_deliberate': {
-            const { instance_id, topic } = args;
-            const redis = await getConnection(instance_id);
-            const historyRaw = await redis.lrange(`cachly:lessons:${topic}`, 0, -1);
-            const history = historyRaw.map(r => { try {
-                return JSON.parse(r);
-            }
-            catch {
-                return null;
-            } }).filter(Boolean);
-            if (history.length < 2) {
-                return [
-                    `🗳️ **MADC: "${topic}"**`, '',
-                    `Not enough history for deliberation (need ≥ 2 entries, found ${history.length}).`,
-                    '', `Call \`learn_from_attempts\` with conflicting outcomes to trigger deliberation.`,
-                ].join('\n');
-            }
-            // Specialist agents and their domain keywords
-            const AGENTS = [
-                { name: 'InfraAgent', domains: ['infra', 'k8s', 'docker', 'server', 'wireguard', 'helm'] },
-                { name: 'AuthAgent', domains: ['auth', 'jwt', 'keycloak', 'oauth', 'oidc', 'token'] },
-                { name: 'DeployAgent', domains: ['deploy', 'ci', 'pipeline', 'rsync', 'release'] },
-                { name: 'DatabaseAgent', domains: ['db', 'gorm', 'migration', 'postgres', 'clickhouse', 'redis'] },
-                { name: 'DebugAgent', domains: ['debug', 'panic', 'race', 'nil', 'fix', 'error'] },
-                { name: 'APIAgent', domains: ['api', 'http', 'grpc', 'rest', 'fiber', 'web'] },
-            ];
-            const topicDomain = topic.split(':')[0] ?? '';
-            const relevantAgents = AGENTS.filter(a => a.domains.some(d => topicDomain === d || topic.includes(d)));
-            const votingAgents = relevantAgents.length > 0 ? relevantAgents : AGENTS;
-            // Measure each agent's CKG coverage in their domains
-            const agentCoverage = new Map();
-            for (const agent of votingAgents) {
-                let edgeCount = 0;
-                for (const domain of agent.domains) {
-                    const nodeKeys = [];
-                    const nStream = redis.scanStream({ match: `cachly:ckg:node:${domain}*`, count: 50 });
-                    await new Promise((res, rej) => { nStream.on('data', (b) => nodeKeys.push(...b)); nStream.on('end', res); nStream.on('error', rej); });
-                    edgeCount += nodeKeys.length;
-                }
-                agentCoverage.set(agent.name, edgeCount);
-            }
-            const successLessons = history.filter(l => l.outcome === 'success' || l.outcome === 'partial');
-            const failureLessons = history.filter(l => l.outcome === 'failure');
-            if (failureLessons.length === 0) {
-                return [
-                    `🗳️ **MADC: "${topic}"**`, '',
-                    `No contradictions found — all ${successLessons.length} entries have non-failure outcomes.`,
-                    '', `Use \`ckg_inspect(concept="${ckgSlug(topic)}")\` to explore the confidence graph.`,
-                ].join('\n');
-            }
-            // Agent voting logic
-            const votes = [];
-            for (const agent of votingAgents) {
-                const coverage = agentCoverage.get(agent.name) ?? 0;
-                let vote;
-                let reason;
-                if (coverage < 2) {
-                    vote = 'abstain';
-                    reason = 'insufficient domain coverage';
-                }
-                else if (successLessons.length >= failureLessons.length * 2) {
-                    vote = 'success';
-                    reason = `${successLessons.length}/${history.length} entries confirm success`;
-                }
-                else if (failureLessons.length >= successLessons.length * 2) {
-                    vote = 'failure';
-                    reason = `${failureLessons.length}/${history.length} entries confirm failure`;
-                }
-                else {
-                    vote = 'abstain';
-                    reason = `contested (${successLessons.length} success vs ${failureLessons.length} failure)`;
-                }
-                votes.push({ agent: agent.name, vote, coverage, reason });
-            }
-            const successVotes = votes.filter(v => v.vote === 'success').length;
-            const failureVotes = votes.filter(v => v.vote === 'failure').length;
-            const abstainVotes = votes.filter(v => v.vote === 'abstain').length;
-            let resolution;
-            let resolutionText;
-            if (successVotes > 0 && failureVotes === 0) {
-                resolution = 'unanimous_success';
-                resolutionText = `✅ **Unanimous: SUCCESS** — ${successVotes} agent(s) confirm, ${abstainVotes} abstain`;
-            }
-            else if (failureVotes > 0 && successVotes === 0) {
-                resolution = 'unanimous_failure';
-                resolutionText = `❌ **Unanimous: FAILURE** — ${failureVotes} agent(s) confirm, ${abstainVotes} abstain`;
-            }
-            else {
-                resolution = 'contested';
-                resolutionText = `⚠️ **CONTESTED** — ${successVotes} success votes, ${failureVotes} failure votes, ${abstainVotes} abstain`;
-            }
-            // Store resolution as CKG node
-            const resNodeId = ckgSlug(`resolution:${topic}`);
-            const resNode = {
-                id: resNodeId, domain: 'resolution', type: 'resolution', count: 1,
-                ts: new Date().toISOString(), resolution, topic,
-                votes: { success: successVotes, failure: failureVotes, abstain: abstainVotes },
-            };
-            await redis.set(`cachly:ckg:node:${resNodeId}`, JSON.stringify(resNode));
-            // Write contradicts edge if contested; decay loser confidence to 0.1 if unanimous
-            if (resolution === 'contested') {
-                await ckgUpdateEdge(redis, ckgSlug(topic), 'contradicts', resNodeId, false);
-            }
-            else {
-                // Unanimous — demote the losing side's edges to near-zero confidence
-                const loserOutcome = resolution === 'unanimous_success' ? 'failure' : 'success';
-                const loserLessons = (loserOutcome === 'failure' ? failureLessons : successLessons);
-                if (loserLessons.length > 0) {
-                    // Decay all 'fixes' edges from this concept that contradict the resolution
-                    const fromKeys = await redis.smembers(`cachly:ckg:idx:from:${ckgSlug(topic)}`);
-                    for (const fk of fromKeys) {
-                        const er = await redis.get(fk);
-                        if (!er)
-                            continue;
-                        try {
-                            const edge = JSON.parse(er);
-                            if (edge.edgeType === 'fixes' && edge.confidence > 0.15) {
-                                if (resolution === 'unanimous_failure') {
-                                    // Fix was wrong — decay to 0.1
-                                    edge.confidence = 0.1;
-                                    edge.last_updated = new Date().toISOString();
-                                    await redis.set(fk, JSON.stringify(edge));
-                                }
-                            }
-                        }
-                        catch { /* skip corrupt edges */ }
-                    }
-                }
-                // Remove the conflict marker — deliberation resolved it
-                await redis.del(`cachly:ckg:conflict:${ckgSlug(topic)}`);
-            }
-            const lines = [
-                `🗳️ **MADC Deliberation: "${topic}"**`, '',
-                `📊 Evidence: ${successLessons.length} success/partial vs ${failureLessons.length} failure entries (${history.length} total)`,
-                '', `**Voting agents (${votingAgents.length}):**`,
-                ...votes.map(v => {
-                    const icon = v.vote === 'success' ? '✅' : v.vote === 'failure' ? '❌' : '⬜';
-                    const covBar = '▓'.repeat(Math.min(v.coverage, 5)) + '░'.repeat(Math.max(0, 5 - v.coverage));
-                    return `  ${icon} **${v.agent}** [${covBar}] ${v.coverage} CKG edges — ${v.reason}`;
-                }),
-                '', resolutionText, '',
-            ];
-            if (resolution === 'unanimous_success') {
-                lines.push(`🔧 Failure entries superseded — store confirmed lesson: \`learn_from_attempts(topic="${topic}", outcome="success", ...)\``);
-            }
-            else if (resolution === 'unanimous_failure') {
-                lines.push(`🚫 Success claims unconfirmed — re-verify: \`recall_best_solution(topic="${topic}")\``);
-            }
-            else {
-                lines.push(`⚠️ Contested — run \`causal_trace\` before acting. Explore: \`ckg_inspect(concept="${ckgSlug(topic)}")\``);
-            }
-            lines.push('', `📝 Resolution node: \`cachly:ckg:node:${resNodeId}\``);
-            return lines.join('\n');
-        }
-        // ── Layer 5: CLS — cls_ingest ─────────────────────────────────────────────
-        case 'cls_ingest': {
-            const { instance_id, source, payload } = args;
-            const redis = await getConnection(instance_id);
-            const ts = new Date().toISOString();
-            const clsKey = 'cachly:cls:events';
-            if (source === 'git_commit') {
-                const message = String(payload.message ?? '');
-                const sha = String(payload.sha ?? '');
-                const files = (Array.isArray(payload.files) ? payload.files : []);
-                const domain = /^fix/i.test(message) ? 'fix' : /^feat/i.test(message) ? 'feat' : /^refactor/i.test(message) ? 'refactor' : /^test/i.test(message) ? 'test' : 'commit';
-                const slug = `${domain}:${ckgSlug(message.slice(0, 60))}`;
-                const conceptId = ckgSlug(slug);
-                await ckgUpsertNode(redis, conceptId, domain, 'commit');
-                for (const f of files.slice(0, 10)) {
-                    const fd = f.includes('auth') ? 'auth' : f.includes('api') ? 'api' : f.includes('infra') ? 'infra' : f.includes('web') ? 'web' : 'code';
-                    const fileId = ckgSlug(`file:${fd}`);
-                    await ckgUpsertNode(redis, fileId, 'file', fd);
-                    await ckgUpdateEdge(redis, conceptId, 'co-occurs', fileId, true);
-                }
-                const lessonObj = {
-                    topic: slug, outcome: 'success', what_worked: message, what_failed: '',
-                    context: `CLS/git: sha=${sha}`, severity: 'minor',
-                    file_paths: files.slice(0, 10), commands: sha ? [`git show ${sha}`] : [],
-                    tags: ['cls', 'git'], depends_on: [], recall_count: 0, ts, verified_at: ts,
-                    confidence: 0.6, audit_trail: [{ ts, action: 'cls_git_commit' }], version: 3,
-                };
-                await redis.rpush(`cachly:lessons:${slug}`, JSON.stringify(lessonObj));
-                const existing = await redis.get(`cachly:lesson:best:${slug}`);
-                if (!existing)
-                    await redis.set(`cachly:lesson:best:${slug}`, JSON.stringify(lessonObj));
-                await redis.rpush(clsKey, JSON.stringify({ source, payload: { message, sha }, ts }));
-                await redis.ltrim(clsKey, -200, -1);
-                return [
-                    `📨 **CLS Ingested: git_commit**`, '',
-                    `Commit \`${sha.slice(0, 8) || '?'}\`: ${message.slice(0, 80)}`,
-                    `Concept: \`${conceptId}\` (${domain}) · Files: ${files.length}`,
-                    '', `🕸️ CKG: \`${conceptId}\` + ${files.length} file edges · Lesson: \`${slug}\``,
-                    `💡 Inspect: \`ckg_inspect(concept="${domain}")\``,
-                ].join('\n');
-            }
-            if (source === 'ci_outcome') {
-                const status = String(payload.status ?? '');
-                const prev_status = String(payload.prev_status ?? '');
-                const job = String(payload.job ?? 'unknown');
-                const ciCtx = String(payload.context ?? '');
-                const isFixed = ['failure', 'red', 'error'].includes(prev_status) && ['success', 'green', 'passed'].includes(status);
-                const isBroken = ['success', 'green', 'passed'].includes(prev_status) && ['failure', 'red', 'error'].includes(status);
-                const slug = `ci:${ckgSlug(job)}`;
-                const conceptId = ckgSlug(slug);
-                await ckgUpsertNode(redis, conceptId, 'ci', 'job');
-                if (isFixed) {
-                    const problemId = ckgSlug(`problem:${ckgSlug(job)}`);
-                    await ckgUpsertNode(redis, problemId, 'problem', 'ci-failure');
-                    await ckgUpdateEdge(redis, conceptId, 'fixes', problemId, true);
-                    const lessonObj = {
-                        topic: slug, outcome: 'success',
-                        what_worked: `CI job "${job}" went ${prev_status} → ${status}`,
-                        what_failed: `Job "${job}" was failing`, context: `CLS/ci: ${ciCtx}`,
-                        severity: 'major', file_paths: [], commands: [], tags: ['cls', 'ci'],
-                        depends_on: [], recall_count: 0, ts, verified_at: ts, confidence: 0.75,
-                        audit_trail: [{ ts, action: 'cls_ci_fixed' }], version: 3,
-                    };
-                    await redis.rpush(`cachly:lessons:${slug}`, JSON.stringify(lessonObj));
-                    await redis.set(`cachly:lesson:best:${slug}`, JSON.stringify(lessonObj));
-                }
-                else if (isBroken) {
-                    const causeId = ckgSlug(`cause:${ckgSlug(job)}`);
-                    await ckgUpsertNode(redis, causeId, 'cause', 'ci-break');
-                    await ckgUpdateEdge(redis, conceptId, 'causes', causeId, false);
-                }
-                await redis.rpush(clsKey, JSON.stringify({ source, payload: { status, prev_status, job }, ts }));
-                await redis.ltrim(clsKey, -200, -1);
-                const statusIcon = isFixed ? '✅ Fixed' : isBroken ? '🔴 Broken' : '📊 Recorded';
-                return [
-                    `📨 **CLS Ingested: ci_outcome**`, '',
-                    `${statusIcon}: \`${job}\` — ${prev_status || '?'} → ${status}`,
-                    isFixed ? `🔧 CKG \`fixes\` edge added (75% confidence)` : isBroken ? `⚡ CKG \`causes\` edge added` : `📊 State recorded`,
-                    `💡 Lesson: \`${slug}\`  |  Predict: \`brain_predict(context="${job}")\``,
-                ].join('\n');
-            }
-            if (source === 'ide_diagnostic') {
-                const error = String(payload.error ?? '');
-                const fix = String(payload.fix ?? '');
-                const file = String(payload.file ?? '');
-                const errorConcept = extractProblemConcept(error) ?? 'unknown-error';
-                const slug = `debug:${ckgSlug(errorConcept)}`;
-                const conceptId = ckgSlug(slug);
-                const problemId = ckgSlug(`problem:${errorConcept}`);
-                await ckgUpsertNode(redis, conceptId, 'debug', 'diagnostic');
-                await ckgUpsertNode(redis, problemId, 'problem', 'compiler-error');
-                await ckgUpdateEdge(redis, conceptId, 'fixes', problemId, true);
-                const lessonObj = {
-                    topic: slug, outcome: 'success', what_worked: fix, what_failed: error,
-                    context: `CLS/ide: ${file}`, severity: 'minor',
-                    file_paths: file ? [file] : [], commands: [], tags: ['cls', 'ide-diagnostic'],
-                    depends_on: [], recall_count: 0, ts, verified_at: ts, confidence: 0.65,
-                    audit_trail: [{ ts, action: 'cls_ide_diagnostic' }], version: 3,
-                };
-                await redis.rpush(`cachly:lessons:${slug}`, JSON.stringify(lessonObj));
-                const existingL = await redis.get(`cachly:lesson:best:${slug}`);
-                if (!existingL)
-                    await redis.set(`cachly:lesson:best:${slug}`, JSON.stringify(lessonObj));
-                await redis.rpush(clsKey, JSON.stringify({ source, payload: { error: error.slice(0, 60), fix: fix.slice(0, 60), file }, ts }));
-                await redis.ltrim(clsKey, -200, -1);
-                return [
-                    `📨 **CLS Ingested: ide_diagnostic**`, '',
-                    `Error: \`${error.slice(0, 80)}\``,
-                    `Fix: ${fix.slice(0, 100)}`,
-                    file ? `File: \`${file}\`` : '',
-                    '', `🕸️ CKG: \`${conceptId}\` → fixes → \`${problemId}\`  |  Lesson: \`${slug}\``,
-                ].filter(l => l !== '').join('\n');
-            }
-            return `❌ Unknown CLS source: "${source}". Valid: git_commit, ci_outcome, ide_diagnostic`;
-        }
-        // ── Layer 5: CLS — cls_install_hooks ─────────────────────────────────────
-        case 'cls_install_hooks': {
-            const { instance_id, repo_path = '.', hooks = ['git', 'ci'] } = args;
-            const hooksArr = Array.isArray(hooks) ? hooks : ['git', 'ci'];
-            const lines = [`🔌 **CLS Hook Installation Guide**\n`];
-            if (hooksArr.includes('git')) {
-                const hookScript = buildClsPostCommitHook(instance_id);
-                lines.push(`### Git post-commit hook`);
-                lines.push(`**Quick install (run once per repo):**`);
-                lines.push('```sh');
-                lines.push(`cat > ${repo_path}/.git/hooks/post-commit << 'HOOK'`);
-                lines.push(hookScript);
-                lines.push(`HOOK`);
-                lines.push(`chmod +x ${repo_path}/.git/hooks/post-commit`);
-                lines.push('```');
-                lines.push(`After install: every \`git commit\` automatically updates your brain's CKG.`);
-                lines.push('');
-            }
-            if (hooksArr.includes('ci')) {
-                lines.push(`### GitHub Actions CI outcome hook`);
-                lines.push(`**Add at the end of each job** (after build/test steps):`);
-                lines.push('```yaml');
-                lines.push(`- name: cachly CLS — record CI outcome`);
-                lines.push(`  if: always()`);
-                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(`      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(`    " 2>/dev/null || true`);
-                lines.push(`  env:`);
-                lines.push(`    CACHLY_JWT: \${{ secrets.CACHLY_JWT }}`);
-                lines.push('```');
-                lines.push('');
-            }
-            lines.push(`💡 Once installed: \`brain_search(query="cls")\` to verify events are arriving.`);
-            lines.push(`📊 Monitor CKG growth: \`ckg_inspect(concept="ci")\` or \`ckg_inspect(concept="fix")\``);
-            return lines.join('\n');
-        }
-        // ── Layer 6: FedBrain — fedbrain_contribute ───────────────────────────────
-        case 'fedbrain_contribute': {
-            const { instance_id, lesson_key, visibility = 'public' } = args;
-            const redis = await getConnection(instance_id);
-            const raw = await redis.get(`cachly:lesson:best:${lesson_key}`);
-            if (!raw)
-                return `❌ Lesson \`${lesson_key}\` not found. Store it first with \`learn_from_attempts\`.`;
-            const lesson = safeJsonParse(raw, null);
-            if (!lesson)
-                return `❌ Lesson \`${lesson_key}\` data is corrupted. Re-store with \`learn_from_attempts\`.`;
-            const domainTokens = [lesson.topic.split(':')[0], ...(lesson.tags ?? [])].filter(Boolean);
-            const domainFingerprint = [...new Set(domainTokens)].sort().join(',');
-            // HMAC certificate ID (non-reversible, privacy-safe)
-            const certContent = `${lesson.topic}:${lesson.outcome}:${lesson.what_worked}`;
-            const certId = createHmac('sha256', `cachly-fedbrain:${instance_id}`).update(certContent).digest('hex').slice(0, 16);
-            const cert = {
-                cert_id: certId, lesson_key, visibility,
-                domain_fingerprint: domainFingerprint,
-                contributed_at: new Date().toISOString(),
-                confirm_count: 0,
-                trust_score: lesson.outcome === 'success' ? 0.85 : 0.5,
-            };
-            await redis.set(`cachly:fedbrain:cert:${certId}`, JSON.stringify(cert));
-            await redis.sadd('cachly:fedbrain:contributed', certId);
-            // Try global commons via syndication API
-            let syndicationResult;
-            try {
-                await apiFetch('/api/v1/syndication/contribute', {
-                    method: 'POST',
-                    body: JSON.stringify({
-                        topic: lesson.topic, outcome: lesson.outcome,
-                        what_worked: lesson.what_worked, what_failed: lesson.what_failed ?? '',
-                        severity: lesson.severity ?? 'major', cert_id: certId,
-                        domain_fingerprint: domainFingerprint, visibility,
-                    }),
-                });
-                syndicationResult = `✅ Contributed to global commons`;
-            }
-            catch {
-                syndicationResult = `📦 Stored locally (commons API unavailable — will sync when online)`;
-            }
-            return [
-                `🌐 **FedBrain Contribute: "${lesson_key}"**`, '',
-                `📜 Certificate: \`${certId}\``,
-                `🏷️ Domain fingerprint: ${domainTokens.slice(0, 6).map(t => `\`${t}\``).join(', ')}`,
-                `🔒 Visibility: ${visibility}`,
-                '', syndicationResult, '',
-                `💡 At 10 independent confirms → 🏆 Gold Standard`,
-                `🔍 Search: \`fedbrain_search(query="${lesson.topic.split(':').slice(-1)[0]}")\``,
-            ].join('\n');
-        }
-        // ── Layer 6: FedBrain — fedbrain_search ──────────────────────────────────
-        case 'fedbrain_search': {
-            const { instance_id, query, context_hints = [], limit = 10 } = args;
-            const redis = await getConnection(instance_id);
-            // Build local domain context from contributed certificates + explicit hints
-            const contribIds = await redis.smembers('cachly:fedbrain:contributed');
-            const localDomains = new Map();
-            for (const certId of contribIds.slice(0, 30)) {
-                const certRaw = await redis.get(`cachly:fedbrain:cert:${certId}`);
-                if (!certRaw)
-                    continue;
-                try {
-                    const cert = JSON.parse(certRaw);
-                    for (const d of (cert.domain_fingerprint ?? '').split(',').filter(Boolean)) {
-                        localDomains.set(d, (localDomains.get(d) ?? 0) + 1);
-                    }
-                }
-                catch { /* skip */ }
-            }
-            for (const hint of (Array.isArray(context_hints) ? context_hints : [])) {
-                localDomains.set(hint.toLowerCase(), (localDomains.get(hint.toLowerCase()) ?? 0) + 2);
-            }
-            let results = [];
-            // Set when the commons API call fails — the results below come from this
-            // single machine's local lessons, not from the confirmed global network.
-            // The reply must say so; printing them as unlabeled commons hits would
-            // dress a network outage up as confirmed world knowledge.
-            let usedLocalFallback = false;
-            try {
-                const params = new URLSearchParams({ q: query, limit: String(Math.min(limit * 2, 50)) });
-                const res = await apiFetch(`/api/v1/syndication/search?${params}`);
-                results = res.results ?? [];
-            }
-            catch {
-                usedLocalFallback = true;
-                // Fallback: search local lessons
-                const lessonKeys = [];
-                const lStream = redis.scanStream({ match: 'cachly:lesson:best:*', count: 200 });
-                await new Promise((res, rej) => { lStream.on('data', (b) => lessonKeys.push(...b)); lStream.on('end', res); lStream.on('error', rej); });
-                for (const k of lessonKeys.slice(0, 60)) {
-                    const r = await redis.get(k);
-                    if (!r)
-                        continue;
-                    try {
-                        const l = JSON.parse(r);
-                        const haystack = `${l.topic} ${l.what_worked ?? ''} ${l.what_failed ?? ''}`.toLowerCase();
-                        if (query.toLowerCase().split(/\s+/).some(t => t.length > 2 && haystack.includes(t))) {
-                            results.push({ id: k.split(':').pop() ?? k, topic: l.topic, category: l.topic.split(':')[0], outcome: l.outcome, what_worked: l.what_worked ?? '', severity: l.severity ?? 'major', confirm_count: 0, created_at: l.ts ?? new Date().toISOString() });
-                        }
-                    }
-                    catch { /* skip */ }
-                }
-            }
-            const fallbackNotice = usedLocalFallback
-                ? ` — ⚠️ Commons unreachable, local fallback (this machine only, not confirmed by the network)`
-                : '';
-            if (results.length === 0) {
-                return [`🌐 **FedBrain Search: "${query}"**${fallbackNotice}`, '', `No results. Contribute: \`fedbrain_contribute(lesson_key="fix:...")\``].join('\n');
-            }
-            // Context-weighted ranking
-            const ranked = results.map(r => {
-                const rDomains = (r.domain_fingerprint ?? r.category ?? '').split(',').filter(Boolean);
-                const overlap = rDomains.reduce((s, d) => s + (localDomains.get(d) ?? 0), 0);
-                const contextScore = localDomains.size > 0 ? overlap / Math.max(1, localDomains.size + rDomains.length) : 0;
-                const confirmedScore = Math.min(1, r.confirm_count / 10);
-                const weightedScore = (contextScore * 0.4) + (confirmedScore * 0.4) + (r.outcome === 'success' ? 0.2 : 0);
-                // A fallback result never earned network confirmations — it cannot be a
-                // Gold Standard no matter what confirm_count says.
-                return { ...r, weightedScore, isGoldStandard: !usedLocalFallback && r.confirm_count >= 10 };
-            }).sort((a, b) => b.weightedScore - a.weightedScore).slice(0, limit);
-            const lines = [`🌐 **FedBrain Search: "${query}"** — ${ranked.length} result${ranked.length !== 1 ? 's' : ''} (context-weighted)${fallbackNotice}\n`];
-            for (const r of ranked) {
-                const icon = r.outcome === 'success' ? '✅' : r.outcome === 'failure' ? '❌' : '⚠️';
-                const goldBadge = r.isGoldStandard ? ' 🏆 _Gold Standard_' : (!usedLocalFallback && r.confirm_count >= 3) ? ` ✓${r.confirm_count}` : '';
-                const ctxPct = Math.round(r.weightedScore * 100);
-                lines.push(`${icon}${goldBadge} **\`${r.topic}\`** [ctx: ${ctxPct}%]`);
-                if (r.what_worked)
-                    lines.push(`  ✅ ${r.what_worked.slice(0, 150)}`);
-                if (r.what_failed)
-                    lines.push(`  ❌ ${r.what_failed.slice(0, 80)}`);
-                lines.push(`  _${r.confirm_count} confirm${r.confirm_count !== 1 ? 's' : ''}  |  id: \`${r.id}\`_`, '');
-            }
-            if (localDomains.size > 0) {
-                const topDomains = [...localDomains.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([d, n]) => `\`${d}\`(${n})`).join(', ');
-                lines.push(`🎯 Your context: ${topDomains}`);
-            }
-            lines.push(`💡 Confirm a result: \`fedbrain_confirm(id="<id>", topic="<topic>", outcome="worked")\``);
-            return lines.join('\n');
-        }
-        // ── Layer 6: FedBrain — fedbrain_confirm ─────────────────────────────────
-        case 'fedbrain_confirm': {
-            // The commons confirm endpoint keys on the syndicated lesson id
-            // (POST /api/v1/syndication/:id/confirm). `id` comes from fedbrain_search
-            // results; `topic` is kept for the LOCAL CKG confidence edge and display.
-            const { instance_id, id, topic, outcome } = args;
-            if (!id) {
-                return [
-                    `❌ **FedBrain Confirm** needs the lesson \`id\` from \`fedbrain_search\` results.`,
-                    `Run \`fedbrain_search(query="...")\`, copy the id shown next to a result,`,
-                    `then: \`fedbrain_confirm(id="<id>", topic="<topic>", outcome="worked")\`.`,
-                ].join('\n');
-            }
-            const redis = await getConnection(instance_id);
-            const ts = new Date().toISOString();
-            const confirmEntry = JSON.stringify({ id, topic, outcome, ts });
-            await redis.rpush('cachly:fedbrain:confirmations', confirmEntry);
-            await redis.ltrim('cachly:fedbrain:confirmations', -200, -1);
-            // Update local CKG confidence (only when we know which topic this maps to).
-            const worked = outcome === 'worked';
-            const partial = outcome === 'partially_worked';
-            if (topic) {
-                await ckgUpdateEdge(redis, ckgSlug(topic), 'fixes', ckgSlug(`syndicated:${topic}`), worked, partial);
-            }
-            // Propagate to global commons — id in the PATH, body ignored server-side.
-            let propResult;
-            try {
-                await apiFetch(`/api/v1/syndication/${encodeURIComponent(id)}/confirm`, { method: 'POST' });
-                propResult = `✅ Confirmation propagated to global commons`;
-            }
-            catch {
-                await redis.rpush('cachly:fedbrain:pending_confirms', confirmEntry);
-                await redis.ltrim('cachly:fedbrain:pending_confirms', -50, -1);
-                propResult = `📦 Queued locally (API unavailable — will propagate on next online session)`;
-            }
-            const icon = worked ? '✅' : partial ? '⚠️' : '❌';
-            const label = topic ?? id;
-            return [
-                `${icon} **FedBrain Confirm: "${label}"** → ${outcome}`, '',
-                propResult, '',
-                topic
-                    ? `🕸️ CKG confidence ${worked || partial ? 'boosted' : 'reduced'} for \`${ckgSlug(topic)}\``
-                    : `🕸️ Local CKG unchanged (pass \`topic\` to also update your own confidence graph)`,
-                `💡 Your confirmation helps other brains worldwide.`,
-                `📊 Status: \`fedbrain_status(instance_id="...")\``,
-            ].join('\n');
-        }
-        // ── Layer 6: FedBrain — fedbrain_status ──────────────────────────────────
-        case 'fedbrain_status': {
-            const { instance_id } = args;
-            const redis = await getConnection(instance_id);
-            const contribIds = await redis.smembers('cachly:fedbrain:contributed');
-            const confirmsRaw = await redis.lrange('cachly:fedbrain:confirmations', -10, -1);
-            const pendingConfirms = await redis.llen('cachly:fedbrain:pending_confirms');
-            const confirms = confirmsRaw.map(r => { try {
-                return JSON.parse(r);
-            }
-            catch {
-                return null;
-            } }).filter(Boolean);
-            const certDetails = [];
-            for (const certId of contribIds.slice(0, 15)) {
-                const raw = await redis.get(`cachly:fedbrain:cert:${certId}`);
-                if (!raw)
-                    continue;
-                try {
-                    const cert = JSON.parse(raw);
-                    certDetails.push({ cert_id: cert.cert_id, lesson_key: cert.lesson_key, confirm_count: cert.confirm_count ?? 0, trust_score: cert.trust_score ?? 0.5, isGold: (cert.confirm_count ?? 0) >= 10 });
-                }
-                catch { /* skip */ }
-            }
-            const lines = [
-                `🌐 **FedBrain Status**\n`,
-                `### 📤 Contributed Lessons: ${contribIds.length}`,
-            ];
-            if (certDetails.length > 0) {
-                for (const c of certDetails) {
-                    const goldBadge = c.isGold ? ' 🏆 Gold Standard' : '';
-                    const confBar = '█'.repeat(Math.min(10, c.confirm_count)) + '░'.repeat(Math.max(0, 10 - c.confirm_count));
-                    lines.push(`  \`${c.lesson_key}\` [${confBar}] ×${c.confirm_count}${goldBadge}`);
-                }
-            }
-            else {
-                lines.push(`  _None yet. Contribute with \`fedbrain_contribute(lesson_key="fix:...")\`_`);
-            }
-            lines.push('', `### 📥 Recent Confirmations: ${confirms.length}`);
-            if (confirms.length > 0) {
-                for (const c of confirms.slice(-5)) {
-                    const icon = c.outcome === 'worked' ? '✅' : c.outcome === 'partially_worked' ? '⚠️' : '❌';
-                    lines.push(`  ${icon} \`${c.topic}\` — ${c.outcome} (${new Date(c.ts).toLocaleDateString('de-DE')})`);
-                }
-            }
-            else {
-                lines.push(`  _None yet. Confirm syndicated lessons with \`fedbrain_confirm\`_`);
-            }
-            if (pendingConfirms > 0) {
-                lines.push('', `⚠️ ${pendingConfirms} confirmation${pendingConfirms !== 1 ? 's' : ''} pending propagation`);
-            }
-            lines.push('', '---', `**Contribute:** \`fedbrain_contribute(lesson_key="fix:...")\``, `**Search:** \`fedbrain_search(query="...")\``, `**Confirm:** \`fedbrain_confirm(id="...", topic="...", outcome="worked")\``);
-            return lines.join('\n');
-        }
-        // ── Layer 6: FedBrain — brain_federate ───────────────────────────────────
-        case 'brain_federate': {
-            const { instance_id, source, domain, min_confidence = 0.6, dry_run = false } = args;
-            if (instance_id === source)
-                return `❌ Source and destination cannot be the same brain.`;
-            const destRedis = await getConnection(instance_id);
-            const srcRedis = await getConnection(source);
-            const domainPattern = domain === '*' ? 'cachly:ckg:node:*' : `cachly:ckg:node:${domain}*`;
-            // Scan source CKG nodes matching the domain
-            const nodeKeys = [];
-            const nStream = srcRedis.scanStream({ match: domainPattern, count: 100 });
-            await new Promise((res, rej) => { nStream.on('data', (b) => nodeKeys.push(...b)); nStream.on('end', res); nStream.on('error', rej); });
-            if (nodeKeys.length === 0) {
-                return [
-                    `🧠 **brain_federate: "${domain}"**`, '',
-                    `No CKG nodes found in source brain for domain \`${domain}\`.`,
-                    `The source brain may not have knowledge in this area yet.`,
-                    `Try: \`fedbrain_search(query="${domain}")\` to find global commons knowledge instead.`,
-                ].join('\n');
-            }
-            // Transfer nodes + their outgoing edges
-            let nodesTransferred = 0;
-            let edgesTransferred = 0;
-            let lessonsTransferred = 0;
-            let skippedLowConf = 0;
-            const transferLog = [];
-            for (const nk of nodeKeys) {
-                const nodeRaw = await srcRedis.get(nk);
-                if (!nodeRaw)
-                    continue;
-                let node;
-                try {
-                    node = JSON.parse(nodeRaw);
-                }
-                catch {
-                    continue;
-                }
-                if (!dry_run)
-                    await destRedis.set(nk, nodeRaw);
-                nodesTransferred++;
-                // Transfer outgoing edges for this node
-                const edgeKeys = await srcRedis.smembers(`cachly:ckg:idx:from:${node.id}`);
-                for (const ek of edgeKeys) {
-                    const edgeRaw = await srcRedis.get(ek);
-                    if (!edgeRaw)
-                        continue;
-                    let edge;
-                    try {
-                        edge = JSON.parse(edgeRaw);
-                    }
-                    catch {
-                        continue;
-                    }
-                    if (edge.confidence < min_confidence) {
-                        skippedLowConf++;
-                        continue;
-                    }
-                    if (!dry_run) {
-                        await destRedis.set(ek, edgeRaw);
-                        await destRedis.sadd(`cachly:ckg:idx:from:${edge.from}`, ek);
-                        await destRedis.sadd(`cachly:ckg:idx:to:${edge.to}`, ek);
-                    }
-                    edgesTransferred++;
-                }
-                // Transfer best-lesson for the same topic slug
-                const lessonKey = `cachly:lesson:best:${node.id}`;
-                const lessonRaw = await srcRedis.get(lessonKey);
-                if (lessonRaw) {
-                    if (!dry_run)
-                        await destRedis.set(lessonKey, lessonRaw);
-                    lessonsTransferred++;
-                    if (transferLog.length < 8) {
-                        try {
-                            const l = JSON.parse(lessonRaw);
-                            const icon = l.outcome === 'success' ? '✅' : l.outcome === 'failure' ? '❌' : '⚠️';
-                            transferLog.push(`  ${icon} \`${l.topic}\` — ${(l.what_worked ?? '').slice(0, 80)}`);
-                        }
-                        catch { /* skip */ }
-                    }
-                }
-            }
-            // Record federation provenance
-            if (!dry_run) {
-                const provEntry = JSON.stringify({
-                    source, domain, transferred_at: new Date().toISOString(),
-                    nodes: nodesTransferred, edges: edgesTransferred, lessons: lessonsTransferred,
-                });
-                await destRedis.rpush('cachly:fedbrain:federations', provEntry);
-                await destRedis.ltrim('cachly:fedbrain:federations', -50, -1);
-            }
-            const dryTag = dry_run ? ' (DRY RUN — no writes)' : '';
-            const lines = [
-                `🧠 **brain_federate: "${domain}"**${dryTag}`, '',
-                `📤 Source: \`${source}\``,
-                `📥 Destination: \`${instance_id}\``,
-                `🔍 Domain filter: \`${domain}\`  |  min_confidence: ${min_confidence}`,
-                '',
-                `### Transfer Summary`,
-                `  🕸️ CKG nodes:  ${nodesTransferred}`,
-                `  🔗 CKG edges:  ${edgesTransferred}  (${skippedLowConf} skipped, confidence < ${min_confidence})`,
-                `  📚 Lessons:    ${lessonsTransferred}`,
-                '',
-            ];
-            if (transferLog.length > 0) {
-                lines.push(`### Sample lessons transferred:`, ...transferLog);
-                if (lessonsTransferred > transferLog.length)
-                    lines.push(`  _... and ${lessonsTransferred - transferLog.length} more_`);
-                lines.push('');
-            }
-            if (dry_run) {
-                lines.push(`💡 Run without \`dry_run: true\` to apply the transfer.`);
-            }
-            else {
-                lines.push(`✅ Transfer complete. Your brain now has the \`${domain}\` knowledge from \`${source}\`.`);
-                lines.push(`🔍 Explore: \`ckg_inspect(concept="${domain}")\`  |  \`recall_best_solution(topic="${domain}:...")\``);
-            }
-            return lines.join('\n');
-        }
-        // ── crystal_view ──────────────────────────────────────────────────────────
-        case 'crystal_view': {
-            const { instance_id, show_raw = false } = args;
-            const redis = await getConnection(instance_id);
-            const raw = await redis.get('cachly:crystal:latest');
-            if (!raw) {
-                return [
-                    `💎 **Memory Crystal: not yet created**`, '',
-                    `No crystal found. Create one with \`memory_crystalize()\` to compress your accumulated wisdom.`,
-                    '', `💡 Tip: run \`memory_crystalize\` monthly for best results.`,
-                ].join('\n');
-            }
-            const crystal = safeJsonParse(raw, null);
-            if (!crystal)
-                return `❌ Memory Crystal data is corrupted. Re-create with \`memory_crystalize()\`.`;
-            const age = Math.floor((Date.now() - new Date(crystal.ts).getTime()) / 86400000);
-            const freshEmoji = age <= 7 ? '🟢' : age <= 30 ? '🟡' : '🔴';
-            const lines = [
-                `💎 **Memory Crystal: ${crystal.label}**`, '',
-                `📅 Created: ${new Date(crystal.ts).toLocaleDateString('de-DE')} (${age}d ago ${freshEmoji})`,
-                `📊 Compressed from: ${crystal.created_from}`,
-                `🗂️ Categories: ${crystal.categories.slice(0, 10).map(c => `\`${c}\``).join(', ')}${crystal.categories.length > 10 ? ` +${crystal.categories.length - 10} more` : ''}`,
-                '',
-                `**🔑 Top patterns (${crystal.top_patterns.length}):**`,
-            ];
-            for (const p of crystal.top_patterns) {
-                lines.push(`  • **${p.category}** (${p.count}×): ${p.insight.slice(0, 110)}`);
-            }
-            if (age > 30) {
-                lines.push('', `⚠️ Crystal is ${age}d old — run \`memory_crystalize()\` to refresh it.`);
-            }
-            if (show_raw) {
-                lines.push('', '```json', JSON.stringify(crystal, null, 2), '```');
-            }
-            // Team Crystal (W8): the cross-person, causal layer — shown alongside the
-            // per-brain crystal when team_crystallize has been run.
-            const teamRaw = await redis.get('cachly:crystal:team:latest').catch(() => null);
-            if (teamRaw) {
-                const tc = safeJsonParse(teamRaw, null);
-                if (tc && tc.patterns?.length) {
-                    const tcAge = Math.floor((Date.now() - new Date(tc.ts).getTime()) / 86400000);
-                    lines.push('', `---`, `💠 **Team Crystal: ${tc.label}** _(${tcAge}d ago · ${tc.contributors} contributors)_`, `_Fixes multiple teammates independently converged on — the team-wide layer:_`);
-                    for (const p of tc.patterns.slice(0, 5)) {
-                        lines.push(`  • 🧩 **${p.concept}** — ${p.author_count} people (${p.authors.map(a => `@${a}`).join(', ')}): ${p.convergent_fix.slice(0, 90)}`);
-                    }
-                }
-            }
-            lines.push('', `💡 Refresh: \`memory_crystalize()\` · \`team_crystallize()\`  |  Recover: \`compact_recover(instance_id="...")\``);
-            return lines.join('\n');
-        }
-        // ── compact_recover ───────────────────────────────────────────────────────
-        case 'compact_recover': {
-            const { instance_id, focus = '' } = args;
-            const redis = await getConnection(instance_id);
-            const lines = [`🔁 **Compact Recovery Briefing**\n`];
-            lines.push(`> *Call this first after any context limit hit. Reconstructs where you left off.*\n`);
-            // 1. Memory Crystal
-            const crystalRaw = await redis.get('cachly:crystal:latest');
-            if (crystalRaw) {
-                const crystal = safeJsonParse(crystalRaw, null);
-                if (crystal) {
-                    lines.push(`### 💎 Memory Crystal: ${crystal.label}`);
-                    lines.push(`Compressed from ${crystal.session_count} sessions, ${crystal.lesson_count} lessons.`);
-                    const topN = focus
-                        ? crystal.top_patterns.filter(p => p.category.toLowerCase().includes(focus.toLowerCase()) || p.insight.toLowerCase().includes(focus.toLowerCase())).slice(0, 4)
-                        : crystal.top_patterns.slice(0, 4);
-                    for (const p of topN)
-                        lines.push(`  • **${p.category}**: ${p.insight.slice(0, 100)}`);
-                    lines.push('');
-                }
-            }
-            // 2. Last session summary
-            const lastSession = await redis.get('cachly:session:last');
-            if (lastSession) {
-                const sess = safeJsonParse(lastSession, null);
-                if (sess) {
-                    lines.push(`### 🕐 Last Session`);
-                    if (sess.focus)
-                        lines.push(`Focus: _${sess.focus}_`);
-                    if (sess.summary)
-                        lines.push(`Summary: ${sess.summary.slice(0, 300)}`);
-                    lines.push('');
-                }
-            }
-            // 3. Session handoff
-            const handoff = await redis.get('cachly:session:handoff');
-            if (handoff) {
-                const h = safeJsonParse(handoff, null);
-                if (h) {
-                    lines.push(`### 📋 Handoff (from last window)`);
-                    if (h.context_summary)
-                        lines.push(`Context: ${h.context_summary.slice(0, 200)}`);
-                    if (h.remaining_tasks?.length) {
-                        lines.push(`Remaining tasks:`);
-                        for (const t of h.remaining_tasks.slice(0, 5))
-                            lines.push(`  • ${t}`);
-                    }
-                    if (h.instructions)
-                        lines.push(`⚠️ Instructions: ${h.instructions.slice(0, 200)}`);
-                    if (h.blocked_on)
-                        lines.push(`🚧 Blocked on: ${h.blocked_on}`);
-                    lines.push('');
-                }
-            }
-            // 4. WIP registry
-            const wipRaw = await redis.get('cachly:ctx:wip-registry');
-            if (wipRaw) {
-                const wip = safeJsonParse(wipRaw, null);
-                if (wip?.content) {
-                    lines.push(`### 🔧 WIP Registry`);
-                    lines.push(wip.content.slice(0, 400));
-                    lines.push('');
-                }
-            }
-            // 5. Open failures (roadmap with status=blocked/in_progress)
-            const roadmapKeys = [];
-            const rStream = redis.scanStream({ match: 'cachly:roadmap:*', count: 100 });
-            await new Promise((res, rej) => { rStream.on('data', (b) => roadmapKeys.push(...b)); rStream.on('end', res); rStream.on('error', rej); });
-            const openItems = [];
-            for (const k of roadmapKeys.slice(0, 30)) {
-                const r = await redis.get(k);
-                if (!r)
-                    continue;
-                try {
-                    const item = JSON.parse(r);
-                    if (item.status === 'in_progress' || item.status === 'blocked')
-                        openItems.push({ title: item.title ?? k, status: item.status, priority: item.priority });
-                }
-                catch { /* skip */ }
-            }
-            if (openItems.length > 0) {
-                lines.push(`### 🚧 Open Items`);
-                for (const i of openItems.slice(0, 5))
-                    lines.push(`  • [${i.status}] ${i.title}`);
-                lines.push('');
-            }
-            // 6. Focus-relevant lessons
-            if (focus) {
-                const lessonKeys = [];
-                const lStream = redis.scanStream({ match: 'cachly:lesson:best:*', count: 200 });
-                await new Promise((res, rej) => { lStream.on('data', (b) => lessonKeys.push(...b)); lStream.on('end', res); lStream.on('error', rej); });
-                const relevant = [];
-                for (const k of lessonKeys) {
-                    const r = await redis.get(k);
-                    if (!r)
-                        continue;
-                    try {
-                        const l = JSON.parse(r);
-                        if (l.topic.toLowerCase().includes(focus.toLowerCase()) && l.what_worked) {
-                            relevant.push({ topic: l.topic, what_worked: l.what_worked });
-                        }
-                    }
-                    catch { /* skip */ }
-                }
-                if (relevant.length > 0) {
-                    lines.push(`### 💡 Relevant Lessons for "${focus}"`);
-                    for (const l of relevant.slice(0, 4))
-                        lines.push(`  • **${l.topic}**: ${l.what_worked.slice(0, 100)}`);
-                    lines.push('');
-                }
-            }
-            if (lines.length <= 3) {
-                lines.push(`_No brain data found. Start accumulating knowledge with \`learn_from_attempts\` and \`session_start\`._`);
-            }
-            lines.push(`---`, `🧠 Brain is ready. Continue your work — full context restored.`);
-            return lines.join('\n');
-        }
-        // ── brain_from_git ────────────────────────────────────────────────────────
-        case 'brain_from_git': {
-            const startedAt = Date.now();
-            const { instance_id, repo_path = '.', limit = 100, branch = 'HEAD', since = '', incremental = true } = args;
-            const redis = await getConnection(instance_id);
-            const { execSync } = await import('node:child_process');
-            const { resolve } = await import('node:path');
-            const repoDir = resolve(repo_path);
-            const maxCommits = Math.min(Number(limit) || 100, 500);
-            // Semaphore: max 10 concurrent git subprocesses per MCP process
-            await _gitSemAcquire();
-            try {
-                // Verify it's a git repo
-                try {
-                    execSync('git rev-parse --git-dir', { cwd: repoDir, stdio: 'pipe' });
-                }
-                catch {
-                    return `❌ Not a git repository: \`${repoDir}\`. Pass \`repo_path\` pointing to a git checkout.`;
-                }
-                // Incremental mode: resume from last processed commit SHA
-                const lastShaKey = `cachly:brain_from_git:last_sha:${Buffer.from(repoDir).toString('base64').slice(0, 32)}`;
-                let lastSha = '';
-                let isIncremental = false;
-                if (incremental !== false && !since) {
-                    lastSha = (await redis.get(lastShaKey)) ?? '';
-                    isIncremental = Boolean(lastSha);
-                }
-                // 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:"COMMIT|||%H|||%s|||%ad|||%an" --date=short --no-merges --name-only -n ${maxCommits}`;
-                let logOutput = '';
-                try {
-                    logOutput = execSync(logCmd, { cwd: repoDir, encoding: 'utf-8', stdio: 'pipe' });
-                }
-                catch (e) {
-                    return `❌ git log failed: ${e.message}. Check \`repo_path\` and \`branch\`.`;
-                }
-                const commits = [];
-                let current = 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) {
-                        const norm = normalizeGitPath(line);
-                        if (norm)
-                            current.files.push(norm);
-                    }
-                }
-                if (current)
-                    commits.push(current);
-                if (commits.length === 0) {
-                    if (isIncremental) {
-                        return `✅ brain_from_git: Brain is up to date — no new commits since last run (last SHA: \`${lastSha.slice(0, 8)}\`).`;
-                    }
-                    // Empty repo — first contact must still leave the user with a working path,
-                    // not a bare warning (roadmap P1-5: onboarding-magic for empty/small repos).
-                    return buildFirstContactReport({
-                        repoDir, revRange, processed: 0, ingested: 0, skipped: 0,
-                        durationMs: Date.now() - startedAt, isIncremental: false,
-                        instanceId: instance_id, categories: [], suggestedQueries: [],
-                        emptyReason: `No commits found in \`${repoDir}\` on branch \`${branch}\`${since ? ` since ${since}` : ''}.`,
-                    });
-                }
-                // Pattern classifiers
-                const classifyCommit = (subject) => {
-                    const s = subject.toLowerCase();
-                    if (/\b(fix|fixed|fixes|bug|hotfix|patch|revert|resolve|closes? #\d+)\b/.test(s)) {
-                        const sev = /\b(critical|crash|security|auth|data loss|outage|prod|production)\b/.test(s) ? 'critical' : /\b(major|breaking|regression|hotfix)\b/.test(s) ? 'major' : 'minor';
-                        return { category: 'fix', outcome: 'success', severity: sev };
-                    }
-                    if (/\b(feat|feature|add|added|implement|new|introduce)\b/.test(s))
-                        return { category: 'feat', outcome: 'success', severity: 'minor' };
-                    if (/\b(refactor|clean|cleanup|improve|simplify|extract|rename)\b/.test(s))
-                        return { category: 'refactor', outcome: 'success', severity: 'minor' };
-                    if (/\b(perf|optimize|speed|cache|latency|memory|performance)\b/.test(s))
-                        return { category: 'perf', outcome: 'success', severity: 'major' };
-                    if (/\b(security|cve|auth|csrf|xss|sql|injection|sanitize|escape|encrypt)\b/.test(s))
-                        return { category: 'security', outcome: 'success', severity: 'critical' };
-                    if (/\b(deploy|ci|cd|build|docker|k8s|helm|infra|devops)\b/.test(s))
-                        return { category: 'deploy', outcome: 'success', severity: 'major' };
-                    if (/\b(test|spec|coverage|assert|mock|unit|integration)\b/.test(s))
-                        return { category: 'test', outcome: 'success', severity: 'minor' };
-                    return { category: 'chore', outcome: 'success', severity: 'minor' };
-                };
-                // Extract domain keywords from commit subject
-                const extractDomain = (subject) => {
-                    const s = subject.toLowerCase();
-                    const tokens = s.replace(/[^a-z0-9\s\-_]/g, ' ').split(/\s+/).filter(t => t.length > 3 && !['that', 'this', 'with', 'from', 'when', 'into', 'also', 'some', 'were'].includes(t));
-                    return tokens.slice(0, 3).join('-') || 'general';
-                };
-                const ts = new Date().toISOString();
-                let ingested = 0;
-                let skipped = 0;
-                const categoryCount = new Map();
-                const severityCount = new Map();
-                const seededTopics = [];
-                // Best commit to use for the proof-of-value recall — prefer a fix (highest signal).
-                let proofCandidate = null;
-                const total = commits.length;
-                const progressInterval = Math.max(1, Math.floor(total / 10)); // emit ~10 progress updates
-                let lastProgressAt = 0;
-                process.stderr.write(`\n🧠 brain_from_git: processing ${total} commits from ${repoDir}...\n`);
-                for (let i = 0; i < commits.length; i++) {
-                    const commit = commits[i];
-                    // Emit progress to stderr so editors can display it in MCP logs
-                    if (i - lastProgressAt >= progressInterval) {
-                        process.stderr.write(`   ⏳ Processing ${i}/${total} commits (${ingested} lessons so far)...\n`);
-                        lastProgressAt = i;
-                    }
-                    if (!commit.subject) {
-                        skipped++;
-                        continue;
-                    }
-                    const { category, outcome, severity } = classifyCommit(commit.subject);
-                    const domain = extractDomain(commit.subject);
-                    const topic = `${category}:${domain}`;
-                    categoryCount.set(category, (categoryCount.get(category) ?? 0) + 1);
-                    severityCount.set(severity, (severityCount.get(severity) ?? 0) + 1);
-                    seededTopics.push(topic);
-                    if (!proofCandidate || (category === 'fix' && !proofCandidate.topic.startsWith('fix:'))) {
-                        proofCandidate = { topic, subject: commit.subject };
-                    }
-                    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}`,
-                        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) }],
-                        version: 3,
-                    };
-                    // 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.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 — 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);
-                                // Phase 3: build the person↔person collaboration graph from shared files.
-                                await ckgRecordCollaboration(redis, fileId, personId);
-                            }
-                        }
-                        catch { /* non-critical */ }
-                    }
-                    ingested++;
-                }
-                process.stderr.write(`   ✅ brain_from_git complete: ${ingested}/${total} commits ingested\n\n`);
-                // Save the latest commit SHA for incremental runs
-                if (commits.length > 0 && commits[0]?.sha) {
-                    await redis.set(lastShaKey, commits[0].sha, 'EX', 90 * 24 * 3600); // expire after 90 days
-                }
-                _lastBrainFromGitCounts = {
-                    fixes: categoryCount.get('fix') ?? 0,
-                    features: categoryCount.get('feat') ?? 0,
-                    refactors: categoryCount.get('refactor') ?? 0,
-                    total: ingested,
-                };
-                // ── Proof of value: run ONE real recall against a topic seeded seconds ago,
-                // so the first-contact response already demonstrates a working search hit.
-                let proof = null;
-                if (proofCandidate && ingested > 0) {
-                    try {
-                        const hits = await keywordSearch(redis, ['cachly:lesson:best:*'], proofCandidate.subject, 1);
-                        if (hits.length > 0) {
-                            const parsed = safeJsonParse(hits[0].content, {});
-                            proof = {
-                                query: proofCandidate.subject.slice(0, 80),
-                                topic: parsed.topic ?? hits[0].key.replace('cachly:lesson:best:', ''),
-                                snippet: (parsed.what_worked ?? '').slice(0, 120) || proofCandidate.subject.slice(0, 120),
-                            };
-                        }
-                    }
-                    catch { /* proof is best-effort — never fail the seeding response */ }
-                }
-                return buildFirstContactReport({
-                    repoDir, revRange,
-                    processed: commits.length, ingested, skipped,
-                    durationMs: Date.now() - startedAt,
-                    isIncremental, lastSha,
-                    instanceId: instance_id,
-                    categories: [...categoryCount.entries()].sort((a, b) => b[1] - a[1]),
-                    severities: [...severityCount.entries()].sort((a, b) => b[1] - a[1]),
-                    proof,
-                    suggestedQueries: suggestRecallQueries(seededTopics, instance_id),
-                });
-            }
-            finally {
-                _gitSemRelease();
-            }
-        }
-        // ── brain_from_ci ─────────────────────────────────────────────────────────
-        case 'brain_from_ci': {
-            const { instance_id, outcomes } = args;
-            const redis = await getConnection(instance_id);
-            const ts = Date.now();
-            let fixes = 0;
-            let breaks = 0;
-            let stable = 0;
-            const total = outcomes.length;
-            for (const entry of outcomes) {
-                const status = String(entry.status ?? '');
-                const prev_status = String(entry.prev_status ?? '');
-                const job = String(entry.job ?? 'unknown');
-                const ciCtx = String(entry.context ?? '');
-                const isFixed = ['failure', 'red', 'error'].includes(prev_status) && ['success', 'green', 'passed'].includes(status);
-                const isBroken = ['success', 'green', 'passed'].includes(prev_status) && ['failure', 'red', 'error'].includes(status);
-                const slug = `ci:${ckgSlug(job)}`;
-                const conceptId = ckgSlug(slug);
-                await ckgUpsertNode(redis, conceptId, 'ci', 'job');
-                if (isFixed) {
-                    const problemId = ckgSlug(`problem:${ckgSlug(job)}`);
-                    await ckgUpsertNode(redis, problemId, 'problem', 'ci-failure');
-                    await ckgUpdateEdge(redis, conceptId, 'fixes', problemId, true);
-                    const lessonObj = {
-                        topic: slug, outcome: 'success',
-                        what_worked: `CI job "${job}" went ${prev_status} → ${status}`,
-                        what_failed: `Job "${job}" was failing`, context: `brain_from_ci: ${ciCtx}`,
-                        severity: 'major', file_paths: [], commands: [], tags: ['brain_from_ci', 'ci'],
-                        depends_on: [], recall_count: 0, ts, verified_at: ts, confidence: 0.65,
-                        audit_trail: [{ ts, action: 'brain_from_ci_fixed' }], version: 3,
-                    };
-                    await redis.rpush(`cachly:lessons:${slug}`, JSON.stringify(lessonObj));
-                    await redis.ltrim(`cachly:lessons:${slug}`, -100, -1);
-                    await redis.set(`cachly:lesson:best:${slug}`, JSON.stringify(lessonObj));
-                    fixes++;
-                }
-                else if (isBroken) {
-                    const causeId = ckgSlug(`cause:${ckgSlug(job)}`);
-                    await ckgUpsertNode(redis, causeId, 'cause', 'ci-break');
-                    await ckgUpdateEdge(redis, conceptId, 'causes', causeId, false);
-                    breaks++;
-                }
-                else {
-                    stable++;
-                }
-                const clsKey = `cachly:cls:${instance_id}`;
-                await redis.rpush(clsKey, JSON.stringify({ source: 'ci_outcome', payload: { status, prev_status, job }, ts }));
-                await redis.ltrim(clsKey, -200, -1);
-            }
-            _lastBrainFromCiCounts = { fixes, breaks, stable, total };
-            return [
-                `📥 **brain_from_ci**: Ingested ${total} outcomes — ${fixes} fixes learned, ${breaks} breaks noted, ${stable} stable`,
-                '',
-                fixes > 0 ? `✅ ${fixes} fix lesson${fixes !== 1 ? 's' : ''} written (confidence 0.65) — CKG \`fixes\` edges added` : '',
-                breaks > 0 ? `🔴 ${breaks} break${breaks !== 1 ? 's' : ''} noted — CKG \`causes\` edges added` : '',
-                stable > 0 ? `📊 ${stable} stable outcome${stable !== 1 ? 's' : ''} recorded` : '',
-                '',
-                `💡 Explore: \`brain_search(query="ci")\`  |  \`brain_predict(context="<job-name>")\``,
-            ].filter(Boolean).join('\n');
-        }
-        // ── brain_predict_failures ─────────────────────────────────────────────────
-        case 'brain_predict_failures': {
-            const { instance_id, context: ctx, top_k = 5, format = 'detailed' } = args;
-            const redis = await getConnection(instance_id);
-            const ctxTokens = ctx.toLowerCase().replace(/[^a-z0-9\s\-_:.]/g, ' ').split(/\s+/).filter(t => t.length > 2);
-            const failures = [];
-            // Step 1: CKG — find 'causes' and 'degrades_under' edges from context tokens
-            for (const token of ctxTokens.slice(0, 8)) {
-                const nodeKeys = [];
-                const nStream = redis.scanStream({ match: `cachly:ckg:node:*${token}*`, count: 50 });
-                await new Promise((res, rej) => { nStream.on('data', (b) => nodeKeys.push(...b)); nStream.on('end', res); nStream.on('error', rej); });
-                for (const nk of nodeKeys.slice(0, 5)) {
-                    const nodeRaw = await redis.get(nk);
-                    if (!nodeRaw)
-                        continue;
-                    const node = safeJsonParse(nodeRaw, null);
-                    if (!node)
-                        continue;
-                    const edgeKeys = await redis.smembers(`cachly:ckg:idx:from:${node.id}`);
-                    for (const ek of edgeKeys.slice(0, 20)) {
-                        const edgeRaw = await redis.get(ek);
-                        if (!edgeRaw)
-                            continue;
-                        const edge = safeJsonParse(edgeRaw, null);
-                        if (!edge)
-                            continue;
-                        if (edge.edgeType !== 'causes' && edge.edgeType !== 'degrades_under')
-                            continue;
-                        // Look up fix for this failure from CKG 'fixes' edges
-                        const fixEdgeKeys = await redis.smembers(`cachly:ckg:idx:from:${edge.to}`);
-                        let fix;
-                        for (const fek of fixEdgeKeys.slice(0, 10)) {
-                            const feRaw = await redis.get(fek);
-                            if (!feRaw)
-                                continue;
-                            const fe = safeJsonParse(feRaw, null);
-                            if (!fe)
-                                continue;
-                            if (fe.edgeType === 'fixes') {
-                                const lessonRaw = await redis.get(`cachly:lesson:best:${fe.from}`);
-                                if (lessonRaw) {
-                                    const lesson = safeJsonParse(lessonRaw, null);
-                                    fix = lesson?.what_worked?.slice(0, 120);
-                                    break;
-                                }
-                            }
-                        }
-                        failures.push({
-                            concept: node.id,
-                            failure: edge.to.replace(/-/g, ' '),
-                            probability: edge.confidence,
-                            fix,
-                            source: 'ckg',
-                        });
-                    }
-                }
-            }
-            // Step 2: Lesson history — find failure-outcome lessons matching context
-            const lessonKeys = [];
-            const lStream = redis.scanStream({ match: 'cachly:lesson:best:*', count: 300 });
-            await new Promise((res, rej) => { lStream.on('data', (b) => lessonKeys.push(...b)); lStream.on('end', res); lStream.on('error', rej); });
-            for (const k of lessonKeys.slice(0, 100)) {
-                const r = await redis.get(k);
-                if (!r)
-                    continue;
-                try {
-                    const l = JSON.parse(r);
-                    if (l.outcome !== 'failure' && l.outcome !== 'partial')
-                        continue;
-                    if (!l.what_failed)
-                        continue;
-                    const haystack = `${l.topic} ${l.what_failed}`.toLowerCase();
-                    const matchScore = ctxTokens.filter(t => haystack.includes(t)).length / Math.max(1, ctxTokens.length);
-                    if (matchScore < 0.15)
-                        continue;
-                    const sevBoost = l.severity === 'critical' ? 0.15 : l.severity === 'major' ? 0.05 : 0;
-                    failures.push({
-                        concept: l.topic,
-                        failure: l.what_failed.slice(0, 80),
-                        probability: Math.min(0.97, (l.confidence ?? 0.5) * matchScore * 1.5 + sevBoost),
-                        fix: l.what_worked?.slice(0, 120),
-                        topic: l.topic,
-                        source: 'lesson',
-                    });
-                }
-                catch { /* skip */ }
-            }
-            if (failures.length === 0) {
-                return [
-                    `🔮 **Failure Prediction: "${ctx}"**`, '',
-                    `No known failure patterns found for this context.`,
-                    `💡 The brain learns from every \`learn_from_attempts(outcome="failure")\` call.`,
-                    `🔍 Try: \`brain_predict(context="${ctx}")\` for broader predictions.`,
-                ].join('\n');
-            }
-            // Deduplicate and rank by probability
-            const seen = new Set();
-            const ranked = failures.filter(f => {
-                const k = f.failure.slice(0, 40);
-                if (seen.has(k))
-                    return false;
-                seen.add(k);
-                return true;
-            }).sort((a, b) => b.probability - a.probability).slice(0, Number(top_k));
-            const lines = [`🔮 **Failure Prediction for: "${ctx}"**\n`];
-            lines.push(`> Pre-deploy failure analysis based on ${failures.length} patterns. Ranked by probability.\n`);
-            for (let i = 0; i < ranked.length; i++) {
-                const f = ranked[i];
-                const pct = Math.round(f.probability * 100);
-                const bar = '█'.repeat(Math.round(pct / 10)) + '░'.repeat(10 - Math.round(pct / 10));
-                const icon = pct >= 70 ? '🔴' : pct >= 40 ? '🟡' : '🟢';
-                lines.push(`${icon} **${i + 1}. ${f.failure}**`);
-                lines.push(`   Probability: ${bar} **${pct}%** (${f.source === 'ckg' ? 'CKG causal edge' : 'lesson history'})`);
-                if (format === 'detailed' && f.fix) {
-                    lines.push(`   ✅ Pre-loaded fix: _${f.fix}_`);
-                }
-                if (format === 'detailed' && f.topic) {
-                    lines.push(`   📚 Lesson: \`${f.topic}\``);
-                }
-                lines.push('');
-            }
-            const highRisk = ranked.filter(f => f.probability >= 0.6);
-            if (highRisk.length > 0) {
-                lines.push(`⚠️ **${highRisk.length} high-risk failure${highRisk.length > 1 ? 's' : ''} detected** (≥60% probability). Review fixes before proceeding.`);
-            }
-            else {
-                lines.push(`✅ No high-risk failures detected. Proceed with caution and monitor closely.`);
-            }
-            lines.push('', `💡 After deploy: \`learn_from_attempts(topic="deploy:...", outcome="success|failure")\` to improve future predictions.`);
-            return lines.join('\n');
-        }
-        // ── Move 5: brain_contribute_signal — privacy-safe federation ────────────
-        case 'brain_contribute_signal': {
-            const { instance_id, topic_category, outcome, confidence = 0.5 } = args;
-            if (!topic_category?.trim())
-                throw new Error('topic_category is required');
-            if (!['success', 'failure', 'partial'].includes(outcome)) {
-                throw new Error('outcome must be success, failure, or partial');
-            }
-            // Bucket locally before sending — no raw confidence value leaves the instance.
-            const bucket = confidence >= 0.75 ? 'high' : confidence >= 0.5 ? 'medium' : 'low';
-            let apiResult = '📦 Signal stored locally (commons API unavailable)';
-            try {
-                await apiFetch('/api/v1/federation/signals', {
-                    method: 'POST',
-                    body: JSON.stringify({
-                        topic_category: topic_category.trim().toLowerCase(),
-                        outcome,
-                        confidence: confidence,
-                    }),
-                });
-                apiResult = '✅ Signal contributed to the global commons (no raw data shared)';
-            }
-            catch {
-                // Store in local outbox for later sync
-                const redis = await getConnection(instance_id);
-                const outboxKey = `cachly:fed:outbox:${Date.now()}`;
-                await redis.set(outboxKey, JSON.stringify({ topic_category, outcome, bucket, ts: new Date().toISOString() }), 'EX', 60 * 60 * 24 * 7).catch(() => { });
-            }
-            return [
-                `🔒 **Brain Contribute Signal: \`${topic_category}\`**`,
-                '',
-                `📊 Outcome: **${outcome}** · Confidence bucket: **${bucket}**`,
-                `🛡️ Privacy: topic category only — no lesson text, no org identity`,
-                '',
-                apiResult,
-                '',
-                `💡 When ≥ k orgs contribute the same pattern, a meta-lesson appears in \`brain_import_meta\`.`,
-            ].join('\n');
-        }
-        // ── Move 5: brain_import_meta — import k-anonymous meta-lessons ──────────
-        case 'brain_import_meta': {
-            const { instance_id, category, limit = 20 } = args;
-            let metas = [];
-            let kThreshold = 3;
-            try {
-                const qs = new URLSearchParams();
-                if (category)
-                    qs.set('category', category);
-                qs.set('limit', String(Math.min(limit, 200)));
-                const resp = await apiFetch(`/api/v1/federation/meta?${qs.toString()}`);
-                metas = resp.meta_lessons ?? [];
-                kThreshold = resp.k_threshold ?? 3;
-            }
-            catch {
-                return '❌ Could not reach the global commons API. Try again later.';
-            }
-            if (metas.length === 0) {
-                return [
-                    `🌐 **Brain Import Meta-Lessons**`,
-                    '',
-                    `No meta-lessons available yet (k-threshold: ${kThreshold} signals required).`,
-                    '',
-                    `💡 Contribute signals with \`brain_contribute_signal\` to help build the commons.`,
-                ].join('\n');
-            }
-            // Store meta-lessons in local Brain as state:'meta' (never overwrite real lessons).
-            const redis = await getConnection(instance_id);
-            let imported = 0;
-            for (const m of metas) {
-                const localKey = `cachly:lesson:best:meta:${m.topic_category}`;
-                const existing = await redis.get(localKey);
-                if (!existing) {
-                    await redis.set(localKey, JSON.stringify({
-                        topic: `meta:${m.topic_category}`,
-                        outcome: m.dominant_outcome,
-                        // "independent orgs" only became an honest claim once the API
-                        // started counting DISTINCT contributors (KAI-96). Older servers
-                        // omit the field — then say what we actually know: signal rows.
-                        what_worked: m.contributor_count != null
-                            ? `Meta-pattern from ${m.contributor_count} independent orgs`
-                            : `Meta-pattern from ${m.signal_count} signals`,
-                        what_failed: '',
-                        recall_count: 0,
-                        ts: m.derived_at,
-                        state: 'meta',
-                        avg_confidence: m.avg_confidence,
-                        signal_count: m.signal_count,
-                        audit_trail: [{ ts: new Date().toISOString(), action: 'imported_meta' }],
-                    }));
-                    imported++;
-                }
-            }
-            const lines = [
-                `🌐 **Brain Import Meta-Lessons** (k ≥ ${kThreshold})`,
-                '',
-                `| Topic Category | Outcome | Confidence | Signals |`,
-                `|---|---|---|---|`,
-            ];
-            for (const m of metas.slice(0, 15)) {
-                const conf = (m.avg_confidence * 100).toFixed(0) + '%';
-                lines.push(`| \`${m.topic_category}\` | ${m.dominant_outcome} | ${conf} | ${m.signal_count} |`);
-            }
-            if (metas.length > 15)
-                lines.push(`| _…${metas.length - 15} more_ | | | |`);
-            lines.push('', `✅ **${imported}** new meta-lessons imported into local Brain.`);
-            if (imported < metas.length) {
-                lines.push(`_(${metas.length - imported} already present — not overwritten)_`);
-            }
-            return lines.join('\n');
-        }
-        // ── brain_watch ───────────────────────────────────────────────────────────
-        case 'brain_watch': {
-            const { instance_id = '', project_dir = '.', api_key } = args;
-            const { resolve } = await import('node:path');
-            const projectDir = resolve(project_dir);
-            const { result, hookPath } = await installBrainWatchHook(projectDir, instance_id, api_key);
-            if (result === 'skipped-no-git') {
-                return [
-                    `⚠️ **brain_watch: no git repository found**`,
-                    '',
-                    `No \`.git\` directory in \`${projectDir}\`.`,
-                    `Pass \`project_dir\` pointing to a git checkout.`,
-                ].join('\n');
-            }
-            const statusLine = {
-                written: '✅ Hook installed (new)',
-                upgraded: '🔄 Hook upgraded to latest version',
-                appended: '📎 Hook appended to existing post-commit script',
-                unchanged: '✓ Hook already up to date — nothing changed',
-            };
-            return [
-                `🧠 **brain_watch ${statusLine[result] ?? result}**`,
-                '',
-                `Hook path: \`${hookPath}\``,
-                `Instance:  \`${instance_id || '(none — set CACHLY_BRAIN_INSTANCE_ID or pass instance_id)'}\``,
-                '',
-                `Every future commit will automatically teach your Brain.`,
-                `No manual \`brain_from_git\` needed — the hook runs silently in the background.`,
-                '',
-                `💡 Verify: \`git commit --allow-empty -m "test brain_watch"\` then \`smart_recall(query="test")\``,
-            ].join('\n');
-        }
-        default:
-            return null;
-    }
-}
-//# sourceMappingURL=fedbrain.js.map
+import{createHmac as ie}from"node:crypto";import{ckgSlug as $,extractProblemConcept as ae,ckgUpsertNode as J,ckgUpdateEdge as T,ckgUpsertPersonNode as ce,ckgUpsertFileNode as re,ckgRecordCollaboration as le}from"../ckg.js";import{safeJsonParse as A,normalizeGitPath as ue}from"../utils.js";import{buildClsPostCommitHook as de}from"../cls-hook.js";import{installBrainWatchHook as fe}from"../brain-watch-hook.js";import{keywordSearch as he}from"../search.js";import{buildFirstContactReport as te,suggestRecallQueries as me}from"../first-contact.js";let pe=null,ge=null,W=0;const _e=10,se=[];function ye(){return W<_e?(W++,Promise.resolve()):new Promise(E=>se.push(E))}function we(){const E=se.shift();E?E():W--}const Oe=new Set(["madc_deliberate","cls_ingest","cls_install_hooks","fedbrain_contribute","fedbrain_search","fedbrain_confirm","fedbrain_status","brain_federate","crystal_view","compact_recover","brain_from_git","brain_from_ci","brain_predict_failures","brain_contribute_signal","brain_import_meta","brain_watch"]);async function Ne(E,N,I,G){switch(E){case"madc_deliberate":{const{instance_id:y,topic:a}=N,n=await I(y),e=(await n.lrange(`cachly:lessons:${a}`,0,-1)).map(g=>{try{return JSON.parse(g)}catch{return null}}).filter(Boolean);if(e.length<2)return[`\u{1F5F3}\uFE0F **MADC: "${a}"**`,"",`Not enough history for deliberation (need \u2265 2 entries, found ${e.length}).`,"","Call `learn_from_attempts` with conflicting outcomes to trigger deliberation."].join(`
+`);const l=[{name:"InfraAgent",domains:["infra","k8s","docker","server","wireguard","helm"]},{name:"AuthAgent",domains:["auth","jwt","keycloak","oauth","oidc","token"]},{name:"DeployAgent",domains:["deploy","ci","pipeline","rsync","release"]},{name:"DatabaseAgent",domains:["db","gorm","migration","postgres","clickhouse","redis"]},{name:"DebugAgent",domains:["debug","panic","race","nil","fix","error"]},{name:"APIAgent",domains:["api","http","grpc","rest","fiber","web"]}],u=a.split(":")[0]??"",c=l.filter(g=>g.domains.some(S=>u===S||a.includes(S))),o=c.length>0?c:l,d=new Map;for(const g of o){let S=0;for(const k of g.domains){const x=[],j=n.scanStream({match:`cachly:ckg:node:${k}*`,count:50});await new Promise((R,D)=>{j.on("data",P=>x.push(...P)),j.on("end",R),j.on("error",D)}),S+=x.length}d.set(g.name,S)}const h=e.filter(g=>g.outcome==="success"||g.outcome==="partial"),s=e.filter(g=>g.outcome==="failure");if(s.length===0)return[`\u{1F5F3}\uFE0F **MADC: "${a}"**`,"",`No contradictions found \u2014 all ${h.length} entries have non-failure outcomes.`,"",`Use \`ckg_inspect(concept="${$(a)}")\` to explore the confidence graph.`].join(`
+`);const i=[];for(const g of o){const S=d.get(g.name)??0;let k,x;S<2?(k="abstain",x="insufficient domain coverage"):h.length>=s.length*2?(k="success",x=`${h.length}/${e.length} entries confirm success`):s.length>=h.length*2?(k="failure",x=`${s.length}/${e.length} entries confirm failure`):(k="abstain",x=`contested (${h.length} success vs ${s.length} failure)`),i.push({agent:g.name,vote:k,coverage:S,reason:x})}const r=i.filter(g=>g.vote==="success").length,f=i.filter(g=>g.vote==="failure").length,m=i.filter(g=>g.vote==="abstain").length;let p,w;r>0&&f===0?(p="unanimous_success",w=`\u2705 **Unanimous: SUCCESS** \u2014 ${r} agent(s) confirm, ${m} abstain`):f>0&&r===0?(p="unanimous_failure",w=`\u274C **Unanimous: FAILURE** \u2014 ${f} agent(s) confirm, ${m} abstain`):(p="contested",w=`\u26A0\uFE0F **CONTESTED** \u2014 ${r} success votes, ${f} failure votes, ${m} abstain`);const b=$(`resolution:${a}`),O={id:b,domain:"resolution",type:"resolution",count:1,ts:new Date().toISOString(),resolution:p,topic:a,votes:{success:r,failure:f,abstain:m}};if(await n.set(`cachly:ckg:node:${b}`,JSON.stringify(O)),p==="contested")await T(n,$(a),"contradicts",b,!1);else{if(((p==="unanimous_success"?"failure":"success")==="failure"?s:h).length>0){const k=await n.smembers(`cachly:ckg:idx:from:${$(a)}`);for(const x of k){const j=await n.get(x);if(j)try{const R=JSON.parse(j);R.edgeType==="fixes"&&R.confidence>.15&&p==="unanimous_failure"&&(R.confidence=.1,R.last_updated=new Date().toISOString(),await n.set(x,JSON.stringify(R)))}catch{}}}await n.del(`cachly:ckg:conflict:${$(a)}`)}const C=[`\u{1F5F3}\uFE0F **MADC Deliberation: "${a}"**`,"",`\u{1F4CA} Evidence: ${h.length} success/partial vs ${s.length} failure entries (${e.length} total)`,"",`**Voting agents (${o.length}):**`,...i.map(g=>{const S=g.vote==="success"?"\u2705":g.vote==="failure"?"\u274C":"\u2B1C",k="\u2593".repeat(Math.min(g.coverage,5))+"\u2591".repeat(Math.max(0,5-g.coverage));return`  ${S} **${g.agent}** [${k}] ${g.coverage} CKG edges \u2014 ${g.reason}`}),"",w,""];return p==="unanimous_success"?C.push(`\u{1F527} Failure entries superseded \u2014 store confirmed lesson: \`learn_from_attempts(topic="${a}", outcome="success", ...)\``):p==="unanimous_failure"?C.push(`\u{1F6AB} Success claims unconfirmed \u2014 re-verify: \`recall_best_solution(topic="${a}")\``):C.push(`\u26A0\uFE0F Contested \u2014 run \`causal_trace\` before acting. Explore: \`ckg_inspect(concept="${$(a)}")\``),C.push("",`\u{1F4DD} Resolution node: \`cachly:ckg:node:${b}\``),C.join(`
+`)}case"cls_ingest":{const{instance_id:y,source:a,payload:n}=N,t=await I(y),e=new Date().toISOString(),l="cachly:cls:events";if(a==="git_commit"){const u=String(n.message??""),c=String(n.sha??""),o=Array.isArray(n.files)?n.files:[],d=/^fix/i.test(u)?"fix":/^feat/i.test(u)?"feat":/^refactor/i.test(u)?"refactor":/^test/i.test(u)?"test":"commit",h=`${d}:${$(u.slice(0,60))}`,s=$(h);await J(t,s,d,"commit");for(const f of o.slice(0,10)){const m=f.includes("auth")?"auth":f.includes("api")?"api":f.includes("infra")?"infra":f.includes("web")?"web":"code",p=$(`file:${m}`);await J(t,p,"file",m),await T(t,s,"co-occurs",p,!0)}const i={topic:h,outcome:"success",what_worked:u,what_failed:"",context:`CLS/git: sha=${c}`,severity:"minor",file_paths:o.slice(0,10),commands:c?[`git show ${c}`]:[],tags:["cls","git"],depends_on:[],recall_count:0,ts:e,verified_at:e,confidence:.6,audit_trail:[{ts:e,action:"cls_git_commit"}],version:3};return await t.rpush(`cachly:lessons:${h}`,JSON.stringify(i)),await t.get(`cachly:lesson:best:${h}`)||await t.set(`cachly:lesson:best:${h}`,JSON.stringify(i)),await t.rpush(l,JSON.stringify({source:a,payload:{message:u,sha:c},ts:e})),await t.ltrim(l,-200,-1),["\u{1F4E8} **CLS Ingested: git_commit**","",`Commit \`${c.slice(0,8)||"?"}\`: ${u.slice(0,80)}`,`Concept: \`${s}\` (${d}) \xB7 Files: ${o.length}`,"",`\u{1F578}\uFE0F CKG: \`${s}\` + ${o.length} file edges \xB7 Lesson: \`${h}\``,`\u{1F4A1} Inspect: \`ckg_inspect(concept="${d}")\``].join(`
+`)}if(a==="ci_outcome"){const u=String(n.status??""),c=String(n.prev_status??""),o=String(n.job??"unknown"),d=String(n.context??""),h=["failure","red","error"].includes(c)&&["success","green","passed"].includes(u),s=["success","green","passed"].includes(c)&&["failure","red","error"].includes(u),i=`ci:${$(o)}`,r=$(i);if(await J(t,r,"ci","job"),h){const m=$(`problem:${$(o)}`);await J(t,m,"problem","ci-failure"),await T(t,r,"fixes",m,!0);const p={topic:i,outcome:"success",what_worked:`CI job "${o}" went ${c} \u2192 ${u}`,what_failed:`Job "${o}" was failing`,context:`CLS/ci: ${d}`,severity:"major",file_paths:[],commands:[],tags:["cls","ci"],depends_on:[],recall_count:0,ts:e,verified_at:e,confidence:.75,audit_trail:[{ts:e,action:"cls_ci_fixed"}],version:3};await t.rpush(`cachly:lessons:${i}`,JSON.stringify(p)),await t.set(`cachly:lesson:best:${i}`,JSON.stringify(p))}else if(s){const m=$(`cause:${$(o)}`);await J(t,m,"cause","ci-break"),await T(t,r,"causes",m,!1)}return await t.rpush(l,JSON.stringify({source:a,payload:{status:u,prev_status:c,job:o},ts:e})),await t.ltrim(l,-200,-1),["\u{1F4E8} **CLS Ingested: ci_outcome**","",`${h?"\u2705 Fixed":s?"\u{1F534} Broken":"\u{1F4CA} Recorded"}: \`${o}\` \u2014 ${c||"?"} \u2192 ${u}`,h?"\u{1F527} CKG `fixes` edge added (75% confidence)":s?"\u26A1 CKG `causes` edge added":"\u{1F4CA} State recorded",`\u{1F4A1} Lesson: \`${i}\`  |  Predict: \`brain_predict(context="${o}")\``].join(`
+`)}if(a==="ide_diagnostic"){const u=String(n.error??""),c=String(n.fix??""),o=String(n.file??""),d=ae(u)??"unknown-error",h=`debug:${$(d)}`,s=$(h),i=$(`problem:${d}`);await J(t,s,"debug","diagnostic"),await J(t,i,"problem","compiler-error"),await T(t,s,"fixes",i,!0);const r={topic:h,outcome:"success",what_worked:c,what_failed:u,context:`CLS/ide: ${o}`,severity:"minor",file_paths:o?[o]:[],commands:[],tags:["cls","ide-diagnostic"],depends_on:[],recall_count:0,ts:e,verified_at:e,confidence:.65,audit_trail:[{ts:e,action:"cls_ide_diagnostic"}],version:3};return await t.rpush(`cachly:lessons:${h}`,JSON.stringify(r)),await t.get(`cachly:lesson:best:${h}`)||await t.set(`cachly:lesson:best:${h}`,JSON.stringify(r)),await t.rpush(l,JSON.stringify({source:a,payload:{error:u.slice(0,60),fix:c.slice(0,60),file:o},ts:e})),await t.ltrim(l,-200,-1),["\u{1F4E8} **CLS Ingested: ide_diagnostic**","",`Error: \`${u.slice(0,80)}\``,`Fix: ${c.slice(0,100)}`,o?`File: \`${o}\``:"","",`\u{1F578}\uFE0F CKG: \`${s}\` \u2192 fixes \u2192 \`${i}\`  |  Lesson: \`${h}\``].filter(m=>m!=="").join(`
+`)}return`\u274C Unknown CLS source: "${a}". Valid: git_commit, ci_outcome, ide_diagnostic`}case"cls_install_hooks":{const{instance_id:y,repo_path:a=".",hooks:n=["git","ci"]}=N,t=Array.isArray(n)?n:["git","ci"],e=[`\u{1F50C} **CLS Hook Installation Guide**
+`];if(t.includes("git")){const l=de(y);e.push("### Git post-commit hook"),e.push("**Quick install (run once per repo):**"),e.push("```sh"),e.push(`cat > ${a}/.git/hooks/post-commit << 'HOOK'`),e.push(l),e.push("HOOK"),e.push(`chmod +x ${a}/.git/hooks/post-commit`),e.push("```"),e.push("After install: every `git commit` automatically updates your brain's CKG."),e.push("")}return t.includes("ci")&&(e.push("### GitHub Actions CI outcome hook"),e.push("**Add at the end of each job** (after build/test steps):"),e.push("```yaml"),e.push("- name: cachly CLS \u2014 record CI outcome"),e.push("  if: always()"),e.push("  run: |"),e.push('    node -e "'),e.push("    const r=require('https');"),e.push(`    const d=JSON.stringify({instance_id:'${y}',source:'ci_outcome',payload:{`),e.push("      status:'${{ job.status }}',prev_status:'unknown',job:'${{ github.job }}',"),e.push("      context:'github-actions run ${{ github.run_number }}'}});"),e.push("    r.request({hostname:'api.cachly.dev',path:'/api/v1/cls/ingest',method:'POST',"),e.push("      headers:{'Content-Type':'application/json','Authorization':'Bearer $CACHLY_JWT',"),e.push("        'Content-Length':d.length}},()=>{}).end(d);"),e.push('    " 2>/dev/null || true'),e.push("  env:"),e.push("    CACHLY_JWT: ${{ secrets.CACHLY_JWT }}"),e.push("```"),e.push("")),e.push('\u{1F4A1} Once installed: `brain_search(query="cls")` to verify events are arriving.'),e.push('\u{1F4CA} Monitor CKG growth: `ckg_inspect(concept="ci")` or `ckg_inspect(concept="fix")`'),e.join(`
+`)}case"fedbrain_contribute":{const{instance_id:y,lesson_key:a,visibility:n="public"}=N,t=await I(y),e=await t.get(`cachly:lesson:best:${a}`);if(!e)return`\u274C Lesson \`${a}\` not found. Store it first with \`learn_from_attempts\`.`;const l=A(e,null);if(!l)return`\u274C Lesson \`${a}\` data is corrupted. Re-store with \`learn_from_attempts\`.`;const u=[l.topic.split(":")[0],...l.tags??[]].filter(Boolean),c=[...new Set(u)].sort().join(","),o=`${l.topic}:${l.outcome}:${l.what_worked}`,d=ie("sha256",`cachly-fedbrain:${y}`).update(o).digest("hex").slice(0,16),h={cert_id:d,lesson_key:a,visibility:n,domain_fingerprint:c,contributed_at:new Date().toISOString(),confirm_count:0,trust_score:l.outcome==="success"?.85:.5};await t.set(`cachly:fedbrain:cert:${d}`,JSON.stringify(h)),await t.sadd("cachly:fedbrain:contributed",d);let s;try{await G("/api/v1/syndication/contribute",{method:"POST",body:JSON.stringify({topic:l.topic,outcome:l.outcome,what_worked:l.what_worked,what_failed:l.what_failed??"",severity:l.severity??"major",cert_id:d,domain_fingerprint:c,visibility:n})}),s="\u2705 Contributed to global commons"}catch{s="\u{1F4E6} Stored locally (commons API unavailable \u2014 will sync when online)"}return[`\u{1F310} **FedBrain Contribute: "${a}"**`,"",`\u{1F4DC} Certificate: \`${d}\``,`\u{1F3F7}\uFE0F Domain fingerprint: ${u.slice(0,6).map(i=>`\`${i}\``).join(", ")}`,`\u{1F512} Visibility: ${n}`,"",s,"","\u{1F4A1} At 10 independent confirms \u2192 \u{1F3C6} Gold Standard",`\u{1F50D} Search: \`fedbrain_search(query="${l.topic.split(":").slice(-1)[0]}")\``].join(`
+`)}case"fedbrain_search":{const{instance_id:y,query:a,context_hints:n=[],limit:t=10}=N,e=await I(y),l=await e.smembers("cachly:fedbrain:contributed"),u=new Map;for(const i of l.slice(0,30)){const r=await e.get(`cachly:fedbrain:cert:${i}`);if(r)try{const f=JSON.parse(r);for(const m of(f.domain_fingerprint??"").split(",").filter(Boolean))u.set(m,(u.get(m)??0)+1)}catch{}}for(const i of Array.isArray(n)?n:[])u.set(i.toLowerCase(),(u.get(i.toLowerCase())??0)+2);let c=[],o=!1;try{const i=new URLSearchParams({q:a,limit:String(Math.min(t*2,50))});c=(await G(`/api/v1/syndication/search?${i}`)).results??[]}catch{o=!0;const i=[],r=e.scanStream({match:"cachly:lesson:best:*",count:200});await new Promise((f,m)=>{r.on("data",p=>i.push(...p)),r.on("end",f),r.on("error",m)});for(const f of i.slice(0,60)){const m=await e.get(f);if(m)try{const p=JSON.parse(m),w=`${p.topic} ${p.what_worked??""} ${p.what_failed??""}`.toLowerCase();a.toLowerCase().split(/\s+/).some(b=>b.length>2&&w.includes(b))&&c.push({id:f.split(":").pop()??f,topic:p.topic,category:p.topic.split(":")[0],outcome:p.outcome,what_worked:p.what_worked??"",severity:p.severity??"major",confirm_count:0,created_at:p.ts??new Date().toISOString()})}catch{}}}const d=o?" \u2014 \u26A0\uFE0F Commons unreachable, local fallback (this machine only, not confirmed by the network)":"";if(c.length===0)return[`\u{1F310} **FedBrain Search: "${a}"**${d}`,"",'No results. Contribute: `fedbrain_contribute(lesson_key="fix:...")`'].join(`
+`);const h=c.map(i=>{const r=(i.domain_fingerprint??i.category??"").split(",").filter(Boolean),f=r.reduce((b,O)=>b+(u.get(O)??0),0),m=u.size>0?f/Math.max(1,u.size+r.length):0,p=Math.min(1,i.confirm_count/10),w=m*.4+p*.4+(i.outcome==="success"?.2:0);return{...i,weightedScore:w,isGoldStandard:!o&&i.confirm_count>=10}}).sort((i,r)=>r.weightedScore-i.weightedScore).slice(0,t),s=[`\u{1F310} **FedBrain Search: "${a}"** \u2014 ${h.length} result${h.length!==1?"s":""} (context-weighted)${d}
+`];for(const i of h){const r=i.outcome==="success"?"\u2705":i.outcome==="failure"?"\u274C":"\u26A0\uFE0F",f=i.isGoldStandard?" \u{1F3C6} _Gold Standard_":!o&&i.confirm_count>=3?` \u2713${i.confirm_count}`:"",m=Math.round(i.weightedScore*100);s.push(`${r}${f} **\`${i.topic}\`** [ctx: ${m}%]`),i.what_worked&&s.push(`  \u2705 ${i.what_worked.slice(0,150)}`),i.what_failed&&s.push(`  \u274C ${i.what_failed.slice(0,80)}`),s.push(`  _${i.confirm_count} confirm${i.confirm_count!==1?"s":""}  |  id: \`${i.id}\`_`,"")}if(u.size>0){const i=[...u.entries()].sort((r,f)=>f[1]-r[1]).slice(0,5).map(([r,f])=>`\`${r}\`(${f})`).join(", ");s.push(`\u{1F3AF} Your context: ${i}`)}return s.push('\u{1F4A1} Confirm a result: `fedbrain_confirm(id="<id>", topic="<topic>", outcome="worked")`'),s.join(`
+`)}case"fedbrain_confirm":{const{instance_id:y,id:a,topic:n,outcome:t}=N;if(!a)return["\u274C **FedBrain Confirm** needs the lesson `id` from `fedbrain_search` results.",'Run `fedbrain_search(query="...")`, copy the id shown next to a result,','then: `fedbrain_confirm(id="<id>", topic="<topic>", outcome="worked")`.'].join(`
+`);const e=await I(y),l=new Date().toISOString(),u=JSON.stringify({id:a,topic:n,outcome:t,ts:l});await e.rpush("cachly:fedbrain:confirmations",u),await e.ltrim("cachly:fedbrain:confirmations",-200,-1);const c=t==="worked",o=t==="partially_worked";n&&await T(e,$(n),"fixes",$(`syndicated:${n}`),c,o);let d;try{await G(`/api/v1/syndication/${encodeURIComponent(a)}/confirm`,{method:"POST"}),d="\u2705 Confirmation propagated to global commons"}catch{await e.rpush("cachly:fedbrain:pending_confirms",u),await e.ltrim("cachly:fedbrain:pending_confirms",-50,-1),d="\u{1F4E6} Queued locally (API unavailable \u2014 will propagate on next online session)"}return[`${c?"\u2705":o?"\u26A0\uFE0F":"\u274C"} **FedBrain Confirm: "${n??a}"** \u2192 ${t}`,"",d,"",n?`\u{1F578}\uFE0F CKG confidence ${c||o?"boosted":"reduced"} for \`${$(n)}\``:"\u{1F578}\uFE0F Local CKG unchanged (pass `topic` to also update your own confidence graph)","\u{1F4A1} Your confirmation helps other brains worldwide.",'\u{1F4CA} Status: `fedbrain_status(instance_id="...")`'].join(`
+`)}case"fedbrain_status":{const{instance_id:y}=N,a=await I(y),n=await a.smembers("cachly:fedbrain:contributed"),t=await a.lrange("cachly:fedbrain:confirmations",-10,-1),e=await a.llen("cachly:fedbrain:pending_confirms"),l=t.map(o=>{try{return JSON.parse(o)}catch{return null}}).filter(Boolean),u=[];for(const o of n.slice(0,15)){const d=await a.get(`cachly:fedbrain:cert:${o}`);if(d)try{const h=JSON.parse(d);u.push({cert_id:h.cert_id,lesson_key:h.lesson_key,confirm_count:h.confirm_count??0,trust_score:h.trust_score??.5,isGold:(h.confirm_count??0)>=10})}catch{}}const c=[`\u{1F310} **FedBrain Status**
+`,`### \u{1F4E4} Contributed Lessons: ${n.length}`];if(u.length>0)for(const o of u){const d=o.isGold?" \u{1F3C6} Gold Standard":"",h="\u2588".repeat(Math.min(10,o.confirm_count))+"\u2591".repeat(Math.max(0,10-o.confirm_count));c.push(`  \`${o.lesson_key}\` [${h}] \xD7${o.confirm_count}${d}`)}else c.push('  _None yet. Contribute with `fedbrain_contribute(lesson_key="fix:...")`_');if(c.push("",`### \u{1F4E5} Recent Confirmations: ${l.length}`),l.length>0)for(const o of l.slice(-5)){const d=o.outcome==="worked"?"\u2705":o.outcome==="partially_worked"?"\u26A0\uFE0F":"\u274C";c.push(`  ${d} \`${o.topic}\` \u2014 ${o.outcome} (${new Date(o.ts).toLocaleDateString("de-DE")})`)}else c.push("  _None yet. Confirm syndicated lessons with `fedbrain_confirm`_");return e>0&&c.push("",`\u26A0\uFE0F ${e} confirmation${e!==1?"s":""} pending propagation`),c.push("","---",'**Contribute:** `fedbrain_contribute(lesson_key="fix:...")`','**Search:** `fedbrain_search(query="...")`','**Confirm:** `fedbrain_confirm(id="...", topic="...", outcome="worked")`'),c.join(`
+`)}case"brain_federate":{const{instance_id:y,source:a,domain:n,min_confidence:t=.6,dry_run:e=!1}=N;if(y===a)return"\u274C Source and destination cannot be the same brain.";const l=await I(y),u=await I(a),c=n==="*"?"cachly:ckg:node:*":`cachly:ckg:node:${n}*`,o=[],d=u.scanStream({match:c,count:100});if(await new Promise((w,b)=>{d.on("data",O=>o.push(...O)),d.on("end",w),d.on("error",b)}),o.length===0)return[`\u{1F9E0} **brain_federate: "${n}"**`,"",`No CKG nodes found in source brain for domain \`${n}\`.`,"The source brain may not have knowledge in this area yet.",`Try: \`fedbrain_search(query="${n}")\` to find global commons knowledge instead.`].join(`
+`);let h=0,s=0,i=0,r=0;const f=[];for(const w of o){const b=await u.get(w);if(!b)continue;let O;try{O=JSON.parse(b)}catch{continue}e||await l.set(w,b),h++;const C=await u.smembers(`cachly:ckg:idx:from:${O.id}`);for(const k of C){const x=await u.get(k);if(!x)continue;let j;try{j=JSON.parse(x)}catch{continue}if(j.confidence<t){r++;continue}e||(await l.set(k,x),await l.sadd(`cachly:ckg:idx:from:${j.from}`,k),await l.sadd(`cachly:ckg:idx:to:${j.to}`,k)),s++}const g=`cachly:lesson:best:${O.id}`,S=await u.get(g);if(S&&(e||await l.set(g,S),i++,f.length<8))try{const k=JSON.parse(S),x=k.outcome==="success"?"\u2705":k.outcome==="failure"?"\u274C":"\u26A0\uFE0F";f.push(`  ${x} \`${k.topic}\` \u2014 ${(k.what_worked??"").slice(0,80)}`)}catch{}}if(!e){const w=JSON.stringify({source:a,domain:n,transferred_at:new Date().toISOString(),nodes:h,edges:s,lessons:i});await l.rpush("cachly:fedbrain:federations",w),await l.ltrim("cachly:fedbrain:federations",-50,-1)}const p=[`\u{1F9E0} **brain_federate: "${n}"**${e?" (DRY RUN \u2014 no writes)":""}`,"",`\u{1F4E4} Source: \`${a}\``,`\u{1F4E5} Destination: \`${y}\``,`\u{1F50D} Domain filter: \`${n}\`  |  min_confidence: ${t}`,"","### Transfer Summary",`  \u{1F578}\uFE0F CKG nodes:  ${h}`,`  \u{1F517} CKG edges:  ${s}  (${r} skipped, confidence < ${t})`,`  \u{1F4DA} Lessons:    ${i}`,""];return f.length>0&&(p.push("### Sample lessons transferred:",...f),i>f.length&&p.push(`  _... and ${i-f.length} more_`),p.push("")),e?p.push("\u{1F4A1} Run without `dry_run: true` to apply the transfer."):(p.push(`\u2705 Transfer complete. Your brain now has the \`${n}\` knowledge from \`${a}\`.`),p.push(`\u{1F50D} Explore: \`ckg_inspect(concept="${n}")\`  |  \`recall_best_solution(topic="${n}:...")\``)),p.join(`
+`)}case"crystal_view":{const{instance_id:y,show_raw:a=!1}=N,n=await I(y),t=await n.get("cachly:crystal:latest");if(!t)return["\u{1F48E} **Memory Crystal: not yet created**","","No crystal found. Create one with `memory_crystalize()` to compress your accumulated wisdom.","","\u{1F4A1} Tip: run `memory_crystalize` monthly for best results."].join(`
+`);const e=A(t,null);if(!e)return"\u274C Memory Crystal data is corrupted. Re-create with `memory_crystalize()`.";const l=Math.floor((Date.now()-new Date(e.ts).getTime())/864e5),u=l<=7?"\u{1F7E2}":l<=30?"\u{1F7E1}":"\u{1F534}",c=[`\u{1F48E} **Memory Crystal: ${e.label}**`,"",`\u{1F4C5} Created: ${new Date(e.ts).toLocaleDateString("de-DE")} (${l}d ago ${u})`,`\u{1F4CA} Compressed from: ${e.created_from}`,`\u{1F5C2}\uFE0F Categories: ${e.categories.slice(0,10).map(d=>`\`${d}\``).join(", ")}${e.categories.length>10?` +${e.categories.length-10} more`:""}`,"",`**\u{1F511} Top patterns (${e.top_patterns.length}):**`];for(const d of e.top_patterns)c.push(`  \u2022 **${d.category}** (${d.count}\xD7): ${d.insight.slice(0,110)}`);l>30&&c.push("",`\u26A0\uFE0F Crystal is ${l}d old \u2014 run \`memory_crystalize()\` to refresh it.`),a&&c.push("","```json",JSON.stringify(e,null,2),"```");const o=await n.get("cachly:crystal:team:latest").catch(()=>null);if(o){const d=A(o,null);if(d&&d.patterns?.length){const h=Math.floor((Date.now()-new Date(d.ts).getTime())/864e5);c.push("","---",`\u{1F4A0} **Team Crystal: ${d.label}** _(${h}d ago \xB7 ${d.contributors} contributors)_`,"_Fixes multiple teammates independently converged on \u2014 the team-wide layer:_");for(const s of d.patterns.slice(0,5))c.push(`  \u2022 \u{1F9E9} **${s.concept}** \u2014 ${s.author_count} people (${s.authors.map(i=>`@${i}`).join(", ")}): ${s.convergent_fix.slice(0,90)}`)}}return c.push("",'\u{1F4A1} Refresh: `memory_crystalize()` \xB7 `team_crystallize()`  |  Recover: `compact_recover(instance_id="...")`'),c.join(`
+`)}case"compact_recover":{const{instance_id:y,focus:a=""}=N,n=await I(y),t=[`\u{1F501} **Compact Recovery Briefing**
+`];t.push(`> *Call this first after any context limit hit. Reconstructs where you left off.*
+`);const e=await n.get("cachly:crystal:latest");if(e){const s=A(e,null);if(s){t.push(`### \u{1F48E} Memory Crystal: ${s.label}`),t.push(`Compressed from ${s.session_count} sessions, ${s.lesson_count} lessons.`);const i=a?s.top_patterns.filter(r=>r.category.toLowerCase().includes(a.toLowerCase())||r.insight.toLowerCase().includes(a.toLowerCase())).slice(0,4):s.top_patterns.slice(0,4);for(const r of i)t.push(`  \u2022 **${r.category}**: ${r.insight.slice(0,100)}`);t.push("")}}const l=await n.get("cachly:session:last");if(l){const s=A(l,null);s&&(t.push("### \u{1F550} Last Session"),s.focus&&t.push(`Focus: _${s.focus}_`),s.summary&&t.push(`Summary: ${s.summary.slice(0,300)}`),t.push(""))}const u=await n.get("cachly:session:handoff");if(u){const s=A(u,null);if(s){if(t.push("### \u{1F4CB} Handoff (from last window)"),s.context_summary&&t.push(`Context: ${s.context_summary.slice(0,200)}`),s.remaining_tasks?.length){t.push("Remaining tasks:");for(const i of s.remaining_tasks.slice(0,5))t.push(`  \u2022 ${i}`)}s.instructions&&t.push(`\u26A0\uFE0F Instructions: ${s.instructions.slice(0,200)}`),s.blocked_on&&t.push(`\u{1F6A7} Blocked on: ${s.blocked_on}`),t.push("")}}const c=await n.get("cachly:ctx:wip-registry");if(c){const s=A(c,null);s?.content&&(t.push("### \u{1F527} WIP Registry"),t.push(s.content.slice(0,400)),t.push(""))}const o=[],d=n.scanStream({match:"cachly:roadmap:*",count:100});await new Promise((s,i)=>{d.on("data",r=>o.push(...r)),d.on("end",s),d.on("error",i)});const h=[];for(const s of o.slice(0,30)){const i=await n.get(s);if(i)try{const r=JSON.parse(i);(r.status==="in_progress"||r.status==="blocked")&&h.push({title:r.title??s,status:r.status,priority:r.priority})}catch{}}if(h.length>0){t.push("### \u{1F6A7} Open Items");for(const s of h.slice(0,5))t.push(`  \u2022 [${s.status}] ${s.title}`);t.push("")}if(a){const s=[],i=n.scanStream({match:"cachly:lesson:best:*",count:200});await new Promise((f,m)=>{i.on("data",p=>s.push(...p)),i.on("end",f),i.on("error",m)});const r=[];for(const f of s){const m=await n.get(f);if(m)try{const p=JSON.parse(m);p.topic.toLowerCase().includes(a.toLowerCase())&&p.what_worked&&r.push({topic:p.topic,what_worked:p.what_worked})}catch{}}if(r.length>0){t.push(`### \u{1F4A1} Relevant Lessons for "${a}"`);for(const f of r.slice(0,4))t.push(`  \u2022 **${f.topic}**: ${f.what_worked.slice(0,100)}`);t.push("")}}return t.length<=3&&t.push("_No brain data found. Start accumulating knowledge with `learn_from_attempts` and `session_start`._"),t.push("---","\u{1F9E0} Brain is ready. Continue your work \u2014 full context restored."),t.join(`
+`)}case"brain_from_git":{const y=Date.now(),{instance_id:a,repo_path:n=".",limit:t=100,branch:e="HEAD",since:l="",incremental:u=!0}=N,c=await I(a),{execSync:o}=await import("node:child_process"),{resolve:d}=await import("node:path"),h=d(n),s=Math.min(Number(t)||100,500);await ye();try{try{o("git rev-parse --git-dir",{cwd:h,stdio:"pipe"})}catch{return`\u274C Not a git repository: \`${h}\`. Pass \`repo_path\` pointing to a git checkout.`}const i=`cachly:brain_from_git:last_sha:${Buffer.from(h).toString("base64").slice(0,32)}`;let r="",f=!1;u!==!1&&!l&&(r=await c.get(i)??"",f=!!r);const m=l?`--since="${l}"`:"",w=(f?`${r}..HEAD`:"")||e,b=`git log ${w} ${m} --pretty=format:"COMMIT|||%H|||%s|||%ad|||%an" --date=short --no-merges --name-only -n ${s}`;let O="";try{O=o(b,{cwd:h,encoding:"utf-8",stdio:"pipe"})}catch(v){return`\u274C git log failed: ${v.message}. Check \`repo_path\` and \`branch\`.`}const C=[];let g=null;for(const v of O.split(`
+`)){const _=v.trim();if(_.startsWith("COMMIT|||")){g&&C.push(g);const[,L,B,F,U]=_.split("|||");g={sha:(L??"").trim(),subject:(B??"").trim(),date:(F??"").trim(),author:(U??"").trim(),files:[]}}else if(_&&g){const L=ue(_);L&&g.files.push(L)}}if(g&&C.push(g),C.length===0)return f?`\u2705 brain_from_git: Brain is up to date \u2014 no new commits since last run (last SHA: \`${r.slice(0,8)}\`).`:te({repoDir:h,revRange:w,processed:0,ingested:0,skipped:0,durationMs:Date.now()-y,isIncremental:!1,instanceId:a,categories:[],suggestedQueries:[],emptyReason:`No commits found in \`${h}\` on branch \`${e}\`${l?` since ${l}`:""}.`});const S=v=>{const _=v.toLowerCase();return/\b(fix|fixed|fixes|bug|hotfix|patch|revert|resolve|closes? #\d+)\b/.test(_)?{category:"fix",outcome:"success",severity:/\b(critical|crash|security|auth|data loss|outage|prod|production)\b/.test(_)?"critical":/\b(major|breaking|regression|hotfix)\b/.test(_)?"major":"minor"}:/\b(feat|feature|add|added|implement|new|introduce)\b/.test(_)?{category:"feat",outcome:"success",severity:"minor"}:/\b(refactor|clean|cleanup|improve|simplify|extract|rename)\b/.test(_)?{category:"refactor",outcome:"success",severity:"minor"}:/\b(perf|optimize|speed|cache|latency|memory|performance)\b/.test(_)?{category:"perf",outcome:"success",severity:"major"}:/\b(security|cve|auth|csrf|xss|sql|injection|sanitize|escape|encrypt)\b/.test(_)?{category:"security",outcome:"success",severity:"critical"}:/\b(deploy|ci|cd|build|docker|k8s|helm|infra|devops)\b/.test(_)?{category:"deploy",outcome:"success",severity:"major"}:/\b(test|spec|coverage|assert|mock|unit|integration)\b/.test(_)?{category:"test",outcome:"success",severity:"minor"}:{category:"chore",outcome:"success",severity:"minor"}},k=v=>v.toLowerCase().replace(/[^a-z0-9\s\-_]/g," ").split(/\s+/).filter(B=>B.length>3&&!["that","this","with","from","when","into","also","some","were"].includes(B)).slice(0,3).join("-")||"general",x=new Date().toISOString();let j=0,R=0;const D=new Map,P=new Map,z=[];let K=null;const q=C.length,oe=Math.max(1,Math.floor(q/10));let Y=0;process.stderr.write(`
+\u{1F9E0} brain_from_git: processing ${q} commits from ${h}...
+`);for(let v=0;v<C.length;v++){const _=C[v];if(v-Y>=oe&&(process.stderr.write(`   \u23F3 Processing ${v}/${q} commits (${j} lessons so far)...
+`),Y=v),!_.subject){R++;continue}const{category:L,outcome:B,severity:F}=S(_.subject),U=k(_.subject),M=`${L}:${U}`;D.set(L,(D.get(L)??0)+1),P.set(F,(P.get(F)??0)+1),z.push(M),(!K||L==="fix"&&!K.topic.startsWith("fix:"))&&(K={topic:M,subject:_.subject});const Q=_.files.filter(H=>H.length>0).slice(0,12),X={topic:M,outcome:B,severity:F,what_worked:_.subject.slice(0,200),what_failed:"",context:`git:${_.sha.slice(0,8)} by ${_.author} on ${_.date}`,author:_.author||void 0,file_paths:Q,commands:[`git show ${_.sha.slice(0,8)}`],tags:["brain_from_git",L,"git-history"],visibility:"team",depends_on:[],recall_count:0,ts:x,verified_at:x,confidence:.55,audit_trail:[{ts:x,action:"brain_from_git",sha:_.sha.slice(0,8)}],version:3};await c.get(`cachly:lesson:best:${M}`)||(await c.set(`cachly:lesson:best:${M}`,JSON.stringify(X),"EX",90*86400),await c.rpush(`cachly:lessons:${M}`,JSON.stringify(X)),await c.ltrim(`cachly:lessons:${M}`,-100,-1),await c.expire(`cachly:lessons:${M}`,90*86400)),await c.rpush("cachly:lessons:brain_from_git:all",JSON.stringify({topic:M,sha:_.sha.slice(0,8),subject:_.subject.slice(0,60)})),await c.ltrim("cachly:lessons:brain_from_git:all",-500,-1),await c.expire("cachly:lessons:brain_from_git:all",90*86400);const Z=$(M);if(await J(c,Z,L,"git-derived"),_.author)try{const H=await ce(c,_.author,L);await T(c,H,"authored",Z,B==="success",B==="partial");for(const ne of Q.slice(0,8)){const ee=await re(c,ne);await T(c,H,"touched",ee,!0),await le(c,ee,H)}}catch{}j++}process.stderr.write(`   \u2705 brain_from_git complete: ${j}/${q} commits ingested
+
+`),C.length>0&&C[0]?.sha&&await c.set(i,C[0].sha,"EX",2160*3600),pe={fixes:D.get("fix")??0,features:D.get("feat")??0,refactors:D.get("refactor")??0,total:j};let V=null;if(K&&j>0)try{const v=await he(c,["cachly:lesson:best:*"],K.subject,1);if(v.length>0){const _=A(v[0].content,{});V={query:K.subject.slice(0,80),topic:_.topic??v[0].key.replace("cachly:lesson:best:",""),snippet:(_.what_worked??"").slice(0,120)||K.subject.slice(0,120)}}}catch{}return te({repoDir:h,revRange:w,processed:C.length,ingested:j,skipped:R,durationMs:Date.now()-y,isIncremental:f,lastSha:r,instanceId:a,categories:[...D.entries()].sort((v,_)=>_[1]-v[1]),severities:[...P.entries()].sort((v,_)=>_[1]-v[1]),proof:V,suggestedQueries:me(z,a)})}finally{we()}}case"brain_from_ci":{const{instance_id:y,outcomes:a}=N,n=await I(y),t=Date.now();let e=0,l=0,u=0;const c=a.length;for(const o of a){const d=String(o.status??""),h=String(o.prev_status??""),s=String(o.job??"unknown"),i=String(o.context??""),r=["failure","red","error"].includes(h)&&["success","green","passed"].includes(d),f=["success","green","passed"].includes(h)&&["failure","red","error"].includes(d),m=`ci:${$(s)}`,p=$(m);if(await J(n,p,"ci","job"),r){const b=$(`problem:${$(s)}`);await J(n,b,"problem","ci-failure"),await T(n,p,"fixes",b,!0);const O={topic:m,outcome:"success",what_worked:`CI job "${s}" went ${h} \u2192 ${d}`,what_failed:`Job "${s}" was failing`,context:`brain_from_ci: ${i}`,severity:"major",file_paths:[],commands:[],tags:["brain_from_ci","ci"],depends_on:[],recall_count:0,ts:t,verified_at:t,confidence:.65,audit_trail:[{ts:t,action:"brain_from_ci_fixed"}],version:3};await n.rpush(`cachly:lessons:${m}`,JSON.stringify(O)),await n.ltrim(`cachly:lessons:${m}`,-100,-1),await n.set(`cachly:lesson:best:${m}`,JSON.stringify(O)),e++}else if(f){const b=$(`cause:${$(s)}`);await J(n,b,"cause","ci-break"),await T(n,p,"causes",b,!1),l++}else u++;const w=`cachly:cls:${y}`;await n.rpush(w,JSON.stringify({source:"ci_outcome",payload:{status:d,prev_status:h,job:s},ts:t})),await n.ltrim(w,-200,-1)}return ge={fixes:e,breaks:l,stable:u,total:c},[`\u{1F4E5} **brain_from_ci**: Ingested ${c} outcomes \u2014 ${e} fixes learned, ${l} breaks noted, ${u} stable`,"",e>0?`\u2705 ${e} fix lesson${e!==1?"s":""} written (confidence 0.65) \u2014 CKG \`fixes\` edges added`:"",l>0?`\u{1F534} ${l} break${l!==1?"s":""} noted \u2014 CKG \`causes\` edges added`:"",u>0?`\u{1F4CA} ${u} stable outcome${u!==1?"s":""} recorded`:"","",'\u{1F4A1} Explore: `brain_search(query="ci")`  |  `brain_predict(context="<job-name>")`'].filter(Boolean).join(`
+`)}case"brain_predict_failures":{const{instance_id:y,context:a,top_k:n=5,format:t="detailed"}=N,e=await I(y),l=a.toLowerCase().replace(/[^a-z0-9\s\-_:.]/g," ").split(/\s+/).filter(r=>r.length>2),u=[];for(const r of l.slice(0,8)){const f=[],m=e.scanStream({match:`cachly:ckg:node:*${r}*`,count:50});await new Promise((p,w)=>{m.on("data",b=>f.push(...b)),m.on("end",p),m.on("error",w)});for(const p of f.slice(0,5)){const w=await e.get(p);if(!w)continue;const b=A(w,null);if(!b)continue;const O=await e.smembers(`cachly:ckg:idx:from:${b.id}`);for(const C of O.slice(0,20)){const g=await e.get(C);if(!g)continue;const S=A(g,null);if(!S||S.edgeType!=="causes"&&S.edgeType!=="degrades_under")continue;const k=await e.smembers(`cachly:ckg:idx:from:${S.to}`);let x;for(const j of k.slice(0,10)){const R=await e.get(j);if(!R)continue;const D=A(R,null);if(D&&D.edgeType==="fixes"){const P=await e.get(`cachly:lesson:best:${D.from}`);if(P){x=A(P,null)?.what_worked?.slice(0,120);break}}}u.push({concept:b.id,failure:S.to.replace(/-/g," "),probability:S.confidence,fix:x,source:"ckg"})}}}const c=[],o=e.scanStream({match:"cachly:lesson:best:*",count:300});await new Promise((r,f)=>{o.on("data",m=>c.push(...m)),o.on("end",r),o.on("error",f)});for(const r of c.slice(0,100)){const f=await e.get(r);if(f)try{const m=JSON.parse(f);if(m.outcome!=="failure"&&m.outcome!=="partial"||!m.what_failed)continue;const p=`${m.topic} ${m.what_failed}`.toLowerCase(),w=l.filter(O=>p.includes(O)).length/Math.max(1,l.length);if(w<.15)continue;const b=m.severity==="critical"?.15:m.severity==="major"?.05:0;u.push({concept:m.topic,failure:m.what_failed.slice(0,80),probability:Math.min(.97,(m.confidence??.5)*w*1.5+b),fix:m.what_worked?.slice(0,120),topic:m.topic,source:"lesson"})}catch{}}if(u.length===0)return[`\u{1F52E} **Failure Prediction: "${a}"**`,"","No known failure patterns found for this context.",'\u{1F4A1} The brain learns from every `learn_from_attempts(outcome="failure")` call.',`\u{1F50D} Try: \`brain_predict(context="${a}")\` for broader predictions.`].join(`
+`);const d=new Set,h=u.filter(r=>{const f=r.failure.slice(0,40);return d.has(f)?!1:(d.add(f),!0)}).sort((r,f)=>f.probability-r.probability).slice(0,Number(n)),s=[`\u{1F52E} **Failure Prediction for: "${a}"**
+`];s.push(`> Pre-deploy failure analysis based on ${u.length} patterns. Ranked by probability.
+`);for(let r=0;r<h.length;r++){const f=h[r],m=Math.round(f.probability*100),p="\u2588".repeat(Math.round(m/10))+"\u2591".repeat(10-Math.round(m/10)),w=m>=70?"\u{1F534}":m>=40?"\u{1F7E1}":"\u{1F7E2}";s.push(`${w} **${r+1}. ${f.failure}**`),s.push(`   Probability: ${p} **${m}%** (${f.source==="ckg"?"CKG causal edge":"lesson history"})`),t==="detailed"&&f.fix&&s.push(`   \u2705 Pre-loaded fix: _${f.fix}_`),t==="detailed"&&f.topic&&s.push(`   \u{1F4DA} Lesson: \`${f.topic}\``),s.push("")}const i=h.filter(r=>r.probability>=.6);return i.length>0?s.push(`\u26A0\uFE0F **${i.length} high-risk failure${i.length>1?"s":""} detected** (\u226560% probability). Review fixes before proceeding.`):s.push("\u2705 No high-risk failures detected. Proceed with caution and monitor closely."),s.push("",'\u{1F4A1} After deploy: `learn_from_attempts(topic="deploy:...", outcome="success|failure")` to improve future predictions.'),s.join(`
+`)}case"brain_contribute_signal":{const{instance_id:y,topic_category:a,outcome:n,confidence:t=.5}=N;if(!a?.trim())throw new Error("topic_category is required");if(!["success","failure","partial"].includes(n))throw new Error("outcome must be success, failure, or partial");const e=t>=.75?"high":t>=.5?"medium":"low";let l="\u{1F4E6} Signal stored locally (commons API unavailable)";try{await G("/api/v1/federation/signals",{method:"POST",body:JSON.stringify({topic_category:a.trim().toLowerCase(),outcome:n,confidence:t})}),l="\u2705 Signal contributed to the global commons (no raw data shared)"}catch{const u=await I(y),c=`cachly:fed:outbox:${Date.now()}`;await u.set(c,JSON.stringify({topic_category:a,outcome:n,bucket:e,ts:new Date().toISOString()}),"EX",3600*24*7).catch(()=>{})}return[`\u{1F512} **Brain Contribute Signal: \`${a}\`**`,"",`\u{1F4CA} Outcome: **${n}** \xB7 Confidence bucket: **${e}**`,"\u{1F6E1}\uFE0F Privacy: topic category only \u2014 no lesson text, no org identity","",l,"","\u{1F4A1} When \u2265 k orgs contribute the same pattern, a meta-lesson appears in `brain_import_meta`."].join(`
+`)}case"brain_import_meta":{const{instance_id:y,category:a,limit:n=20}=N;let t=[],e=3;try{const o=new URLSearchParams;a&&o.set("category",a),o.set("limit",String(Math.min(n,200)));const d=await G(`/api/v1/federation/meta?${o.toString()}`);t=d.meta_lessons??[],e=d.k_threshold??3}catch{return"\u274C Could not reach the global commons API. Try again later."}if(t.length===0)return["\u{1F310} **Brain Import Meta-Lessons**","",`No meta-lessons available yet (k-threshold: ${e} signals required).`,"","\u{1F4A1} Contribute signals with `brain_contribute_signal` to help build the commons."].join(`
+`);const l=await I(y);let u=0;for(const o of t){const d=`cachly:lesson:best:meta:${o.topic_category}`;await l.get(d)||(await l.set(d,JSON.stringify({topic:`meta:${o.topic_category}`,outcome:o.dominant_outcome,what_worked:o.contributor_count!=null?`Meta-pattern from ${o.contributor_count} independent orgs`:`Meta-pattern from ${o.signal_count} signals`,what_failed:"",recall_count:0,ts:o.derived_at,state:"meta",avg_confidence:o.avg_confidence,signal_count:o.signal_count,audit_trail:[{ts:new Date().toISOString(),action:"imported_meta"}]})),u++)}const c=[`\u{1F310} **Brain Import Meta-Lessons** (k \u2265 ${e})`,"","| Topic Category | Outcome | Confidence | Signals |","|---|---|---|---|"];for(const o of t.slice(0,15)){const d=(o.avg_confidence*100).toFixed(0)+"%";c.push(`| \`${o.topic_category}\` | ${o.dominant_outcome} | ${d} | ${o.signal_count} |`)}return t.length>15&&c.push(`| _\u2026${t.length-15} more_ | | | |`),c.push("",`\u2705 **${u}** new meta-lessons imported into local Brain.`),u<t.length&&c.push(`_(${t.length-u} already present \u2014 not overwritten)_`),c.join(`
+`)}case"brain_watch":{const{instance_id:y="",project_dir:a=".",api_key:n}=N,{resolve:t}=await import("node:path"),e=t(a),{result:l,hookPath:u}=await fe(e,y,n);return l==="skipped-no-git"?["\u26A0\uFE0F **brain_watch: no git repository found**","",`No \`.git\` directory in \`${e}\`.`,"Pass `project_dir` pointing to a git checkout."].join(`
+`):[`\u{1F9E0} **brain_watch ${{written:"\u2705 Hook installed (new)",upgraded:"\u{1F504} Hook upgraded to latest version",appended:"\u{1F4CE} Hook appended to existing post-commit script",unchanged:"\u2713 Hook already up to date \u2014 nothing changed"}[l]??l}**`,"",`Hook path: \`${u}\``,`Instance:  \`${y||"(none \u2014 set CACHLY_BRAIN_INSTANCE_ID or pass instance_id)"}\``,"","Every future commit will automatically teach your Brain.","No manual `brain_from_git` needed \u2014 the hook runs silently in the background.","",'\u{1F4A1} Verify: `git commit --allow-empty -m "test brain_watch"` then `smart_recall(query="test")`'].join(`
+`)}default:return null}}export{Oe as FEDBRAIN_TOOL_NAMES,ge as _lastBrainFromCiCounts,pe as _lastBrainFromGitCounts,Ne as handleFedbrainTool};