@cachly-dev/mcp-server 0.10.128 → 0.10.130

package/dist/src/handlers/brain.js

@@ -1,4181 +1,69 @@
-import { execSync } from 'node:child_process';
-import { createRequire } from 'node:module';
-import { calculateConfidence, confidenceBadge, STRUCTURED_TEMPLATES, CONFIDENCE_WARN_VALUE, CONFIDENCE_STALE_VALUE, CONFIDENCE_WARN_DAYS } from '../confidence.js';
-import { ckgSlug, extractProblemConcept, ckgUpsertNode, ckgUpdateEdge, ckgUpsertPersonNode, ckgUpsertFileNode, ckgRecordCollaboration, ckgUpsertServiceNode } from '../ckg.js';
-import { safeJsonParse, scanKeys } from '../utils.js';
-import { ersparteMinuten, istStarterLektion } from '../wertbeitrag.js';
-import { lessonPreviewLines, trimTo } from '../lesson-preview.js';
-import { meldeEinmal, OHNE_VEKTOREN, OHNE_DIENST, OHNE_FRAGEVEKTOR } from '../aussetzer.js';
-import { versuchStart, neueKennung, wendeZuteilungAn, schliesseVersuchAb } from '../versuch.js';
-/**
- * Preview for one smart_recall hit.
- *
- * WHY THIS EXISTS: the previous version sliced `r.content` — the RAW JSON of the
- * stored record — at 300/400 characters. So the budget was spent on syntax:
- *
- *   > {"topic":"node4:einrichtung-contabo-und-fallen","outcome":"success","sev…
- *
- * Roughly the first 80 characters carry no information at all, the reader gets
- * field names instead of facts, and `commands` / `what_failed` never appear
- * because they sit far past the cut. smart_recall is the call this project
- * mandates BEFORE EVERY TASK — it is the worst possible place for that.
- *
- * A lesson is now rendered as a lesson: trimmed prose, its warning when the
- * lesson is critical, and its commands/paths. Anything that is not a lesson
- * (context entries, indexes) keeps a raw preview — but trimmed at a word
- * boundary and with an honest cut marker.
- */
-export function recallVorschau(key, content, maxChars) {
-    if (key.includes('lesson:best:')) {
-        const l = safeJsonParse(content, {});
-        if (l && typeof l === 'object' && (l.what_worked || l.what_failed || l.commands?.length)) {
-            return lessonPreviewLines(l, { maxChars, indent: '  ' });
-        }
-    }
-    const roh = trimTo(content, maxChars);
-    return roh ? [roh] : [];
-}
-import { getRole, ROLE_BADGE, getScopes, lessonVisibleToScope, reviewModeEnabled, storeLessonProposal } from './team.js';
-import { keywordSearch, wortindexEntwerten, tokenize, splitMultiQuery, levenshtein, indexVocab as _indexVocab } from '../search.js';
-import { rerankByQuality, qualityMultiplier, extractLessonQuality } from '../rerank.js';
-import { computeEmbedding, hasEmbedProvider } from '../embeddings.js';
-import { VEKTOR_PRAEFIX, NAME_VEKTOR_PRAEFIX, packe, textFuerVektor, textFuerNamensVektor, Vektorbestand, } from '../bedeutung.js';
-import { schreibeEingaenge, Eingangsbestand, EINGANG_GEWICHT } from '../eingaenge.js';
-import { Seltenheitsbestand } from '../seltenheitsbestand.js';
-import { spurLegen } from '../spuren.js';
-import { bewerteTopf, spreizeImTopf, reichereAn, inhaltsWoerter, grobStamm, GEWICHTE, } from '../rangfolge.js';
-/**
- * Ein Vektorbestand fuer den ganzen Prozess.
- *
- * Er haelt rund 2 MB je 500 Lektionen im Arbeitsspeicher. Die bei jeder Frage
- * neu zu holen waere langsamer als der Wortabgleich, den wir gerade ergaenzen —
- * der Gewinn waere weg, bevor er anfaengt.
- */
-const vektorbestand = new Vektorbestand();
-/** Dieselbe Mechanik, andere Sicht: die Vektoren der Themennamen. */
-const namensbestand = new Vektorbestand(60_000, NAME_VEKTOR_PRAEFIX);
-/** Die Fehlertext-Eingaenge, je Lektion ihr bester. */
-const eingangsbestand = new Eingangsbestand();
-/** Die Wortstatistik des Bestands — stehend, nicht je Frage neu. */
-const seltenheitsbestand = new Seltenheitsbestand();
-import { upgradeNudge } from '../upgrade-nudge.js';
-import { recallTiefe, TIEFE_VOLL, TIEFE_VOLL_MEHRTHEMIG } from '../recall-tiefe.js';
-import { nutzungInWorten, nutzungsSchluessel, verdichte } from '../werkzeug-nutzung.js';
-import { inWorten as lieferungInWorten, lieferBild, lieferSchluessel, trefferSchluessel } from '../geliefert.js';
-import { COAUTHOR_PREF_KEY, autorHinweis, coautorAus, echterGitLeser, ermittleAutor, mitCoautor, nurMensch } from '../autor.js';
-import { TOOLS } from '../tools.js';
-import { vorspannHinweis } from '../vorspann.js';
-import { autorAbzeichen, fremdanteil } from '../autor-abzeichen.js';
-import { cachlyUrl } from '../cachly-url.js';
-// ── Changelog (shown once per version in session_start) ──────────────────────
-// Resolve the package version at runtime from package.json so the session briefing
-// `version` field always matches the published npm version. A hardcoded constant
-// silently drifted (0.10.119 vs published 0.10.122), making new-feature adoption
-// impossible to track. Paths cover both prod (dist/handlers/brain.js → ../../../) and
-// dev (src/handlers/brain.ts → ../../../). Falls back to a literal if resolution fails.
-const CURRENT_VERSION = (() => {
-    try {
-        const req = createRequire(import.meta.url);
-        for (const rel of ['../../../package.json', '../../package.json']) {
-            try {
-                const pkg = req(rel);
-                if (pkg.name === '@cachly-dev/mcp-server' && pkg.version)
-                    return pkg.version;
-            }
-            catch { /* try next candidate */ }
-        }
-    }
-    catch { /* fall through to literal */ }
-    return '0.10.100';
-})();
-// Resolve the total MCP tools count at runtime from generated capabilities.
-// This count is shown in session_start's What's-New briefing for the current version.
-// Falls back silently per CONTRACT: better to skip the count than show a wrong number.
-const getTotalMcpTools = () => {
-    try {
-        const req = createRequire(import.meta.url);
-        const caps = req('../../../CACHLY_CAPABILITIES.json');
-        return caps.mcp?.total_tools ?? null;
-    }
-    catch { /* fail silently */ }
-    return null;
-};
-const WHATS_NEW = {
-    '0.10.119': [
-        `🔍 **Explainable briefings — provenance in every warning**`,
-        `  📎 \`/briefing\` warnings now carry \`outcome\`, \`author\`, \`learned_at\` and \`matched_on\` (the context tokens that triggered the warning) — editors can show WHY a fix hint fired, not just what it claims.`,
-        `  🧰 VS Code 0.12.0 uses this: severity + confidence in the toast, full lesson card with provenance, "Not helpful" per-file suppression, reviewable CLS auto-learns.`,
-        `  🧹 CI docs now describe exactly what ships: scan mode uses the REST \`/scan\` endpoint, the GitLab template covers learn/scan/confirm.`,
-    ],
-    '0.10.115': [
-        `🔧 **\`brain_get_pref\` + \`brain_set_pref\` — persistent Brain preferences**`,
-        `  📖 \`brain_get_pref\` reads back any stored preference (omit key to list all).`,
-        `  ✏️ \`brain_set_pref\` saves a preference to Redis — survives restarts, scoped per Brain instance.`,
-        `  💡 Known key: \`auto_changelog\` — set to "false" to silence the new-lessons digest at session_start.`,
-        `  📊 140 MCP tools`,
-    ],
-    '0.10.114': [
-        `📋 **\`brain_changelog\` — weekly knowledge digest in one call**`,
-        `  📅 Generates a grouped Markdown changelog of lessons learned in the last N days.`,
-        `  👥 Grouped by topic category, annotated with author, recall count, and confidence — paste directly into standup or Slack.`,
-        `  ⚙️ Params: \`days\` (default 7), \`max_lessons\` (default 30), \`include_failures\` (default true).`,
-        `  📊 138 MCP tools`,
-    ],
-    '0.10.113': [
-        `📈 **Week-over-week savings trend in \`cache_stats\`**`,
-        `  📅 \`cache_stats\` now shows **7-day hits** + **WoW trend %** (e.g. \`+23.0% vs prev week\`) so ROI momentum is visible, not just the cumulative total.`,
-        `  ⬇️ Goes red (📉) on drops, green (📈) on growth — first week always shows +100% (new).`,
-        `  🔧 Backed by new \`CountHitsInWindow\` repo method + \`hits_last_7d\`, \`hits_prev_7d\`, \`week_over_week_pct\` fields in \`SavingsEstimate\`.`,
-        `  📊 137 MCP tools`,
-    ],
-    '0.10.112': [
-        `⚙️ **Configurable cost_per_call_usd — accurate ROI for any LLM**`,
-        `  💡 New \`set_cost_per_call\` tool: set your real per-call cost (claude-opus-4.8 → $0.02, gpt-5.5 → $0.015, claude-sonnet-4.6 → $0.009, claude-haiku-4.5 → $0.001) so savings estimates in \`cache_stats\` reflect your actual bill.`,
-        `  🔧 New API: \`PUT /api/v1/instances/:id/cost-per-call\` — persisted per instance, used by \`cache_stats\`, org savings, and SSE analytics stream.`,
-        `  📊 137 MCP tools`,
-    ],
-    '0.10.111': [
-        `🏢 **Org-wide ROI + GitLab CI — the CFO number, aggregated**`,
-        `  💰 \`cache_org_stats\` now shows **org-wide Tokenmaxxing ROI**: total savings summed across every instance in your org, monthly projection, top-5 instances by savings. One number for the whole team.`,
-        `  🔌 Backed by new API endpoint \`GET /api/v1/orgs/:id/savings\` (org members only)`,
-        `  🦊 GitLab CI integration: \`brain-from-ci-gitlab.yml\` — two \`.post\` jobs (on_success/on_failure), same helper script, pipeline never fails because of Brain push`,
-        `  🛠️ GitHub Action template fixed: \`secrets.*\` in job-level \`if\` is invalid — guard removed (helper script skips cleanly on missing secrets)`,
-        `  📊 136 MCP tools`,
-    ],
-    '0.10.110': [
-        `🏢 **Zero friction: ROI-Projektor, Org-Shared-Cache, CI ready-to-paste**`,
-        `  📈 \`cache_stats\` — zero-hit projection calculator: shows expected monthly savings for 5/10/20-dev teams before a single cache hit lands. ROI visible from day 1.`,
-        `  🏢 New \`cache_org_stats\` — shared org-level cache stats across multiple instances. Convention-based (\`org:{id}:sem\`), zero API changes needed.`,
-        `  🔗 \`cache_set\`/\`cache_get\` now accept optional \`org_id\` — write to personal + org namespace, fall back to org on miss. Fully backwards-compatible.`,
-        `  📋 Copy-paste CI integration: \`brain-from-ci-action.yml\` → Brain self-calibrates confidence on every GitHub Actions run. No config beyond two repo secrets.`,
-        `  📊 136 MCP tools`,
-    ],
-    '0.10.109': [
-        `💰 **Tokenmaxxing ROI + Closed-loop CI learning**`,
-        `  📊 \`cache_stats\` now shows a **Tokenmaxxing ROI** section — total tokens saved, monthly cost projection, and top 3 most-cached prompts. Finally a number you can show the CFO.`,
-        `  🔄 New \`brain_from_ci\` — bulk-ingest CI history into the Brain (red→green = learned fix, green→red = CKG causal edge). The brain_from_git equivalent for CI. Bootstrap the Brain from your CI logs in one call.`,
-        `  📊 134 MCP tools`,
-    ],
-    '0.10.108': [
-        `🧠 **Focused briefing + trustworthy autopilot**`,
-        `  🎯 New \`session_start_summary\` — top-N focused briefing by topic. Scores lessons by relevance × confidence + recall_count + severity + recency. Use it for a quick pre-brief without loading the full Brain.`,
-        `  🤝 Autopilot template now explains the data flow upfront ("your own Brain, EU-hosted, no third parties") — no more friction with cautious AI assistants during onboarding`,
-        `  📊 132 MCP tools`,
-    ],
-    '0.10.107': [
-        `🎯 **Recall@3 gap closed — the moat proof got sharper (the head-to-head that matters)**`,
-        `  🔍 External-corpus Recall@3 **82.1% → 98.2%** · Precision@1 **80.4%** · MRR **89.0%** — now ahead of flat-file memory on every metric`,
-        `  🧬 Root-cause fix: documents are no longer indexed with cross-lingual synonyms (the symmetric-expansion bug inflated any doc containing a common word ~28×, burying topic-specific lessons). Queries still expand — a 日本語 query still finds English lessons.`,
-        `  ⚖️ Reranker now compresses BM25 with score^0.3 before applying lesson quality, so a proven success can overtake a text-similar failed attempt even when the distractor scores 5–6× higher in raw BM25`,
-        `  🛡️ CI bench gate widened to both home + external corpora with committed floors (\`npm run bench:gate\`) — recall quality can never silently regress again`,
-        `  📊 121 MCP tools`,
-    ],
-    '0.10.98': [
-        `🌐 **Model-Neutrality as Feature (W9) — "Bring your own model, keep your brain."**`,
-        `  🔌 New \`brain_portability()\` — shows your Brain ID, all compatible MCP clients, and ready-to-paste config snippets for each; proves the same Brain works in Claude, Cursor, Copilot, Windsurf, Cline, Zed and more`,
-        `  🧠 Your lessons, crystals, and predictions are model-agnostic — no vendor lock-in at the memory layer`,
-        `  📖 New docs: cachly.dev/docs/model-neutral — "Same Brain, Any Model" guide with live config examples`,
-        `  📊 121 MCP tools (new: \`brain_portability\`)`,
-    ],
-    '0.10.97': [
-        `💠 **Team Crystallize (W8) — the team-wide, causal counter to per-user "Dreaming"**`,
-        `  🧬 New \`team_crystallize()\` — surfaces fixes that 2+ teammates *independently converged on*, the one thing a single-user memory structurally can't build`,
-        `  🧩 Cross-person clustering: groups structurally similar problems across people & namespaces (e.g. "pool exhaustion" solved the same way in payments, auth & db)`,
-        `  👥 Each pattern names who converged — instant "ask @alice and @bob, they both hit this"`,
-        `  💎 Shows up in \`crystal_view\` alongside your per-brain crystal`,
-        `  📊 120 MCP tools (new: \`team_crystallize\`)`,
-    ],
-    '0.10.96': [
-        `🔐 **Roles & Team-Scopes now ENFORCED (W6) — the enterprise governance layer**`,
-        `  🛡️ \`team_confirm\` is now reviewer-gated, \`team_learn\` blocks viewers (recall-only) — roles stop being cosmetic the moment an admin is assigned`,
-        `  📜 New \`team_audit\` tool — immutable, admin-only trail of every role change & lesson confirmation, for compliance & security reviews`,
-        `  🔓 Zero impact on open teams: governance activates only once you bootstrap an admin; before that everything works exactly as before`,
-        `  📊 119 MCP tools (new: \`team_audit\`)`,
-    ],
-    '0.10.95': [
-        `🧠 **Domain Brain Marketplace (W10) — bootstrap your Brain with curated community knowledge**`,
-        `  🛒 \`brain_marketplace()\` — browse installable packs of high-trust lessons by domain: ☸️ Kubernetes, 🔐 Auth, 🗄️ Database, ⚛️ React, 💳 Payments & more`,
-        `  📦 \`brain_install(slug="k8s")\` — merges a domain's verified lessons into your Brain; live in \`smart_recall\` instantly, even offline`,
-        `  🛡️ Idempotent + non-destructive: installed lessons are tagged \`source:"marketplace:<slug>"\` and NEVER override your own`,
-        `  🔌 New gRPC \`Subscribe\` RPC — agents get new lessons streamed live the moment they're learned (completes the M2M loop with \`Learn\`)`,
-        `  📊 118 MCP tools (new: \`brain_marketplace\`, \`brain_install\`)`,
-    ],
-    '0.10.94': [
-        `🤝 **Person↔Person Collaboration Graph (W5) — "Frag X und Y, die haben das zusammen gelöst"**`,
-        `  🕸️ New \`brain_collab_pairs()\` tool: shows every contributor pair who've touched the same files or recalled each other's lessons — ideal for onboarding and bus-factor analysis`,
-        `  📡 \`smart_recall\` now wires CKG \`collaborates\` edges live when cross-author reuse fires — collaboration graph grows with every team recall`,
-        `  ⚠️ Bus-factor section: flags solo contributors whose knowledge no teammate has yet recalled`,
-        `  📊 116 MCP tools (new: \`brain_collab_pairs\`)`,
-    ],
-    '0.10.93': [
-        `🗺️ **\`brain_plan\` — your Brain goes from "what did we learn?" to "what should I do?"**`,
-        `  🧭 Give it a task you're about to start ("upgrade Postgres 14→16") and it returns an ordered, grounded action plan: ranked failure modes to avoid, proven fix steps (dependency-aware, with commands), and a pre-flight checklist — all from your own lessons`,
-        `  🔬 Generative layer on the CKG: where \`brain_predict\` answers "what might fail?", \`brain_plan\` answers "what, in what order?"`,
-        `  📊 115 MCP tools (new: \`brain_plan\`)`,
-    ],
-    '0.10.92': [
-        `👋 **Welcome-back digest — re-entry after a week away now leads with what changed**`,
-        `  🌱 \`session_start\` detects a gap ≥ 7 days and surfaces how many lessons your Brain gained while you were gone (git, CI & teammates kept it learning), with the freshest topics`,
-        `  🧠 Zero extra latency — the digest is computed from data session_start already loads`,
-        `  🔌 New gRPC \`Learn\` RPC (M2M write path) — agents & CI can now teach the Brain directly, byte-compatible with the MCP lesson format`,
-        `  📊 115 MCP tools`,
-    ],
-    '0.10.91': [
-        `🕐 **Lesson-anchored time attribution — every recall shows when it was learned and how much it saves**`,
-        `  💡 "Brain saved you" banner now includes: when the lesson was learned (e.g. "12 May"), estimated original debug cost by severity (critical=2h, major=1h, minor=20min), and team attribution when a teammate's lesson fires`,
-        `  📅 Origin date formatted as "12 May" (same year) or "12 May 2024" (different year) — no clutter`,
-        `  👥 Cross-author recalls now show "@author" on the same banner line — the "team knowledge reuse" value is front-and-center`,
-        `  📊 115 MCP tools`,
-    ],
-    '0.10.90': [
-        `📊 **External benchmark corpus v2 — the proof is now statistically solid**`,
-        `  🧪 Expanded from 8 queries → 61 lessons / 56 queries across 10 real-world engineering domains (k8s, DB, auth, CI, frontend, API, payments, observability, network, Node.js, security, infra)`,
-        `  ⚔️  10 adversarial distractors added — failure lessons that share the exact same vocabulary as the query, forcing the quality reranker to earn its lift`,
-        `  📈 Results on the larger corpus: cachly +2.9% Precision@1 vs flat-file, +12.5% vs raw BM25 baseline — on a harder dataset, not an easy one`,
-        `  📊 115 MCP tools`,
-    ],
-    '0.10.89': [
-        `⚡ **One-command onboarding — \`autopilot\` is now the single canonical setup**`,
-        `  🚀 Every surface (README, docs, emails, dashboard, blog) now leads with \`npx @cachly-dev/mcp-server@latest autopilot\` — one command signs you in, configures every editor, and bootstraps from git`,
-        `  🧹 Retired the split-brain instructions (legacy \`@cachly-dev/init\` wrapper + the old "three steps") so there's exactly one thing to copy-paste`,
-        `  🔧 Fixed a build-breaking duplicate \`export\` on buildClaudeMdBlock that failed CI on v0.10.88`,
-        `  🔢 Version hygiene — package.json, server.json, lockfile and MCP_VERSION resynced (server.json/lockfile were stuck at 0.10.85)`,
-        `  📊 115 MCP tools`,
-    ],
-    '0.10.88': [
-        `✅ **Honest setup + tested config writer (v0.10.88)**`,
-        `  🔒 setup/autopilot now report the truth: if no editor config could be written it exits non-zero with the exact failures instead of falsely claiming "Brain is ready"`,
-        `  📊 New setup_config_write_failed telemetry — permission/path failures that block activation are now visible in reporting`,
-        `  🧪 24 new unit tests for the config writer (buildServerEnv, buildMcpConfig, mergeMcpConfig, buildClaudeMdBlock) — the merge logic that must never clobber your other MCP servers is now regression-guarded`,
-        `  📊 115 MCP tools`,
-    ],
-    '0.10.87': [
-        `🌐 **Multi-editor auth persistence + full activation telemetry (v0.10.87)**`,
-        `  ✅ JWT + instance_id now persisted to Cursor (\`~/.cursor/mcp.json\`) and Windsurf configs on auth — no more infinite re-auth for non-Claude-Code users`,
-        `  📡 \`device_flow_failed(reason="timeout")\` now fires when sign-in window expires — blind spot in the funnel is gone`,
-        `  📡 \`auto_provision_failed\` now fires on network errors too (was only HTTP non-2xx)`,
-        `  📡 \`brain_from_git_failed\` fires with error reason when auto-bootstrap throws — no more empty brain with no explanation`,
-        `  ✨ Git bootstrap shows lesson count in session_start: "Brain bootstrapped — 23 lessons loaded" — the WOW moment`,
-        `  🔧 API: McpEvent stores brain quality metrics (fixes/features/refactors/total) — git learning quality now measurable`,
-        `  📊 115 MCP tools`,
-    ],
-    '0.10.86': [
-        `🛡️ **Zero-friction activation — your Brain self-heals into existence**`,
-        `  🔧 Auto-provision now runs on *any* tool call, not just at sign-in — if instance creation ever fails once, the next call recovers it automatically`,
-        `  🤝 Parallel tool calls on startup are coalesced into one resolve (no more duplicate-instance races)`,
-        `  💬 Clearer "instance still starting" message — leads with "just retry", no manual config needed`,
-        `  📈 New activation-funnel telemetry: install → sign-in → provision, so silent churn is visible`,
-        `  📊 115 MCP tools`,
-    ],
-    '0.10.85': [
-        `🚀 **One-command onboarding — \`npx @cachly-dev/mcp-server@latest autopilot\`**`,
-        `  ⚡ Single command does it all: auth → instance → every editor config → CLAUDE.md → Brain bootstrap → health`,
-        `  🌱 Seeds the 16-lesson starter corpus when git history is empty — your first smart_recall hits instantly`,
-        `  🤖 Fully automatic (zero prompts); \`setup\` remains for interactive, pick-your-editors onboarding`,
-    ],
-    '0.10.84': [
-        `🤖 **M2M & agent-ecosystem reach — cachly for every caller, human or machine**`,
-        `  🔑 OAuth2 \`client_credentials\` grant — set CACHLY_CLIENT_ID + CACHLY_CLIENT_SECRET for fully headless auth (CI, agents, AI-to-AI)`,
-        `  🗂️ \`npx ... tool-specs --format=openai|anthropic|langchain\` — export all 121 tools in any framework's dialect`,
-        `  🌐 \`npx ... openapi\` — OpenAPI 3.1 doc (1 POST path per tool) for Assistants / codegen / Postman`,
-        `  🧪 14 new tests: client_credentials helpers, all four spec dialects, OpenAPI required-body inference`,
-    ],
-    '0.10.83': [
-        `🧠 **Brain Viz — 3D graph export**`,
-        `  🌐 \`brain_graph(instance_id)\` — exports the Causal Knowledge Graph as a render-ready {nodes, links} payload`,
-        `  🎨 Schema \`cachly.brain_graph/v1\`: node kinds (concept/person/file/service) with color groups + size, edges with confidence`,
-        `  🖥️ Consumed verbatim by the 3D frontend (react-force-graph-3d / three.js) — the visual brain map`,
-        `  🔎 Filters: \`domain\`, \`min_confidence\`, \`max_nodes\` (with truncation flag), \`format="summary"\``,
-        `  🧪 10 tests: kind detection, dangling-edge pruning, confidence/domain filters, schema contract`,
-        `  📊 115 MCP tools`,
-    ],
-    '0.10.82': [
-        `📡 **Telemetry API contracts — dashboard ingest pipeline prepared**`,
-        `  🗂️ \`src/telemetry-types.ts\` — canonical event types + resolved event format (TelemetryEventRaw / TelemetryEventResolved)`,
-        `  🔐 \`user_fingerprint\` — non-reversible JWT sub hash, PII-free user clustering for dashboard`,
-        `  📊 \`metrics\` block on key events: smart_recall (hit/topic), brain_from_git (fixes/features/total), brain_seed_starter (seeded_count)`,
-        `  🚦 Internal API contract documented: GET /internal/telemetry/stream → TelemetryEventResolved[]`,
-    ],
-    '0.10.81': [
-        `⏱️ **Onboarding-Bench — time-to-first-recall, now measured**`,
-        `  📐 \`npm run bench:onboarding\` — cold (empty) vs seeded (starter) first-query hit rate via the real search engine`,
-        `  📊 Result: first-query hit@1 **0% → 87.5%**, hit@3 **0% → 100%**, MRR **0% → 93.8%**`,
-        `  🛡️ CI-defended in \`onboarding-bench.test.ts\` (cold must answer 0%, seeded thresholds enforced)`,
-        `  📋 \`PLAN-DASHBOARD.md\` — full build spec for the external Team-Knowledge-Reuse dashboard (separate repo)`,
-    ],
-    '0.10.80': [
-        `🌱 **Starter corpus — first recall in seconds, not sessions**`,
-        `  📚 \`brain_seed_starter(instance_id)\` — seed 16 curated universal lessons (Docker cache, JWT skew, K8s OOM, N+1, cache stampede…)`,
-        `  🚀 Auto-seeds on first session when git history is empty/shallow — your first \`smart_recall\` returns a real hit`,
-        `  🛡️ Tagged \`source:"starter"\`, idempotent, never overrides your own lessons`,
-        `  ⏱️ Directly attacks time-to-first-recall (<2 min goal); stamps \`born_at\` on seed`,
-        `  🧪 18 new tests: seeding, idempotency, topic_filter, force, user-lesson protection`,
-        `  📊 113 MCP tools`,
-    ],
-    '0.10.79': [
-        `🌐 **Brain Marketplace — full shareable Brain lifecycle**`,
-        `  📋 \`brain_share_list(instance_id)\` — see all your public shares with lesson counts + share IDs`,
-        `  🗑️ \`brain_unshare(share_id)\` — revoke a share; link goes dead immediately`,
-        `  🔍 \`brain_discover(query, topic)\` — search public Brains in the cachly marketplace`,
-        `  📤 \`publish\` CLI — fancy card + share URL; \`--public\` for discoverable; \`--title\` custom name`,
-        `  🧪 stress tests: team_expertise_map with 50 contributors, chain import/unshare, discover fallback`,
-        `  📊 112 MCP tools`,
-    ],
-    '0.10.78': [
-        `🌐 **Phase 3: Shareable / Public Brains**`,
-        `  📤 \`brain_share(instance_id="...")\` — export a Brain snapshot as a shareable link (public or unlisted)`,
-        `  📥 \`brain_import(instance_id="...", share_id="...")\` — import any public Brain into yours (1-line)`,
-        `  🔍 Optional topic_filter, min_confidence, topic_prefix — precise control over what gets shared/imported`,
-        `  🔒 dry_run mode on both tools — preview before committing`,
-        `  🧪 Regression suite added: share handler, buildServerEnv, stdout cleanness`,
-        `  📊 109 MCP tools`,
-    ],
-    '0.10.77': [
-        `🩹 **Frictionless onboarding + first-class self-hosting/BYOK**`,
-        `  🚀 Editor-launched server now serves all tools even before sign-in — zero-credential device flow finally triggers on first tool call`,
-        `  🔒 No more stdout pollution: stdio JSON-RPC stream stays clean when no JWT is set`,
-        `  🏠 \`setup --api-url\` / \`init --api-url\` point at a self-hosted backend; URL baked into config only when non-default`,
-        `  🧬 \`health\` now shows your BYOK embedding provider + accepts cky_ long-lived keys (was a false "invalid token" failure)`,
-    ],
-    '0.10.76': [
-        `📊 **Agent-trace benchmark + editor matrix + setup timer**`,
-        `  📂 New \`agent-traces-corpus.json\` — 22 lessons, 15 queries, realistic AI-agent debug patterns`,
-        `  🏆 Benchmark result: **P@1 +66.7%, MRR +9.5% vs flat-file** (adversarial failure-distractors per category)`,
-        `  📋 README: first-class editor support matrix (Claude Code, Cursor, Windsurf, VSCode, Cline, Continue.dev, Zed)`,
-        `  ⏱️  setup now shows elapsed time + "Brain is ready" banner at the end`,
-    ],
-    '0.10.75': [
-        `🩹 **Setup hardened — works from the VSCode plugin & any non-TTY terminal**`,
-        `  🔌 \`setup\` no longer hangs on a non-interactive stdin (VSCode tasks, CI) — auto-detects + runs in automatic mode`,
-        `  🔐 Device-flow now uses the API proxy first (the old direct-Keycloak call returned 403) — sign-in actually completes`,
-        `  🌐 When auto sign-in is unavailable, the browser opens with a step-by-step API-key guide instead of a silent paste prompt`,
-        `  📊 Funnel fix: \`device_flow_completed\` / \`device_flow_failed(reason)\` now emitted from setup too`,
-    ],
-    '0.10.73': [
-        `🔐 **Team visibility scopes + one-command init + external bench**`,
-        `  🆕 \`team_grant_scope\` / \`team_scopes\` — scope lessons to a sub-team (group="security"); only members + admins recall them`,
-        `  🏷️ \`learn_from_attempts(group="...")\` — orthogonal to private; smart_recall enforces it per requester`,
-        `  ⚡ \`init\` is now zero-arg + idempotent (reuses saved creds, only writes what changed, <60s)`,
-        `  📦 \`npm run bench:external\` — prove recall-lift on a third-party-labeled corpus (portable JSON format)`,
-        `  📊 107 MCP tools`,
-    ],
-    '0.10.72': [
-        `👑 **Role model — admin · reviewer · contributor · viewer (Phase 3)**`,
-        `  🆕 \`team_assign_role\` — establish governance; first call bootstraps, admins manage the rest`,
-        `  🆕 \`team_whoami\` — see your own role and capabilities`,
-        `  🆕 \`team_roster\` — full team role table (👑🛡️✏️👁️)`,
-        `  🛡️ \`team_confirm\` is now role-aware — admin/reviewer auto-get senior weight; contributor gets peer; no self-promotion`,
-        `  👑 Setup CLI now prompts for governance bootstrap (idempotent). 105 MCP tools`,
-    ],
-    '0.10.71': [
-        `🛡️ **Self-healing auth** — no more silent "0 recalls because the token quietly died"`,
-        `  ♻️ Near-expiry tokens auto-refresh into a long-lived key while still valid (zero interaction)`,
-        `  🔁 A rejected (401) call self-heals once and retries before surfacing an error`,
-        `  📣 If the credential is truly dead, session_start + get_api_status say so plainly + how to fix`,
-    ],
-    '0.10.70': [
-        `🛰️ **Service/System nodes in the graph (Phase 3)** — the brain now models running systems`,
-        `  🆕 \`brain_service_map(service="prometheus")\` — who owns it + every failure/fix known`,
-        `  🏷️ Tag lessons with \`service="..."\` (\`service_kind="system"\` for infra) — person→operates, file→runs_in edges`,
-        `  🚨 Incident triage: a restarting pod → instant "who knows this and what's broken before"`,
-        `  📊 102 MCP tools`,
-    ],
-    '0.10.69': [
-        `📁 **Personalized context-aware recall (Phase 3)** — pass \`context_files\` to \`smart_recall\``,
-        `  🎯 Lessons learned on your current files bubble up — even when the query doesn't name the file`,
-        `  🏷️ \`📁 context match\` badge on every file-boosted result so you know WHY it ranked up`,
-        `  ✅ Works alongside keyword, semantic, CKG, and governance signals — a 6th ranking dimension`,
-    ],
-    '0.10.68': [
-        `🤝 **Collaboration graph (Phase 3)** — person↔person edges from shared files`,
-        `  👥 \`brain_who_knows\` now shows who the top expert frequently works with`,
-        `  🚌 Bus-factor insight: "ask X and Y together — they solved this on shared files"`,
-        `  🛡️ Stability: every network call in the agent hot path is now timeout-bounded`,
-    ],
-    '0.10.64': [
-        `📈 **The three decisive metrics, now measurable**`,
-        `  ⏱️ \`brain_metrics()\` — time-to-first-recall, recall-lift, team-knowledge-reuse in one view`,
-        `  👥 Cross-author reuse tracked: recall a teammate's lesson → counted + surfaced inline`,
-        `  🛡️ Stability: scans now capped + timed out (a huge keyspace can't hang the agent)`,
-    ],
-    '0.10.61': [
-        `🎯 **Phase 3C: 100 MCP tools milestone — zero-setup knowledge graph**`,
-        `  🔄 \`brain_from_git\` now auto-builds Person+File nodes from git history (zero setup!)`,
-        `  🔍 \`skill_gaps()\` — find domains with unresolved failures, missing attribution`,
-        `  📊 \`brain_coverage()\` — scored 0-100 health report: lessons · attribution · file coverage`,
-    ],
-    '0.10.60': [
-        `🆕 **Phase 3B: File map + team overview + visibility**`,
-        `  📁 \`brain_file_map(file_paths=[...])\` — experts + lessons per file before you touch it`,
-        `  🗺️ \`team_expertise_map()\` — full team skills matrix in one table`,
-        `  🔒 \`visibility: "private"\` on \`learn_from_attempts\` — private notes never leak to smart_recall`,
-        `  📊 98 MCP tools`,
-    ],
-    '0.10.59': [
-        `🆕 **Phase 3A: Org-wide knowledge graph**`,
-        `  👥 \`brain_who_knows(topic="...")\` — find your team's experts on any topic instantly`,
-        `  🕸️ Person + File nodes auto-built from \`learn_from_attempts(author="...", file_paths=[...])\``,
-        `  👤 Author attribution now shown inline in \`smart_recall\` results`,
-        `  📊 96 MCP tools · 386 tests green`,
-    ],
-    '0.10.58': [
-        `🧹 Zero lint warnings — all unused imports cleaned across every handler`,
-        `✅ Build: 0 errors, 0 warnings · 379 tests green`,
-    ],
-    '0.10.57': [
-        `🆕 **What's new in v${CURRENT_VERSION}:**`,
-        `  🔧 **Critical fix** — corrected the npm bin/main entry path (\`dist/src/index.js\`); 0.10.50–0.10.52 shipped a broken entry point`,
-        `  🔧 Version hygiene — synced package.json, server.json, lockfile, MCP_VERSION; \`latest\` now points forward again`,
-        `  ✅ Accurate tool count (95) across README, server.json, CLI banners`,
-        `  ✅ Includes all Phase 2/3 work: quality reranking, Cachly-Bench, hybrid + CKG recall, team_confirm governance`,
-    ],
-    '0.10.52': [
-        `  ✅ \`smart_recall\` — CKG traversal as Layer 3: finds lessons that FIXED causal-graph-similar problems (🕸️ causal graph badge)`,
-        `  ✅ Bench corpus expanded: governance adversarial pair proves review-boost end-to-end (+22% P@1 headline)`,
-        `  🔧 Import cleanup: unused symbols removed from brain.ts (no functional change)`,
-        `  💡 \`smart_recall\` now shows keyword / semantic / CKG / hybrid match type for every result`,
-    ],
-    '0.10.51': [
-        `  ✅ \`team_confirm\` — human review raises lesson recall ranking (🛡️ senior / ✔️ peer)`,
-        `  ✅ Governance-aware recall — confirmed lessons outrank unreviewed auto-learned entries`,
-    ],
-    '0.10.50': [
-        `  ✅ \`smart_recall\` — unified keyword + semantic hybrid list (one ranked result, not two sections)`,
-        `  ✅ \`smart_recall\` — "Brain saved you here" banner surfaces time saved inline per proven lesson`,
-        `  ✅ Quality reranking — proven successes outrank symptom-dense failures (+11% Precision@1)`,
-        `  ✅ Cachly-Bench — IR benchmark with CI regression guard (see BENCH.md for the proof)`,
-        `  🔧 Contradiction resolution now persisted to Redis (90-day TTL)`,
-        `  💡 Run \`smart_recall\` to see your Brain's recall quality in action`,
-    ],
-    '0.10.49': [
-        `  ✅ \`brain_from_git\` — auto-seed your Brain from git history in seconds`,
-        `  ✅ \`brain_predict_failures\` — predict CI/build failures before they happen`,
-        `  ✅ VS Code extension — Brain status bar, ambient learning, CodeLens hints`,
-        `  ✅ Team Brain — share lessons across your whole engineering team`,
-        `  🔧 Stability — auto-expiring memory keys, longer provisioning wait, robust recall`,
-    ],
-};
-export const BRAIN_TOOL_NAMES = new Set([
-    'learn_from_attempts', 'recall_best_solution', 'smart_recall',
-    'session_start', 'session_start_summary', 'session_end', 'session_ping', 'session_handoff', 'auto_learn_session',
-    'brain_who_knows', 'brain_file_map', 'team_expertise_map',
-    'skill_gaps', 'brain_coverage', 'brain_metrics', 'brain_service_map',
-    'brain_collab_pairs', 'brain_portability', 'brain_changelog',
-    'brain_set_pref', 'brain_get_pref',
-]);
-// ── Free-tier Teaser-Gate ──────────────────────────────────────────────────
-// When a Free-tier Brain crosses its recall limit, smart_recall still delivers
-// the top hit — the magic moment is sacred — but withholds the long tail
-// behind an upgrade teaser ("🔒 N further relevant lessons withheld"). This is a
-// DEPTH gate (hide the tail), never an access wall: the #1 result is always
-// returned. Usage/limit come from the same authoritative numbers as the Brain
-// Health bar (GET /instances/:id/memory), cached briefly to avoid per-call latency.
-//
-// Diese Zusage stand von 2026-07 bis 2026-08-18 NUR hier im Kommentar, waehrend
-// der Zweig `visibleCount = gateActive ? 0 : 8` null Treffer zurueckgab. Seither
-// ist sie eine Funktion mit Gegenprobe: ../recall-tiefe.ts (GROW-043).
-const UPGRADE_URL = cachlyUrl('/billing', 'upgrade');
-const _recallGateCache = new Map();
-/**
- * Instances whose notice has already been shown in this process.
- *
- * Once per PROCESS, not once per call: the MCP server lives for the length of
- * the editor session, so this is exactly "once per session". Without it the
- * notice would repeat on every session_start — and with Ambient Recall that is
- * every prompt. That is the nagging the upgrade nudge was built to avoid, and
- * a line that appears every time stops being read within a day.
- */
-const _noticeGezeigt = new Set();
-// ── Recall quota: ONE unit per recall CALL ───────────────────────────────────
-// The gate above reads a monthly counter that this function writes. It counts
-// calls, not lessons.
-//
-// It used to be derived from the sum of every lesson's recall_count, and a
-// single smart_recall bumps up to five of those — so a free user burned their
-// 500 in about a hundred real calls and the number kept climbing past the cap.
-// The API's REST recall endpoint counts itself; this is the MCP side of the
-// same counter, and without it the cap would simply never be reached here.
-const RECALL_QUOTA_TTL_SECONDS = 70 * 24 * 60 * 60;
-function recallQuotaKey(now = new Date()) {
-    // UTC month, matching the API's t.UTC().Format("2006-01"). Month-scoping in
-    // the key is what makes the quota reset with no cron and no baseline.
-    return `cachly:quota:recalls:${now.toISOString().slice(0, 7)}`;
-}
-async function bumpRecallQuota(redis) {
-    try {
-        const key = recallQuotaKey();
-        const n = await redis.incr(key);
-        if (n === 1)
-            await redis.expire(key, RECALL_QUOTA_TTL_SECONDS);
-    }
-    catch {
-        // Accounting must never fail a recall. Under-counting costs us a little
-        // revenue; a thrown error costs the user the answer they asked for.
-    }
-}
-async function getRecallGate(instanceId, apiFetch) {
-    const cached = _recallGateCache.get(instanceId);
-    if (cached && cached.expiresAt > Date.now())
-        return cached.gate;
-    try {
-        const mem = await apiFetch(`/api/v1/instances/${instanceId}/memory`);
-        const limit = mem?.recall_limit ?? -1;
-        const used = mem?.total_recall_count ?? 0;
-        const gate = {
-            reached: limit > 0 && used >= limit,
-            limit,
-            used,
-            goodwillMessage: mem?.goodwill_message,
-            notice: mem?.notice,
-        };
-        _recallGateCache.set(instanceId, { gate, expiresAt: Date.now() + 60_000 });
-        return gate;
-    }
-    catch {
-        // Stats unavailable → never gate (fail open: value delivery beats monetization).
-        return { reached: false, limit: -1, used: 0 };
-    }
-}
-export async function handleBrainTool(name, args, getConnection, apiFetch) {
-    switch (name) {
-        case 'learn_from_attempts': {
-            const { instance_id, topic, outcome, what_worked, what_failed = '', context: ctx = '', severity = 'major', file_paths = [], commands = [], tags = [], depends_on = [], author = '', visibility = 'team', service = '', service_kind = 'service', group = '', } = args;
-            const redis = await getConnection(instance_id);
-            const ts = new Date().toISOString();
-            /*
-             * ── Der Autor wird HERGELEITET, nicht erwartet ─────────────────────
-             *
-             * Gemessen am 19.08.2026: 195 von 493 Lektionen ohne Autor. `author`
-             * war ein optionales Feld, das ein Agent bei jedem Aufruf mitschicken
-             * sollte — und natuerlich vergisst. Dabei steht der Name in
-             * `git config user.name`.
-             *
-             * Ein Pflichtfeld, das man vergessen kann, ist kein Pflichtfeld.
-             */
-            const herkunft = ermittleAutor({
-                uebergeben: author,
-                umgebung: process.env.CACHLY_AUTHOR,
-                git: echterGitLeser(process.env.CACHLY_WORKSPACE ?? process.cwd()),
-            });
-            // Mitautor nur, wenn ausdruecklich eingeschaltet — Standard ist aus.
-            let coautor = '';
-            try {
-                coautor = coautorAus(await redis.get(`cachly:prefs:${COAUTHOR_PREF_KEY}:${instance_id}`));
-            }
-            catch { /* eine Einstellung darf das Speichern nie stoppen */ }
-            const autorFeld = mitCoautor(herkunft.autor, coautor);
-            const autorTipp = autorHinweis(herkunft);
-            // ── Lessons-Review workflow (P1-1) ─────────────────────────────────────
-            // When the org enabled pending-mode on this (shared) brain, team-visible
-            // lessons become proposals awaiting owner/admin approval instead of
-            // landing in the recall keyspace. Private notes stay direct — they never
-            // surface in team recall anyway. Flag absent = direct write, as before.
-            if (visibility !== 'private' && await reviewModeEnabled(redis, instance_id)) {
-                return storeLessonProposal(redis, topic, {
-                    topic, outcome, what_worked, what_failed, context: ctx, severity,
-                    file_paths, commands, tags, depends_on,
-                    ...(autorFeld ? { author: autorFeld } : {}),
-                    ...(service ? { service } : {}),
-                    ...(group ? { group: String(group).toLowerCase().trim() } : {}),
-                    visibility, recall_count: 0, ts, confidence: 1.0, version: 3,
-                });
-            }
-            // ── Structured template hints ──────────────────────────────────────────
-            const category = topic.split(':')[0];
-            const template = STRUCTURED_TEMPLATES[category];
-            const templateWarnings = [];
-            if (template) {
-                for (const req of template.required) {
-                    if (req === 'commands' && commands.length === 0) {
-                        templateWarnings.push(`📋 ${template.hint}`);
-                    }
-                }
-            }
-            // ── Deduplication + audit trail ────────────────────────────────────────
-            let isUpdate = false;
-            let recallCount = 0;
-            let lastRecalledAt;
-            let auditTrail = [];
-            const existingRaw = await redis.get(`cachly:lesson:best:${topic}`);
-            if (existingRaw) {
-                try {
-                    const prev = JSON.parse(existingRaw);
-                    recallCount = prev.recall_count ?? 0;
-                    lastRecalledAt = prev.last_recalled_at; // learn never stamps it — only recall does
-                    auditTrail = prev.audit_trail ?? [];
-                    auditTrail.push({ ts, action: 'updated', prev_outcome: prev.outcome });
-                    if (auditTrail.length > 20)
-                        auditTrail = auditTrail.slice(-20);
-                    isUpdate = true;
-                    // ── Contradiction detection ─────────────────────────────────────────
-                    const contradictionWarning = [];
-                    if (prev.outcome === 'success' && outcome === 'failure') {
-                        contradictionWarning.push(`⚠️ **Contradiction detected!** Existing lesson has outcome: \`success\`, but you're storing \`failure\`.`, `The existing "success" lesson will be preserved. Only the audit trail is updated.`, `If you meant to mark this as failed permanently, store a new lesson with a distinct topic slug.`);
-                    }
-                    else if (prev.outcome === 'failure' && outcome === 'success') {
-                        contradictionWarning.push(`✅ **Conflict resolved!** Previous lesson was \`failure\` — now overwriting with \`success\`.`);
-                    }
-                    if (contradictionWarning.length > 0) {
-                        // Store contradiction audit but don't block
-                        auditTrail[auditTrail.length - 1].action = 'contradiction-resolved';
-                        // Layer 3: Write CKG contradicts edge for MADC to process
-                        try {
-                            const cId = ckgSlug(topic);
-                            const resId = ckgSlug(`resolution:${topic}`);
-                            await ckgUpdateEdge(redis, cId, 'contradicts', resId, false);
-                        }
-                        catch { /* non-critical */ }
-                        // Persist a queryable resolution record — so contradiction history survives
-                        // (CKG edges alone aren't easily auditable). Bounded + TTL'd like other history.
-                        try {
-                            const resolutionKey = `cachly:contradictions:${topic}`;
-                            const direction = prev.outcome === 'success' && outcome === 'failure'
-                                ? 'kept-success' : 'overwrote-failure';
-                            await redis.rpush(resolutionKey, JSON.stringify({
-                                ts, prev_outcome: prev.outcome, new_outcome: outcome, direction,
-                            }));
-                            await redis.ltrim(resolutionKey, -50, -1);
-                            await redis.expire(resolutionKey, 180 * 86400);
-                        }
-                        catch { /* non-critical */ }
-                        contradictionWarning.push(`🗳️ Run \`madc_deliberate(topic="${topic}")\` to resolve via expert agent voting.`);
-                    }
-                }
-                catch { /* ignore parse error */ }
-            }
-            else {
-                auditTrail = [{ ts, action: 'created' }];
-            }
-            // ── "I Was Wrong" Protocol — failure attribution ───────────────────────
-            const iWasWrongWarning = [];
-            if (outcome === 'failure') {
-                // Search for related success lessons that might have prevented this failure
-                const scanKeys = [];
-                const scanStream = redis.scanStream({ match: 'cachly:lesson:best:*', count: 100 });
-                await new Promise((res, rej) => {
-                    scanStream.on('data', (b) => scanKeys.push(...b));
-                    scanStream.on('end', res);
-                    scanStream.on('error', rej);
-                });
-                const topicWords = topic.split(/[:\-_]/).filter(w => w.length > 2);
-                for (const k of scanKeys.slice(0, 50)) {
-                    const raw = await redis.get(k);
-                    if (!raw)
-                        continue;
-                    try {
-                        const l = JSON.parse(raw);
-                        if (l.outcome !== 'success')
-                            continue;
-                        const lWords = (l.topic ?? '').split(/[:\-_]/).filter(w => w.length > 2);
-                        const overlap = topicWords.filter(w => lWords.includes(w)).length;
-                        if (overlap >= 1 && l.topic !== topic) {
-                            iWasWrongWarning.push(`⚠️ **"I Was Wrong"**: lesson \`${l.topic}\` (success, ${l.severity ?? 'major'}) might have prevented this failure.`, `   → Use \`recall_best_solution(topic="${l.topic}")\` before next attempt.`, `   → To mark it critical: \`learn_from_attempts(topic="${l.topic}", ..., severity="critical")\``);
-                            break; // only show the most relevant match
-                        }
-                    }
-                    catch { /* skip */ }
-                }
-            }
-            // ── Register dependency index for causal chain ─────────────────────────
-            for (const dep of depends_on) {
-                const depKey = `cachly:dep:${dep}`;
-                const existing = await redis.get(depKey);
-                const depTopics = safeJsonParse(existing, []);
-                if (!depTopics.includes(topic))
-                    depTopics.push(topic);
-                await redis.set(depKey, JSON.stringify(depTopics), 'EX', 90 * 86400);
-            }
-            const lessonObj = {
-                topic,
-                outcome,
-                what_worked,
-                what_failed,
-                context: ctx,
-                severity,
-                file_paths,
-                commands,
-                tags,
-                depends_on,
-                // Auch hier der hergeleitete Name — sonst traegt die gespeicherte
-                // Lektion selbst keinen Autor, waehrend der Kausalgraph einen hat.
-                ...(autorFeld ? { author: autorFeld } : {}),
-                ...(service ? { service } : {}),
-                ...(group ? { group: String(group).toLowerCase().trim() } : {}),
-                visibility,
-                recall_count: recallCount,
-                ...(lastRecalledAt ? { last_recalled_at: lastRecalledAt } : {}),
-                ts,
-                verified_at: outcome === 'success' || outcome === 'partial' ? ts : undefined,
-                confidence: 1.0,
-                audit_trail: auditTrail,
-                version: 3,
-            };
-            const lesson = JSON.stringify(lessonObj);
-            // Metric 1 (time-to-first-recall): mark the moment the Brain first gained
-            // knowledge. SET NX so only the very first learn wins. Fire-and-forget.
-            redis.set(`cachly:stats:born_at:${instance_id}`, ts, 'EX', 365 * 86400, 'NX').catch(() => { });
-            // Always append to the history list (audit log); keep last 100 entries, 90-day TTL
-            const listKey = `cachly:lessons:${topic}`;
-            await redis.rpush(listKey, lesson);
-            await redis.ltrim(listKey, -100, -1);
-            await redis.expire(listKey, 90 * 86400);
-            // Update best key for success/partial; for failure only update if no success exists
-            let bestGeschrieben = false;
-            if (outcome === 'success' || outcome === 'partial') {
-                await redis.set(`cachly:lesson:best:${topic}`, lesson);
-                bestGeschrieben = true;
-            }
-            else if (!existingRaw) {
-                await redis.set(`cachly:lesson:best:${topic}`, lesson);
-                bestGeschrieben = true;
-            }
-            // Der stehende Wortindex kennt die neue Lektion noch nicht.
-            //
-            // Ohne diese Zeile waere sie bis zu eine Minute lang nicht auffindbar —
-            // und genau der Fall "gerade gelernt, sofort gesucht" ist der, bei dem
-            // ein Gedaechtnis sich beweisen muss. Der Index wird beim naechsten
-            // Recall neu gebaut, nicht hier: Lernen soll nicht auf das Bauen warten.
-            if (bestGeschrieben)
-                wortindexEntwerten();
-            // ── Vektor fuer den Bedeutungsabgleich ─────────────────────────────────
-            //
-            // Wird beim Schreiben berechnet, nicht beim Suchen. Der Grund steht in
-            // Zahlen: die Einbettung kostet rund 280 ms Netz. Einmal je Lektion ist
-            // das nichts, bei jeder Frage waere es der halbe Gewinn.
-            //
-            // Bewusst NICHT abgewartet: wer eine Lektion speichert, soll nicht auf
-            // einen fremden Dienst warten. Faellt die Einbettung aus, fehlt der
-            // Vektor — und der Bedeutungsabgleich uebergeht diese eine Lektion still.
-            // Das ist der Preis dafuer, dass Lernen immer funktioniert, auch ohne
-            // Netz. Wie viele Lektionen einen Vektor haben, meldet brain_doctor.
-            if (bestGeschrieben && hasEmbedProvider()) {
-                void (async () => {
-                    const gelesen = safeJsonParse(lesson, {});
-                    try {
-                        const v = await computeEmbedding(textFuerVektor(gelesen));
-                        if (v?.length)
-                            await redis.set(`${VEKTOR_PRAEFIX}${topic}`, packe(v));
-                    }
-                    catch { /* kein Vektor ist besser als keine Lektion */ }
-                    // Der Themenname als eigene Sicht.
-                    //
-                    // Er ist kurz und frageaehnlich; eine 60-Zeichen-Frage gegen 60
-                    // Zeichen zu halten ist symmetrisch, gegen 1376 Zeichen Volltext
-                    // nicht. Der Sortierer bewertet beide getrennt (naeheText 1,0,
-                    // naeheThema 0,6). Bis zum 20.08.2026 gab es diese Vektoren nur im
-                    // Messstand — deshalb war rangfolge.ts auch nie verdrahtet.
-                    try {
-                        const nv = await computeEmbedding(textFuerNamensVektor(topic));
-                        if (nv?.length)
-                            await redis.set(`${NAME_VEKTOR_PRAEFIX}${topic}`, packe(nv));
-                    }
-                    catch { /* siehe oben */ }
-                    // Die zweite Tuer: woertliche Fehlertexte als eigene Eingaenge.
-                    //
-                    // Gemessen am 20.08.2026 an 499 Lektionen mit zwei unabhaengigen
-                    // 100-Fragen-Saetzen: von fuenf ausprobierten Tuerarten traegt genau
-                    // DIESE eine. Erstsatz und Uebersetzung brachten null, der Themenname
-                    // steckt schon im Sortierer. Volle Zahlen und Gegenproben stehen in
-                    // .agent/cachly/tor0-tor1-ergebnis.md.
-                    //
-                    // Genau wie der Vektor: nicht abgewartet, Fehler verschluckt. Eine
-                    // Lektion muss auch ohne Netz gespeichert werden koennen.
-                    try {
-                        await schreibeEingaenge(redis, topic, gelesen, computeEmbedding);
-                    }
-                    catch { /* keine Eingaenge ist besser als keine Lektion */ }
-                })();
-            }
-            // Track in decision log for session replay
-            try {
-                const dlKey = 'cachly:session:decision-log';
-                const dlEntry = JSON.stringify({ ts, topic, outcome, what_worked: what_worked.slice(0, 120) });
-                await redis.rpush(dlKey, dlEntry);
-                await redis.ltrim(dlKey, -50, -1);
-            }
-            catch { /* non-critical */ }
-            // ── Layer 1+2: CKG update (Causal Knowledge Graph + Belief Update Engine) ──
-            // BUE: Bayesian confidence, contradiction detection, second-degree propagation, decay
-            let beliefConflict = null;
-            try {
-                const conceptId = ckgSlug(topic);
-                const domain = topic.split(':')[0] ?? 'unknown';
-                const conceptType = domain; // fix, debug, deploy, infra, api, etc.
-                // Upsert concept node
-                await ckgUpsertNode(redis, conceptId, domain, conceptType);
-                // Tag co-occurrence edges
-                for (const tag of tags) {
-                    const tagId = ckgSlug(`tag:${tag}`);
-                    await ckgUpsertNode(redis, tagId, 'tag', 'tag');
-                    await ckgUpdateEdge(redis, conceptId, 'co-occurs', tagId, outcome === 'success', outcome === 'partial');
-                }
-                // depends_on → requires edges (structural, always confidence 1.0 direction)
-                for (const dep of depends_on) {
-                    const depId = ckgSlug(dep);
-                    await ckgUpdateEdge(redis, conceptId, 'requires', depId, true);
-                }
-                // fixes edge: if category=fix and outcome=success, link to problem concept
-                if ((domain === 'fix' || domain === 'debug') && (outcome === 'success' || outcome === 'partial')) {
-                    const problemText = what_failed || ctx || '';
-                    const problemConcept = problemText ? extractProblemConcept(problemText) : null;
-                    if (problemConcept) {
-                        const problemId = ckgSlug(`problem:${problemConcept}`);
-                        await ckgUpsertNode(redis, problemId, 'problem', 'problem');
-                        await ckgUpdateEdge(redis, conceptId, 'fixes', problemId, outcome === 'success', outcome === 'partial');
-                    }
-                }
-                // causes edge: if outcome=failure, link topic concept to the problem context
-                if (outcome === 'failure' && (what_failed || what_worked)) {
-                    const causeText = what_failed || what_worked;
-                    const causeConcept = extractProblemConcept(causeText);
-                    if (causeConcept) {
-                        const causeId = ckgSlug(`cause:${causeConcept}`);
-                        await ckgUpsertNode(redis, causeId, 'cause', 'cause');
-                        await ckgUpdateEdge(redis, conceptId, 'causes', causeId, false);
-                    }
-                }
-                // ── BUE: Contradiction detection ──────────────────────────────────────
-                // If this topic previously had a confirmed 'fixes' edge (confidence > 0.7)
-                // and now outcome=failure → flag belief_conflict
-                if (outcome === 'failure') {
-                    const existingEdgeKeys = await redis.smembers(`cachly:ckg:idx:from:${conceptId}`);
-                    for (const ek of existingEdgeKeys) {
-                        const er = await redis.get(ek);
-                        if (!er)
-                            continue;
-                        const existEdge = safeJsonParse(er, null);
-                        if (!existEdge)
-                            continue;
-                        if (existEdge.edgeType === 'fixes' && existEdge.confidence > 0.7 && existEdge.trials >= 3) {
-                            beliefConflict = `⚠️ **belief_conflict** on \`${topic}\`: previously confirmed fix (confidence ${existEdge.confidence.toFixed(2)}, n=${existEdge.trials}) now reports failure. Both beliefs retained as \`contested\`. Use \`brain_resolve_conflict(instance_id="...", topic="${topic}", winner="success"|"failure")\` to arbitrate, or \`ckg_inspect(concept="${conceptId}")\` to review.`;
-                            // Store conflict marker — records WHICH agent reported the contradiction
-                            // so multi-agent arbitration can show both sides (Move 4).
-                            const conflictKey = `cachly:ckg:conflict:${conceptId}`;
-                            await redis.set(conflictKey, JSON.stringify({
-                                topic,
-                                concept_id: conceptId,
-                                detected_at: new Date().toISOString(),
-                                fix_confidence: existEdge.confidence,
-                                fix_trials: existEdge.trials,
-                                failure_outcome: outcome,
-                                reported_by: autorFeld || 'unknown',
-                                what_failed: what_failed || '',
-                                resolved: false,
-                            }), 'EX', 60 * 60 * 24 * 90);
-                            // Auto-trigger MADC deliberation in background — never blocks learn_from_attempts
-                            // Note: fire-and-forget; madc_deliberate is handled elsewhere in the switch
-                            // (conflict marker stored above — no warm-up call needed)
-                        }
-                    }
-                }
-                // ── BUE: Second-degree propagation ────────────────────────────────────
-                // When a 'fixes' edge gets stronger, boost co-occurring second-degree edges slightly
-                if (outcome === 'success' && (domain === 'fix' || domain === 'debug')) {
-                    const fromEdgeKeys = await redis.smembers(`cachly:ckg:idx:from:${conceptId}`);
-                    for (const ek of fromEdgeKeys.slice(0, 10)) {
-                        const er = await redis.get(ek);
-                        if (!er)
-                            continue;
-                        const e2 = safeJsonParse(er, null);
-                        if (!e2)
-                            continue;
-                        if (e2.edgeType !== 'fixes')
-                            continue;
-                        // Boost second-degree: edges from e2.to get a small fractional success
-                        const secondKeys = await redis.smembers(`cachly:ckg:idx:from:${e2.to}`);
-                        for (const sk of secondKeys.slice(0, 5)) {
-                            const sr = await redis.get(sk);
-                            if (!sr)
-                                continue;
-                            const se = safeJsonParse(sr, null);
-                            if (!se)
-                                continue;
-                            if (se.edgeType !== 'co-occurs')
-                                continue;
-                            // Add 0.1 fractional success (second-degree signal)
-                            se.successes = (se.successes || 0) + 0.1;
-                            se.trials = (se.trials || 0) + 0.1;
-                            se.confidence = (se.successes + 1) / (se.trials + 2);
-                            se.last_updated = new Date().toISOString();
-                            await redis.set(sk, JSON.stringify(se));
-                        }
-                    }
-                }
-                // ── BUE: Stale edge decay ─────────────────────────────────────────────
-                // Edges older than 90 days with < 3 trials decay by 10% confidence.
-                // Only run probabilistically (1% of calls) to avoid per-call overhead.
-                if (Math.random() < 0.01) {
-                    const decayCutoff = Date.now() - 90 * 24 * 60 * 60 * 1000;
-                    const fromEdgeKeys = await redis.smembers(`cachly:ckg:idx:from:${conceptId}`);
-                    for (const ek of fromEdgeKeys) {
-                        const er = await redis.get(ek);
-                        if (!er)
-                            continue;
-                        const de = safeJsonParse(er, null);
-                        if (!de)
-                            continue;
-                        if (de.trials < 3 && de.last_updated && new Date(de.last_updated).getTime() < decayCutoff) {
-                            de.confidence = de.confidence * 0.9;
-                            de.last_updated = new Date().toISOString();
-                            await redis.set(ek, JSON.stringify(de));
-                        }
-                    }
-                }
-            }
-            catch { /* CKG updates are non-critical */ }
-            // ── Phase 3A: People + File nodes in knowledge graph ──────────────────────
-            // Builds the "who knows what" map automatically from author + file_paths.
-            // Person → authored → Concept edges power brain_who_knows queries.
-            //
-            // Seit dem 19.08.2026 steht hier autorFeld statt author: der Name wird
-            // aus git hergeleitet, wenn der Aufrufer keinen mitschickt. Vorher blieb
-            // dieser ganze Block bei zwei Fuenfteln aller Lektionen ungenutzt — und
-            // damit brain_who_knows leer.
-            if (autorFeld) {
-                // Agent activity registry (Move 4): track which agents are actively
-                // writing to this Brain, keyed by author, with a 1h TTL. Powers
-                // brain_conflicts' "who is live" view and multi-agent arbitration.
-                redis.set(`cachly:agents:active:${autorFeld}`, JSON.stringify({ author: autorFeld, last_topic: topic, last_outcome: outcome, ts: new Date().toISOString() }), 'EX', 60 * 60).catch(() => { });
-                try {
-                    const domain = topic.split(':')[0] ?? 'unknown';
-                    const personId = await ckgUpsertPersonNode(redis, nurMensch(autorFeld), domain);
-                    const conceptId = ckgSlug(topic);
-                    await ckgUpdateEdge(redis, personId, 'authored', conceptId, outcome === 'success', outcome === 'partial');
-                    for (const fp of file_paths.slice(0, 8)) {
-                        const fileId = await ckgUpsertFileNode(redis, fp);
-                        await ckgUpdateEdge(redis, personId, 'touched', fileId, true);
-                        // Phase 3: link this author to everyone else who touched the same file.
-                        await ckgRecordCollaboration(redis, fileId, personId);
-                    }
-                }
-                catch { /* non-critical */ }
-            }
-            // ── Phase 3: Service/System nodes ─────────────────────────────────────────
-            // When a lesson names the service/system it concerns (e.g. "prometheus",
-            // "cachly-web"), wire it into the graph: person→operates→service,
-            // concept→affects→service, file→runs_in→service. This is what lets
-            // brain_service_map answer "who owns X and what's gone wrong with X before".
-            if (service && typeof service === 'string' && service.trim()) {
-                try {
-                    const domain = topic.split(':')[0] ?? 'unknown';
-                    const kind = service_kind === 'system' ? 'system' : 'service';
-                    const serviceId = await ckgUpsertServiceNode(redis, service.trim(), domain, kind);
-                    const conceptId = ckgSlug(topic);
-                    // concept → affects → service (outcome decides edge confidence)
-                    await ckgUpdateEdge(redis, conceptId, 'affects', serviceId, outcome === 'success', outcome === 'partial');
-                    if (autorFeld) {
-                        const personId = `person:${ckgSlug(nurMensch(autorFeld))}`;
-                        await ckgUpdateEdge(redis, personId, 'operates', serviceId, true);
-                    }
-                    for (const fp of file_paths.slice(0, 8)) {
-                        const fileId = `file:${ckgSlug(fp)}`;
-                        await ckgUpdateEdge(redis, fileId, 'runs_in', serviceId, true);
-                    }
-                }
-                catch { /* non-critical */ }
-            }
-            // ── Ambient team propagation: if author is set + outcome is success,
-            // auto-store as a team lesson so knowledge is shared without a separate
-            // team_learn call. Tags gain 'team'; the lesson is attributed to the author.
-            // This makes team knowledge sharing the default, not the opt-in.
-            if (autorFeld && (outcome === 'success' || outcome === 'partial')) {
-                const teamLesson = {
-                    topic, outcome, what_worked,
-                    what_failed: what_failed ?? '',
-                    severity,
-                    author: autorFeld,
-                    file_paths,
-                    commands,
-                    tags: [...new Set([...tags, 'team'])],
-                    timestamp: new Date().toISOString(),
-                    recall_count: 0,
-                    version: 2,
-                    auto_propagated: true,
-                };
-                const teamListKey = `cachly:lessons:${topic}`;
-                redis.rpush(teamListKey, JSON.stringify(teamLesson)).catch(() => { });
-            }
-            const emoji = outcome === 'success' ? '✅' : outcome === 'partial' ? '⚠️' : '❌';
-            const sevEmoji = severity === 'critical' ? '🔴' : severity === 'major' ? '🟡' : '🟢';
-            const action = isUpdate ? 'updated' : 'stored';
-            return [
-                `${emoji} **Lesson ${action}:** \`${topic}\` (${outcome}) ${sevEmoji} ${severity}`,
-                beliefConflict ?? '',
-                ``,
-                `**What worked:** ${what_worked}`,
-                what_failed ? `**What failed:** ${what_failed}` : '',
-                ctx ? `**Context:** ${ctx}` : '',
-                file_paths.length > 0 ? `**Files:** ${file_paths.map(f => `\`${f}\``).join(', ')}` : '',
-                commands.length > 0 ? `**Commands:** ${commands.map(c => `\`${c}\``).join(', ')}` : '',
-                tags.length > 0 ? `**Tags:** ${tags.map(t => `#${t}`).join(' ')}` : '',
-                ``,
-                isUpdate
-                    ? `♻️ Updated (recall count: ${recallCount} · audit entries: ${auditTrail.length})`
-                    : `💡 Recall later with \`recall_best_solution(topic="${topic}")\``,
-                (autorFeld && (outcome === 'success' || outcome === 'partial'))
-                    ? `👥 Auto-shared with team (by _${autorFeld}_${herkunft.quelle !== 'uebergeben' ? ` · aus ${herkunft.quelle}` : ''}) — visible in \`team_recall\``
-                    : '',
-                autorTipp ?? '',
-                depends_on.length > 0
-                    ? `🔗 Depends on: ${depends_on.map(d => `\`${d}\``).join(', ')} → trace with \`trace_dependency\``
-                    : '',
-                ...templateWarnings,
-                ...iWasWrongWarning,
-                // GROW-044: Die 100-Zeichen-Regel wird geprueft, nicht geglaubt.
-                // Das Briefing der naechsten Sitzung zeigt je Lektion rund 100
-                // Zeichen; am 16.08.2026 stand die gesuchte Adresse an Zeichen 323,
-                // die Lektion war eingeblendet und der Fehler passierte trotzdem.
-                // Hinweis statt Ablehnung: es gibt Lektionen ohne harte Zahl, und eine
-                // abgelehnte Lektion ist immer schlechter als eine unscharfe.
-                vorspannHinweis(what_worked) ?? '',
-            ].filter(l => l !== '').join('\n');
-        }
-        case 'recall_best_solution': {
-            const { instance_id, topic } = args;
-            const redis = await getConnection(instance_id);
-            // Try exact best-solution key first
-            const best = await redis.get(`cachly:lesson:best:${topic}`);
-            if (best) {
-                const lesson = safeJsonParse(best, null);
-                if (!lesson)
-                    return `⚠️ Lesson data for \`${topic}\` is corrupted. Re-store it with \`learn_from_attempts\`.`;
-                // ── Confidence decay check ───────────────────────────────────────────
-                const confidence = calculateConfidence(lesson);
-                const ref = lesson.verified_at ?? lesson.ts;
-                const ageDays = (Date.now() - new Date(ref).getTime()) / 86400000;
-                const badge = confidenceBadge(confidence, ageDays);
-                // Recall resets verified_at (confidence clock restart) and stamps
-                // last_recalled_at so the recall-quality dashboard can measure recency.
-                const recalledAt = new Date().toISOString();
-                const updatedLesson = {
-                    ...lesson,
-                    recall_count: (lesson.recall_count ?? 0) + 1,
-                    verified_at: recalledAt,
-                    last_recalled_at: recalledAt,
-                    confidence: 1.0,
-                };
-                await redis.set(`cachly:lesson:best:${topic}`, JSON.stringify(updatedLesson));
-                // A targeted lookup is a recall too, and costs the same one quota unit
-                // as a broad smart_recall — the user asked the brain a question either way.
-                void bumpRecallQuota(redis);
-                // Track estimated time saved (30m minor · 60m major · 240m critical).
-                // Starter-Lektionen zaehlen 0 — siehe wertbeitrag.ts.
-                const savedMins = ersparteMinuten(lesson);
-                if (savedMins > 0) {
-                    redis.incrbyfloat(`cachly:stats:time_saved_mins:${instance_id}`, savedMins).catch(() => { });
-                }
-                const sevEmoji = lesson.severity === 'critical' ? '🔴' : lesson.severity === 'major' ? '🟡' : lesson.severity ? '🟢' : '';
-                const auditSummary = (lesson.audit_trail ?? []).length > 1
-                    ? `_Audit: ${(lesson.audit_trail ?? []).length} changes · stored ${new Date(lesson.ts).toLocaleDateString('de-DE')}_`
-                    : '';
-                // "Remember when..." — emotional header for lessons > 60 days old
-                const ageFromStoreDays = (Date.now() - new Date(lesson.ts).getTime()) / 86400000;
-                const rememberWhen = ageFromStoreDays > 60
-                    ? `💭 _Remember when you solved this ${Math.round(ageFromStoreDays / 30)} months ago? Still works._`
-                    : '';
-                // "Never Google This Again" — suggest pinning after 3rd recall
-                const suggestPin = updatedLesson.recall_count === 3 && !lesson.pinned
-                    ? `📌 **You've looked this up 3 times.** Consider pinning it for instant access: add \`pinned: true\` via \`learn_from_attempts\` to always surface it first.`
-                    : '';
-                // ── Trust signal (today-safe consensus layer) ───────────────────────
-                // A lesson recalled many times — or confirmed by multiple distinct
-                // authors — has proven its value. Surface that as social proof.
-                const lessonAuthors = lesson.authors
-                    ?? (lesson.author ? [lesson.author] : []);
-                const distinctAuthors = [...new Set(lessonAuthors.filter(Boolean))];
-                const rc = updatedLesson.recall_count;
-                let trustBadge = '';
-                if (distinctAuthors.length >= 2 && rc >= 5) {
-                    trustBadge = `🏆 **Battle-tested** — recalled ${rc}× · verified by ${distinctAuthors.length} developers. Trust this.`;
-                }
-                else if (rc >= 10) {
-                    trustBadge = `🏆 **Battle-tested** — recalled ${rc}×. This is one of your most-proven solutions.`;
-                }
-                else if (distinctAuthors.length >= 2) {
-                    trustBadge = `✅ **Team-verified** — confirmed by ${distinctAuthors.length} developers.`;
-                }
-                else if (rc >= 5) {
-                    trustBadge = `✅ **Proven** — recalled ${rc}× without contradiction.`;
-                }
-                return [
-                    rememberWhen,
-                    trustBadge,
-                    `${badge} **Best solution for \`${topic}\`** ${sevEmoji}${lesson.severity ? ` (${lesson.severity})` : ''} · recalled ${updatedLesson.recall_count}×`,
-                    ``,
-                    // what_worked may be empty for unresolved failure lessons (the API
-                    // accepts empty what_worked when outcome=failure) — skip the line.
-                    lesson.what_worked ? `**What worked:** ${lesson.what_worked}` : '',
-                    lesson.what_failed ? `**What failed (avoid this):** ${lesson.what_failed}` : '',
-                    lesson.context ? `**Context:** ${lesson.context}` : '',
-                    (lesson.file_paths ?? []).length > 0 ? `**Files:** ${(lesson.file_paths ?? []).map((f) => `\`${f}\``).join(', ')}` : '',
-                    (lesson.commands ?? []).length > 0 ? `**Commands:** ${(lesson.commands ?? []).map((c) => `\`${c}\``).join(', ')}` : '',
-                    (lesson.tags ?? []).length > 0 ? `**Tags:** ${(lesson.tags ?? []).map((t) => `#${t}`).join(' ')}` : '',
-                    auditSummary,
-                    suggestPin,
-                ].filter(l => l !== '').join('\n');
-            }
-            // Partial match: scan all lesson keys for topic substring
-            const allKeys = [];
-            const scanStream = redis.scanStream({ match: 'cachly:lesson:best:*', count: 100 });
-            await new Promise((resolve, reject) => {
-                scanStream.on('data', (batch) => allKeys.push(...batch));
-                scanStream.on('end', resolve);
-                scanStream.on('error', reject);
-            });
-            const matching = allKeys.filter(k => k.toLowerCase().includes(topic.toLowerCase()));
-            if (matching.length === 0) {
-                // Check attempt history as fallback
-                const histKey = `cachly:lessons:${topic}`;
-                const all = await redis.lrange(histKey, -3, -1);
-                if (all.length > 0) {
-                    const parsed = all.map(e => safeJsonParse(e, null)).filter(Boolean);
-                    const lines = parsed.map(p => `- ${p.outcome === 'success' ? '✅' : '❌'} ${p.what_worked.slice(0, 120)} (${new Date(p.ts).toLocaleDateString('de-DE')})`);
-                    return `⚠️ No successful solution for \`${topic}\` yet. Last attempts:\n\n${lines.join('\n')}`;
-                }
-                return `📭 No lessons found for \`${topic}\`. Use \`learn_from_attempts\` after solving it.`;
-            }
-            // Return all partial matches
-            const results = [];
-            for (const k of matching.slice(0, 5)) {
-                const raw = await redis.get(k);
-                if (!raw)
-                    continue;
-                const lesson = safeJsonParse(raw, null);
-                if (!lesson)
-                    continue;
-                results.push(`**\`${lesson.topic}\`** — ${lesson.what_worked.slice(0, 200)}`);
-            }
-            return `🔍 **Partial matches for \`${topic}\`:**\n\n${results.join('\n\n')}`;
-        }
-        case 'smart_recall': {
-            const { instance_id, query, threshold = 0.78, author: requester = '', context_files: rawContextFiles = [], } = args;
-            const contextFiles = Array.isArray(rawContextFiles)
-                ? rawContextFiles.filter((f) => typeof f === 'string')
-                : [];
-            const redis = await getConnection(instance_id);
-            // Team-level visibility scopes: resolve the requester's group memberships +
-            // admin status once, so group-scoped lessons only surface for members/admins.
-            let requesterScopes = new Set();
-            let requesterIsAdmin = false;
-            if (requester) {
-                requesterScopes = await getScopes(redis, instance_id, requester).catch(() => new Set());
-                const reqRole = await getRole(redis, instance_id, requester).catch(() => null);
-                requesterIsAdmin = reqRole === 'admin';
-            }
-            // ── Layer 1: Keyword search across ALL brain data (always works, no embedding) ──
-            // Wider candidate pool (25) lets the quality reranker rescue relevant lessons that
-            // BM25 alone would rank 11–25 due to vocabulary mismatch. Final slice to 5 happens below.
-            const rawMatches = await keywordSearch(redis, ['cachly:ctx:*', 'cachly:lesson:best:*', 'cachly:idx:*'], query, 25);
-            // ── Layer 1.5: Quality-aware rerank — proven success lessons outrank
-            // text-similar failed attempts (the moat; see src/rerank.ts + Cachly-Bench). ──
-            const kwMatches = rerankByQuality(rawMatches);
-            // ── Layer 1.7: Bedeutungsabgleich ──────────────────────────────────────
-            //
-            // Der Wortabgleich findet, was woertlich dasteht. Eine Frage beschreibt
-            // aber ein SYMPTOM, die Lektion eine URSACHE — "Der Deploy haengt beim
-            // Bauen" und "No space left on device" teilen kein Wort und meinen
-            // dasselbe.
-            //
-            // Gemessen am 19.08.2026 an 499 echten Lektionen mit 100 Fragen:
-            //
-            //   Verfahren      Platz 1   Top 3   Top 10
-            //   nur Woerter      21 %    33 %     47 %
-            //   nur Bedeutung    40 %    60 %     68 %
-            //   gemischt 30/70   39 %    55 %     71 %
-            //
-            // Gemischt wird, nicht ersetzt: ohne Netz gibt es keine Einbettung, und
-            // die ersten zehn Treffer sind gemischt besser als bei beiden einzeln.
-            //
-            // Faellt hier etwas aus, bleibt es beim Wortabgleich. Ein Recall, der
-            // wegen eines fremden Dienstes gar nichts liefert, waere schlimmer als
-            // einer, der schlechter sortiert.
-            //
-            // Jeder Ausstieg hier meldet sich EINMAL je Prozess (siehe
-            // `aussetzer.ts`). Am 20.08.2026 wurde gemessen, dass dieser Pfad in
-            // Produktion monatelang stumm ausstieg: 0 Vektoren bei 506 Lektionen.
-            // Von aussen war das von "alles in Ordnung" nicht zu unterscheiden.
-            let sinnAngewandt = false;
-            const kwGemischt = await (async () => {
-                if (!hasEmbedProvider()) {
-                    meldeEinmal(OHNE_DIENST, 'kein Einbettungsdienst eingerichtet — die Suche laeuft nur ueber Woerter');
-                    return kwMatches;
-                }
-                try {
-                    await vektorbestand.aktualisiere(redis);
-                    if (vektorbestand.groesse === 0) {
-                        meldeEinmal(OHNE_VEKTOREN, 'keine einzige Lektion hat eine Einbettung — die Suche laeuft nur ueber '
-                            + 'Woerter. Nachruesten mit eingaenge-nachruesten, pruefen mit brain_doctor');
-                        return kwMatches;
-                    }
-                    const frageVektor = await computeEmbedding(query);
-                    if (!frageVektor?.length) {
-                        meldeEinmal(OHNE_FRAGEVEKTOR, 'die Frage liess sich nicht einbetten — diese Suche laeuft nur ueber Woerter');
-                        return kwMatches;
-                    }
-                    await namensbestand.aktualisiere(redis);
-                    await eingangsbestand.aktualisiere(redis);
-                    await seltenheitsbestand.aktualisiere(redis);
-                    const wortThemen = kwMatches
-                        .filter((m) => m.key.startsWith('cachly:lesson:best:'))
-                        .map((m) => m.key.slice('cachly:lesson:best:'.length));
-                    // ── Die Vorauswahl ────────────────────────────────────────────────
-                    //
-                    // Woerter (Top 25) vereinigt mit Bedeutung (Top 25). Bei vorhandenen
-                    // Eingaengen zaehlt je Lektion ihr BESTER Eingang statt des
-                    // Volltextvektors — gemessen am 20.08.2026 hebt das die Findequote@3
-                    // von 52 auf 56 Prozent, und mit dem Merkmal unten auf 58.
-                    //
-                    // Der Preis steht offen im Ergebnisdokument: dieselben Eingaenge
-                    // SENKEN die Decke von 89 auf 86 Prozent. Fuer den Nutzer zaehlt die
-                    // Findequote — er sieht drei Lektionen, nicht 25.
-                    //
-                    // WICHTIG: das Maximum ueber ALLE Tueren — Volltext, Themenname UND
-                    // Fehlertext. Der erste Versuch am 20.08. hat die Volltext-Auswahl
-                    // durch die Eingangs-Auswahl ERSETZT. Das war falsch: nur 399 von 507
-                    // Lektionen tragen einen Fehlertext, die uebrigen 108 fielen damit
-                    // aus der Vorauswahl. Am echten Bestand gemessen fiel die Trefferlage
-                    // von 90 auf 70 Prozent und die Findequote@3 von 50 auf 48.
-                    const naeheBesteTuer = (t) => Math.max(vektorbestand.naehe(frageVektor, t), namensbestand.naehe(frageVektor, t), eingangsbestand.besteNaehe(frageVektor, t));
-                    const alleThemen = [...seltenheitsbestand.themen()];
-                    const sinnThemen = (alleThemen.length > 0
-                        ? alleThemen
-                        : vektorbestand.aehnlichste(frageVektor, 500).map((x) => x.topic))
-                        .map((t) => ({ t, n: naeheBesteTuer(t) }))
-                        .sort((a, b) => b.n - a.n)
-                        .slice(0, 25)
-                        .map((x) => x.t);
-                    // ── Die Sortierung ───────────────────────────────────────────────
-                    //
-                    // Bis zum 20.08.2026 stand hier `mischeRangfolgen` (Reciprocal Rank
-                    // Fusion). Das war der Grund, warum die ganze Eingangs-Arbeit im
-                    // Produkt fast nichts brachte: RRF mischt ueber PLATZIERUNGEN und
-                    // kann die Naehe zum besten Eingang nicht als abgestufte Groesse
-                    // verwerten.
-                    //
-                    //   frischer Pruefsatz, Findequote@3
-                    //     RRF, wie ausgeliefert                    50 %
-                    //     RRF + Eingaenge als dritte Quelle        51 %
-                    //     bewerteTopf                              52 %
-                    //     bewerteTopf + Eingaenge                  58 %
-                    //
-                    // Faellt ein Merkmal aus (kein Namensvektor, kein Eingang), meldet es
-                    // -2 und `spreizeImTopf` macht daraus fuer alle dieselbe Null — die
-                    // Sortierung faellt dann auf die uebrigen Merkmale zurueck, statt
-                    // falsch zu werden.
-                    const topf = [...new Set([...wortThemen, ...sinnThemen])];
-                    const besteDrei = sinnThemen.slice(0, 3)
-                        .map((t) => vektorbestand.rohvektor(t)).filter(Boolean);
-                    const angereichert = besteDrei.length ? reichereAn(frageVektor, besteDrei) : frageVektor;
-                    const frageWoerter = inhaltsWoerter(query);
-                    const statistik = seltenheitsbestand.statistik;
-                    const bewertbar = topf.map((t) => ({
-                        naeheText: vektorbestand.naehe(frageVektor, t),
-                        naeheThema: namensbestand.naehe(frageVektor, t),
-                        naeheRueckkopplung: vektorbestand.naehe(angereichert, t),
-                        seltenheitsDeckung: statistik
-                            ? statistik.deckung(frageWoerter, new Set([...inhaltsWoerter(seltenheitsbestand.textVon(t))].map(grobStamm)))
-                            : 0,
-                    }));
-                    let punkte = bewerteTopf(bewertbar, GEWICHTE);
-                    if (eingangsbestand.groesse > 0) {
-                        const naehen = topf.map((t) => eingangsbestand.besteNaehe(frageVektor, t));
-                        const gespreizt = spreizeImTopf(naehen);
-                        punkte = punkte.map((pkt, i) => pkt + EINGANG_GEWICHT * gespreizt[i]);
-                    }
-                    const reihenfolge = topf
-                        .map((t, i) => ({ t, p: punkte[i] }))
-                        .sort((a, b) => b.p - a.p)
-                        .map((x) => x.t);
-                    const bekannt = new Map(kwMatches.map((m) => [m.key, m]));
-                    // Lektionen, die NUR der Bedeutungsabgleich gefunden hat, muessen
-                    // nachgeladen werden — der Wortabgleich hat sie nie angefasst.
-                    const sortiert = [];
-                    for (const thema of reihenfolge) {
-                        const key = `cachly:lesson:best:${thema}`;
-                        const da = bekannt.get(key);
-                        if (da) {
-                            sortiert.push(da);
-                            bekannt.delete(key);
-                            continue;
-                        }
-                        const inhalt = await redis.get(key).catch(() => null);
-                        if (inhalt) {
-                            sortiert.push({ key, content: inhalt, score: 0, matchedWords: [], finalScore: 0, qualityBoost: 1 });
-                        }
-                    }
-                    // Alles, was kein Thema war (Kontexteintraege, Index), bleibt hinten
-                    // erhalten statt still zu verschwinden.
-                    sortiert.push(...bekannt.values());
-                    sinnAngewandt = true;
-                    return sortiert;
-                }
-                catch {
-                    return kwMatches;
-                }
-            })();
-            void sinnAngewandt;
-            // One quota unit for this call, regardless of how many lessons it surfaced.
-            void bumpRecallQuota(redis);
-            // ── Gedaechtniszellen ────────────────────────────────────────────────
-            //
-            // Diese Frage hat diese Lektionen gefunden — das ist ein bewiesener Weg
-            // zu ihnen. Fuehrt dieselbe Frage ein ZWEITES Mal hierher, wird sie ein
-            // eigener Eingang, und beim naechsten Mal ist der Weg breiter.
-            //
-            // Warum erst beim zweiten Mal: das Signal "wurde benutzt" gibt es nicht.
-            // Der Server sieht, was er ausgeliefert hat, nicht was jemand damit
-            // gemacht hat. Wiederholung IST das, was einen Trampelpfad ausmacht.
-            //
-            // Nur die ersten DREI: das ist, was die Einblendung zeigt. Wer alle
-            // Treffer aufzeichnet, macht aus jedem Streifschuss einen Weg.
-            //
-            // Nicht abgewartet: wer sucht, soll nicht warten, bis das Gedaechtnis
-            // nachgefuehrt ist.
-            if (hasEmbedProvider()) {
-                const gefundeneThemen = kwGemischt
-                    .filter((m) => m.key.startsWith('cachly:lesson:best:'))
-                    .slice(0, 3)
-                    .map((m) => m.key.slice('cachly:lesson:best:'.length));
-                void spurLegen(redis, query, gefundeneThemen, computeEmbedding)
-                    .catch(() => { });
-            }
-            const savedHere = [];
-            // Exclude archived lessons — they are kept for audit but must not surface in recall.
-            const lessonMatches = kwGemischt.filter(m => m.key.startsWith('cachly:lesson:best:'));
-            let crossAuthorThisCall = 0;
-            let successRecallsThisCall = 0;
-            for (const m of lessonMatches.slice(0, 5)) {
-                const existing = await redis.get(m.key).catch(() => null);
-                if (existing) {
-                    const lesson = safeJsonParse(existing, null);
-                    // Skip archived lessons — brain_hygiene moves them here; they should not resurface.
-                    if (lesson?.state === 'archived')
-                        continue;
-                    if (lesson) {
-                        const recalledAt = new Date().toISOString();
-                        const updated = { ...lesson, recall_count: (lesson.recall_count ?? 0) + 1, verified_at: recalledAt, last_recalled_at: recalledAt };
-                        redis.set(m.key, JSON.stringify(updated)).catch(() => { });
-                        // Starter-Lektionen zaehlen 0 — siehe wertbeitrag.ts.
-                        const savedMins = ersparteMinuten(lesson);
-                        if (savedMins > 0) {
-                            redis.incrbyfloat(`cachly:stats:time_saved_mins:${instance_id}`, savedMins).catch(() => { });
-                        }
-                        // Metric 3 (team-knowledge-reuse): a recall of a lesson authored by
-                        // someone OTHER than the requester is cross-author reuse — the value
-                        // only cachly delivers. Track total proven recalls + cross-author ones.
-                        redis.incr(`cachly:stats:recalls_total:${instance_id}`).catch(() => { });
-                        if (lesson.author && requester && lesson.author !== requester) {
-                            crossAuthorThisCall++;
-                            redis.incr(`cachly:stats:cross_author_recalls:${instance_id}`).catch(() => { });
-                            redis.sadd(`cachly:stats:reuse_pairs:${instance_id}`, `${requester}<-${lesson.author}`).catch(() => { });
-                            // W5: wire person↔person CKG collaborates edges from knowledge-reuse events.
-                            // This feeds brain_collab_pairs and enriches brain_who_knows with reuse-based edges.
-                            const reqPersonId = `person:${ckgSlug(requester)}`;
-                            const authPersonId = `person:${ckgSlug(lesson.author)}`;
-                            ckgUpdateEdge(redis, reqPersonId, 'collaborates', authPersonId, true).catch(() => { });
-                            ckgUpdateEdge(redis, authPersonId, 'collaborates', reqPersonId, true).catch(() => { });
-                        }
-                        if (lesson.outcome === 'success')
-                            successRecallsThisCall++;
-                        // Surface banner for proven successes (recall_count >= 1 means it's been validated).
-                        //
-                        // Der Startvorrat kommt hier NICHT ins Banner. "Brain saved you ~8h
-                        // here — docker:layer-cache" ist keine Leistung des Gedaechtnisses,
-                        // sondern mitgeliefertes Allgemeinwissen. Genau dieses Banner hat
-                        // die Zahl im Panel jahrelang glaubwuerdig aussehen lassen.
-                        if (lesson.outcome === 'success' && (lesson.recall_count ?? 0) >= 1 && !istStarterLektion(lesson)) {
-                            savedHere.push({
-                                topic: m.key.replace('cachly:lesson:best:', ''),
-                                severity: lesson.severity ?? 'major',
-                                recall_count: (lesson.recall_count ?? 0) + 1,
-                                savedMins,
-                                ts: lesson.ts,
-                                author: lesson.author,
-                            });
-                        }
-                    }
-                }
-            }
-            // Metric 1 (time-to-first-recall): stamp the first time recall returned a
-            // successful lesson. SET NX so only the first successful recall wins.
-            // Deliberately NOT gated on savedHere: savedHere requires a pre-existing
-            // recall_count >= 1, which would delay the stamp until the SECOND recall
-            // and inflate every TTFR percentile derived from it.
-            if (successRecallsThisCall > 0) {
-                redis.set(`cachly:stats:first_recall_at:${instance_id}`, new Date().toISOString(), 'EX', 365 * 86400, 'NX').catch(() => { });
-            }
-            // ── Layer 2: Semantic search (parallel, optional) ────────────────────────
-            // Semantic recall is a Premium depth layer: free tier keeps full keyword +
-            // CKG recall (the magic moment), paid tiers add embedding-based retrieval.
-            const inst = await apiFetch(`/api/v1/instances/${instance_id}`).catch(() => null);
-            const tierIsFree = !inst?.tier || inst.tier.toLowerCase() === 'free';
-            const semHits = [];
-            if (!tierIsFree && inst?.vector_token && hasEmbedProvider()) {
-                try {
-                    const embedding = await computeEmbedding(query);
-                    const vectorUrl = `https://api.cachly.dev/v1/sem/${inst.vector_token}`;
-                    const searchRes = await fetch(`${vectorUrl}/search`, {
-                        method: 'POST',
-                        headers: { 'Content-Type': 'application/json' },
-                        body: JSON.stringify({ embedding, namespace: 'cachly:ctx', threshold, top_k: 5 }),
-                        signal: AbortSignal.timeout(8000),
-                    });
-                    if (searchRes.ok) {
-                        const results = (await searchRes.json());
-                        for (const hit of results.filter(r => r.found && r.id)) {
-                            const parts = hit.id.replace('ctx:', '').split(':');
-                            const category = parts[0];
-                            const key = parts.slice(1).join(':');
-                            const redisKey = `cachly:ctx:${category}:${key}`;
-                            const content = await redis.get(redisKey).catch(() => null);
-                            semHits.push({ key: redisKey, similarity: hit.similarity ?? 0, content: content ?? '(evicted)' });
-                        }
-                    }
-                }
-                catch {
-                    // Semantic search failed silently — keyword results are enough
-                }
-            }
-            const bm25Scores = kwGemischt.map(m => m.score);
-            const bm25Min = bm25Scores.length ? Math.min(...bm25Scores) : 0;
-            const bm25Range = bm25Scores.length ? (Math.max(...bm25Scores) - bm25Min) || 1 : 1;
-            const bm25Norm = (s) => (s - bm25Min) / bm25Range;
-            const hybridMap = new Map();
-            for (const m of kwGemischt) {
-                const n = bm25Norm(m.score);
-                hybridMap.set(m.key, {
-                    key: m.key, content: m.content, bm25Score: n,
-                    hybridScore: n * (semHits.length > 0 ? 0.7 : 1.0),
-                    matchedWords: m.matchedWords, matchType: 'keyword', subQuery: m.subQuery,
-                });
-            }
-            for (const hit of semHits) {
-                const existing = hybridMap.get(hit.key);
-                if (existing) {
-                    existing.semScore = hit.similarity;
-                    existing.hybridScore = (existing.bm25Score ?? 0) * 0.6 + hit.similarity * 0.4;
-                    existing.matchType = 'hybrid';
-                }
-                else {
-                    hybridMap.set(hit.key, {
-                        key: hit.key, content: hit.content, semScore: hit.similarity,
-                        hybridScore: hit.similarity * 0.5, matchType: 'semantic',
-                    });
-                }
-            }
-            // ── Layer 3: CKG traversal — follow "fixes" edges to find lessons that solved
-            // structurally similar problems, even when vocabulary differs ───────────────
-            try {
-                const qTokens = tokenize(query).filter(t => t.length >= 4).slice(0, 4);
-                const candidateNodeIds = new Set();
-                for (const token of qTokens) {
-                    const nodeStream = redis.scanStream({ match: `cachly:ckg:node:*${token}*`, count: 20 });
-                    await new Promise((res, rej) => {
-                        nodeStream.on('data', (batch) => {
-                            for (const k of batch.slice(0, 5))
-                                candidateNodeIds.add(k.replace('cachly:ckg:node:', ''));
-                        });
-                        nodeStream.on('end', res);
-                        nodeStream.on('error', rej);
-                    });
-                }
-                const seenFroms = new Set();
-                for (const nodeId of [...candidateNodeIds].slice(0, 12)) {
-                    const inboundEdgeKeys = await redis.smembers(`cachly:ckg:idx:to:${nodeId}`);
-                    for (const ek of inboundEdgeKeys.slice(0, 6)) {
-                        const er = await redis.get(ek);
-                        if (!er)
-                            continue;
-                        const edge = safeJsonParse(er, null);
-                        if (!edge || edge.edgeType !== 'fixes' || edge.confidence < 0.35)
-                            continue;
-                        if (seenFroms.has(edge.from))
-                            continue;
-                        seenFroms.add(edge.from);
-                        const lessonKey = `cachly:lesson:best:${edge.from}`;
-                        const existing = hybridMap.get(lessonKey);
-                        if (existing) {
-                            // Already found by BM25/semantic — boost with causal confirmation
-                            existing.ckgScore = Math.max(existing.ckgScore ?? 0, edge.confidence);
-                            existing.hybridScore = existing.hybridScore * 0.88 + edge.confidence * 0.12;
-                            if (existing.matchType === 'keyword')
-                                existing.matchType = 'hybrid';
-                        }
-                        else {
-                            const content = await redis.get(lessonKey).catch(() => null);
-                            if (!content)
-                                continue;
-                            hybridMap.set(lessonKey, {
-                                key: lessonKey, content,
-                                ckgScore: edge.confidence,
-                                hybridScore: edge.confidence * 0.30, // CKG-only: lower than text hits
-                                matchType: 'ckg',
-                            });
-                        }
-                    }
-                }
-            }
-            catch { /* non-critical — keyword + semantic always available */ }
-            // ── Layer 4: File-context personalization ────────────────────────────────
-            // When the caller provides the files they are currently working on, lessons
-            // that were learned in the context of those files get a score boost. This
-            // surfaces file-specific institutional knowledge even when the query words
-            // don't mention the file name — the structural advantage of a graph brain.
-            if (contextFiles.length > 0) {
-                const ctxSet = new Set(contextFiles.map(f => f.replace(/\\/g, '/')));
-                for (const r of hybridMap.values()) {
-                    if (!r.key.startsWith('cachly:lesson:best:'))
-                        continue;
-                    const ld = safeJsonParse(r.content, {});
-                    const fps = Array.isArray(ld.file_paths)
-                        ? ld.file_paths.filter((f) => typeof f === 'string').map(f => f.replace(/\\/g, '/'))
-                        : [];
-                    if (fps.some(f => ctxSet.has(f))) {
-                        r.hybridScore *= 1.15;
-                        r.contextBoost = true;
-                    }
-                }
-            }
-            // Apply lesson quality to the NON-keyword-only paths. Keyword & hybrid
-            // entries already carry quality from the Layer-1.5 BM25 rerank
-            // (rerankByQuality above), so re-multiplying them would double-count. But a
-            // proven, senior-reviewed, high-severity success found ONLY via embeddings
-            // (matchType 'semantic') or the causal graph (matchType 'ckg') previously
-            // got zero quality lift — it ranked purely on similarity/edge-confidence.
-            // Weight just those two so a trustworthy lesson isn't buried behind a
-            // shallow-but-similar one.
-            for (const r of hybridMap.values()) {
-                if (r.matchType !== 'semantic' && r.matchType !== 'ckg')
-                    continue;
-                const lq = extractLessonQuality({ key: r.key, content: r.content });
-                if (lq)
-                    r.hybridScore *= qualityMultiplier(lq);
-            }
-            // Filter private lessons (recall_best_solution only) + enforce team scopes:
-            // group-scoped lessons surface only for members of that group (admins see all).
-            const hybridResults = [...hybridMap.values()]
-                .filter(r => {
-                if (!r.key.startsWith('cachly:lesson:best:'))
-                    return true;
-                const ld = safeJsonParse(r.content, {});
-                if (ld.visibility === 'private')
-                    return false;
-                if (!lessonVisibleToScope(ld.group, requesterScopes, requesterIsAdmin))
-                    return false;
-                return true;
-            })
-                .sort((a, b) => b.hybridScore - a.hybridScore);
-            // ── Versuch (Messtechnik, siehe versuch.ts) ───────────────────────────────
-            //
-            // Standardmaessig AUS: `versuchStart()` gibt dann `null` zurueck, und
-            // dieser ganze Block tut nichts — `hybridResults` bleibt unangetastet,
-            // nichts wird nach Redis geschrieben, kein Zeichen im Text aendert sich.
-            // Erst mit `CACHLY_VERSUCH=an` UND gesetztem Salz greift die Zuteilung.
-            const versuchSalz = versuchStart();
-            let versuchKennung = '';
-            let versuchTeil = null;
-            if (versuchSalz !== null) {
-                versuchKennung = neueKennung();
-                const hoechstePunktzahl = hybridResults[0]?.hybridScore ?? 0;
-                const ergebnis = wendeZuteilungAn(hybridResults.map((r) => ({ key: r.key, content: r.content, punktzahl: r.hybridScore })), versuchKennung, versuchSalz, hoechstePunktzahl);
-                if (ergebnis.weggelassenesThema !== undefined) {
-                    // HOLD: der bisher beste Treffer wird aus der ausgelieferten Liste
-                    // entfernt. Die uebrigen Treffer und ihre Reihenfolge bleiben gleich.
-                    hybridResults.splice(0, 1);
-                }
-                else if (ergebnis.markierungGesetzt && hybridResults[0] && ergebnis.treffer[0]) {
-                    // DELIVER: derselbe Treffer, aber sein Inhalt traegt jetzt die
-                    // Kanarien-Markierung am Ende von `what_worked`.
-                    hybridResults[0] = { ...hybridResults[0], content: ergebnis.treffer[0].content };
-                }
-                versuchTeil = {
-                    frage: query,
-                    hoechstePunktzahl,
-                    themen: [], // unten befuellt, sobald feststeht, was wirklich sichtbar ist
-                    zulassungsfaehig: ergebnis.zulassungsfaehig,
-                    zulassungsGrund: ergebnis.zulassungsGrund,
-                    zuteilung: ergebnis.zuteilung,
-                    weggelassenesThema: ergebnis.weggelassenesThema,
-                    markierungGesetzt: ergebnis.markierungGesetzt,
-                };
-            }
-            // ── Teaser-Gate: free tier over its recall limit hides the long tail ──────
-            const recallGate = await getRecallGate(instance_id, apiFetch);
-            // Depth gate: once a free user is over their (monthly, goodwill-adjusted)
-            // recall limit, the LONG TAIL is withheld — never the top hit. The rule
-            // lives in recall-tiefe.ts with tests (GROW-043), because it used to live
-            // only in a comment while the branch said `? 0 :` and returned nothing.
-            const gateActive = recallGate.reached;
-            const tiefe = recallTiefe({ ueberLimit: gateActive, gesamt: hybridResults.length, volleTiefe: TIEFE_VOLL });
-            const visibleCount = tiefe.sichtbar;
-            // ── Build output ──────────────────────────────────────────────────────────
-            const lines = [`🧠 **Smart Recall** for: _"${query}"_\n`];
-            // Warm goodwill note — shown the month a free user is gifted +250 recalls.
-            if (recallGate.goodwillMessage) {
-                lines.push(`${recallGate.goodwillMessage}\n`);
-            }
-            // "Brain saved you here" banner — surfaces value inline for proven recalled lessons
-            const SORDER = { critical: 0, major: 1, minor: 2 };
-            const topLesson = savedHere.sort((a, b) => (SORDER[a.severity] ?? 1) - (SORDER[b.severity] ?? 1))[0];
-            if (topLesson) {
-                const fmtMins = (m) => m >= 60 ? `${m / 60}h` : `${m}min`;
-                const learnedStr = (() => {
-                    if (!topLesson.ts)
-                        return null;
-                    const d = new Date(topLesson.ts);
-                    if (isNaN(d.getTime()))
-                        return null;
-                    const now = new Date();
-                    const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
-                    const sameYear = d.getFullYear() === now.getFullYear();
-                    return sameYear ? `${d.getDate()} ${months[d.getMonth()]}` : `${d.getDate()} ${months[d.getMonth()]} ${d.getFullYear()}`;
-                })();
-                const debugCostMins = topLesson.severity === 'critical' ? 120 : topLesson.severity === 'major' ? 60 : 20;
-                const authorStr = topLesson.author && topLesson.author !== requester ? ` · by @${topLesson.author}` : '';
-                const learnedPart = learnedStr ? ` · learned ${learnedStr} (was a ${fmtMins(debugCostMins)} debug)` : '';
-                lines.push(`> 💡 **Brain saved you ~${fmtMins(topLesson.savedMins)} here** — \`${topLesson.topic}\`${learnedPart} · recalled ${topLesson.recall_count}×${authorStr}\n`);
-            }
-            if (crossAuthorThisCall > 0) {
-                lines.push(`> 👥 **Team knowledge reuse** — ${crossAuthorThisCall} of these lesson${crossAuthorThisCall !== 1 ? 's were' : ' was'} written by a teammate. This is the value only a shared brain delivers.\n`);
-            }
-            // File-context personalization banner
-            const ctxBoosted = hybridResults.filter(r => r.contextBoost).length;
-            if (ctxBoosted > 0) {
-                lines.push(`> 📁 **Personalized** — ${ctxBoosted} lesson${ctxBoosted !== 1 ? 's' : ''} boosted because ${ctxBoosted !== 1 ? 'they match' : 'it matches'} your current file context (${contextFiles.slice(0, 3).join(', ')}${contextFiles.length > 3 ? ', …' : ''})\n`);
-            }
-            // Show sub-query info if multi-topic was detected
-            const subQueries = splitMultiQuery(query);
-            if (subQueries.length > 1) {
-                lines.push(`_Detected ${subQueries.length} sub-topics:_ ${subQueries.map((s, i) => `${i + 1}. "${s}"`).join(', ')}\n`);
-            }
-            if (hybridResults.length > 0) {
-                const hasCKG = hybridResults.some(r => r.ckgScore !== undefined);
-                const modeLabel = semHits.length > 0 && hasCKG
-                    ? `keyword + semantic + CKG hybrid`
-                    : semHits.length > 0
-                        ? `keyword + semantic hybrid`
-                        : hasCKG
-                            ? `keyword + CKG hybrid`
-                            : `keyword`;
-                lines.push(`### 🔍 Results (${hybridResults.length} — ${modeLabel})\n`);
-                // Group by sub-query for multi-topic queries
-                if (subQueries.length > 1) {
-                    const grouped = new Map();
-                    const tiefeMehrthemig = recallTiefe({ ueberLimit: gateActive, gesamt: hybridResults.length, volleTiefe: TIEFE_VOLL_MEHRTHEMIG });
-                    for (const r of hybridResults.slice(0, tiefeMehrthemig.sichtbar)) {
-                        const sq = r.subQuery ?? query;
-                        if (!grouped.has(sq))
-                            grouped.set(sq, []);
-                        grouped.get(sq).push(r);
-                    }
-                    for (const [sq, results] of grouped) {
-                        lines.push(`**Topic: "${sq}"** (${results.length} results)\n`);
-                        for (const r of results.slice(0, 4)) {
-                            const label = r.key.replace('cachly:ctx:', '📝 ').replace('cachly:lesson:best:', '💡 ').replace('cachly:idx:', '📂 ');
-                            const scorePart = r.matchType === 'ckg'
-                                ? `CKG: ${(r.ckgScore ?? 0).toFixed(2)}, 🕸️ causal graph`
-                                : r.ckgScore !== undefined && r.bm25Score !== undefined
-                                    ? `BM25: ${(r.bm25Score).toFixed(2)}, CKG: ${(r.ckgScore).toFixed(2)}, 🔀 hybrid`
-                                    : r.matchType === 'hybrid'
-                                        ? `BM25: ${(r.bm25Score ?? 0).toFixed(2)}, sem: ${((r.semScore ?? 0) * 100).toFixed(0)}%, 🔀 hybrid`
-                                        : r.matchType === 'semantic'
-                                            ? `sem: ${((r.semScore ?? 0) * 100).toFixed(0)}%, 🎯 semantic`
-                                            : `BM25: ${(r.bm25Score ?? 0).toFixed(2)}, matched: ${r.matchedWords?.join(', ')}`;
-                            const vorschau = recallVorschau(r.key, r.content, 300);
-                            lines.push(`  **${label}** _(${scorePart})_`);
-                            // Lesbares Brain (docs/produkt/team-puls.md P1): plain-language layer
-                            // stored at lesson:human:<topic> — display-only, ranking untouched.
-                            if (r.key.startsWith('cachly:lesson:best:')) {
-                                const hRaw = (await redis.get(r.key.replace('lesson:best:', 'lesson:human:')).catch(() => null))
-                                    ?? (await redis.get(r.key.replace('cachly:lesson:best:', 'lesson:human:')).catch(() => null));
-                                const h = hRaw ? safeJsonParse(hRaw, {}) : {};
-                                if (h.title)
-                                    lines.push(`  📖 **${h.title}** — ${h.summary ?? ''}`);
-                            }
-                            for (const z of vorschau)
-                                lines.push(`  > ${z}`);
-                            lines.push('');
-                        }
-                    }
-                    const matched = [...grouped.keys()];
-                    const unmatched = subQueries.filter(sq => !matched.includes(sq));
-                    if (unmatched.length > 0) {
-                        lines.push(`\n⚠️ **No results for:** ${unmatched.map(s => `"${s}"`).join(', ')}`);
-                    }
-                }
-                else {
-                    for (const r of hybridResults.slice(0, visibleCount)) {
-                        const label = r.key.replace('cachly:ctx:', '📝 ').replace('cachly:lesson:best:', '💡 ').replace('cachly:idx:', '📂 ');
-                        let authorBadge = '';
-                        if (r.key.startsWith('cachly:lesson:best:')) {
-                            const ld = safeJsonParse(r.content, {});
-                            if (ld.author)
-                                authorBadge = ` · 👤 ${ld.author}`;
-                        }
-                        const contextBadge = r.contextBoost ? ` · 📁 context match` : '';
-                        const scorePart = r.matchType === 'hybrid'
-                            ? `BM25: ${(r.bm25Score ?? 0).toFixed(2)}, sem: ${((r.semScore ?? 0) * 100).toFixed(0)}%, 🔀 hybrid`
-                            : r.matchType === 'semantic'
-                                ? `sem: ${((r.semScore ?? 0) * 100).toFixed(0)}%, 🎯 semantic`
-                                : `BM25: ${(r.bm25Score ?? 0).toFixed(2)}, matched: ${r.matchedWords?.join(', ')}`;
-                        const vorschau = recallVorschau(r.key, r.content, 400);
-                        lines.push(`**${label}**${authorBadge}${contextBadge} _(${scorePart})_`);
-                        // Lesbares Brain (docs/produkt/team-puls.md P1): plain-language layer.
-                        if (r.key.startsWith('cachly:lesson:best:')) {
-                            const hRaw = (await redis.get(r.key.replace('lesson:best:', 'lesson:human:')).catch(() => null))
-                                ?? (await redis.get(r.key.replace('cachly:lesson:best:', 'lesson:human:')).catch(() => null));
-                            const h = hRaw ? safeJsonParse(hRaw, {}) : {};
-                            if (h.title)
-                                lines.push(`📖 **${h.title}** — ${h.summary ?? ''}`);
-                        }
-                        for (const z of vorschau)
-                            lines.push(`> ${z}`);
-                        lines.push('');
-                    }
-                }
-                // ── Depth-gate footer: the top hit stayed, the tail is withheld ────────
-                // Only speak when something was actually held back — announcing
-                // "0 lessons withheld" would sell a wall that isn't there.
-                if (gateActive && tiefe.zurueckgehalten > 0) {
-                    const withheld = tiefe.zurueckgehalten;
-                    lines.push(`🔒 **Free recall limit reached** (${recallGate.used}/${recallGate.limit} this month). ` +
-                        `Showing your top match; ${withheld} further relevant lesson${withheld !== 1 ? 's are' : ' is'} withheld. ` +
-                        `Your limit resets next month, or unlock your full Brain now → ${UPGRADE_URL}\n`);
-                }
-            }
-            else {
-                lines.push(`⚠️ No matches found for: "${query}"`);
-                // Did-You-Mean: find nearest token in index vocab
-                const queryTokens = tokenize(query);
-                const suggestions = [];
-                if (_indexVocab.size > 0 && queryTokens.length > 0) {
-                    for (const qt of queryTokens.slice(0, 3)) {
-                        if (qt.length < 4)
-                            continue;
-                        let bestDist = 3;
-                        let bestTok = '';
-                        for (const v of _indexVocab) {
-                            if (v.length < 3 || Math.abs(v.length - qt.length) > 4)
-                                continue;
-                            const d = levenshtein(qt, v);
-                            if (d > 0 && d < bestDist) {
-                                bestDist = d;
-                                bestTok = v;
-                            }
-                        }
-                        if (bestTok)
-                            suggestions.push(`"${bestTok}" (instead of "${qt}")`);
-                    }
-                }
-                if (suggestions.length > 0) {
-                    lines.push(`💡 **Did you mean:** ${suggestions.join(', ')}?`);
-                }
-                else {
-                    lines.push(`\n💡 Tips:`);
-                    lines.push(`  • Try different keywords`);
-                    lines.push(`  • Use \`list_remembered\` to see available context`);
-                    lines.push(`  • Use \`recall_best_solution("topic")\` for exact topic lookup`);
-                }
-            }
-            // Versuch, Abschluss: Kanarienvogel gegen die WIRKLICH zusammengebaute
-            // Antwort pruefen, Markierung entfernen, Protokoll schreiben (schlaegt
-            // das fehl, bleibt die Antwort trotzdem stehen — siehe schreibeTurnProtokoll).
-            if (versuchSalz !== null && versuchTeil) {
-                const themen = hybridResults.slice(0, visibleCount)
-                    .filter((r) => r.key.startsWith('cachly:lesson:best:'))
-                    .map((r) => r.key.slice('cachly:lesson:best:'.length));
-                return schliesseVersuchAb(redis, versuchKennung, { ...versuchTeil, themen }, lines.join('\n'));
-            }
-            return lines.join('\n');
-        }
-        // ── get_api_status ────────────────────────────────────────────────────────
-        case 'session_start': {
-            const { instance_id, focus = '', author = '', provider = '', workspace_path = '' } = args;
-            const redis = await getConnection(instance_id);
-            // 1. Scan all best-solution lessons
-            const lessonKeys = [];
-            const lStream = redis.scanStream({ match: 'cachly:lesson:best:*', count: 200 });
-            await new Promise((resolve, reject) => {
-                lStream.on('data', (batch) => lessonKeys.push(...batch));
-                lStream.on('end', resolve);
-                lStream.on('error', reject);
-            });
-            const lessons = [];
-            if (lessonKeys.length > 0) {
-                const raws = await redis.mget(...lessonKeys);
-                for (const raw of raws) {
-                    const l = safeJsonParse(raw ?? null, null);
-                    if (l)
-                        lessons.push(l);
-                }
-            }
-            lessons.sort((a, b) => new Date(b.ts).getTime() - new Date(a.ts).getTime());
-            // 3. Count context entries (filter :meta keys)
-            let ctxCount = 0;
-            const ctxStream = redis.scanStream({ match: 'cachly:ctx:*', count: 200 });
-            await new Promise((resolve, reject) => {
-                ctxStream.on('data', (batch) => {
-                    ctxCount += batch.filter((k) => !k.endsWith(':meta')).length;
-                });
-                ctxStream.on('end', resolve);
-                ctxStream.on('error', reject);
-            });
-            // 4. Last session
-            const lastSessionRaw = await redis.get('cachly:session:last');
-            const lastSession = safeJsonParse(lastSessionRaw, null);
-            // 5. Focus filtering
-            const focusTerms = focus.toLowerCase().split(/\s+/).filter(Boolean);
-            const focusLessons = focusTerms.length > 0
-                ? lessons.filter(l => focusTerms.some(term => l.topic.toLowerCase().includes(term) ||
-                    (l.tags ?? []).some((t) => t.toLowerCase().includes(term))))
-                : [];
-            // 6. Streak tracking
-            let streakDays = 0;
-            let streakRecord = 0;
-            let streakMessage = '';
-            try {
-                const streakRaw = await redis.get('cachly:streak:current');
-                const streak = safeJsonParse(streakRaw, null);
-                const today = new Date().toISOString().slice(0, 10);
-                if (streak) {
-                    const lastDate = streak.last_date;
-                    const yesterday = new Date(Date.now() - 86400000).toISOString().slice(0, 10);
-                    if (lastDate === today) {
-                        // Already counted today
-                        streakDays = streak.days;
-                        streakRecord = streak.record;
-                    }
-                    else if (lastDate === yesterday) {
-                        // Continuing streak
-                        streakDays = streak.days + 1;
-                        streakRecord = Math.max(streakDays, streak.record);
-                        await redis.set('cachly:streak:current', JSON.stringify({ days: streakDays, last_date: today, record: streakRecord }));
-                    }
-                    else {
-                        // Streak broken
-                        streakDays = 1;
-                        streakRecord = streak.record;
-                        await redis.set('cachly:streak:current', JSON.stringify({ days: 1, last_date: today, record: streakRecord }));
-                    }
-                }
-                else {
-                    // First session ever
-                    streakDays = 1;
-                    streakRecord = 1;
-                    await redis.set('cachly:streak:current', JSON.stringify({ days: 1, last_date: today, record: 1 }));
-                }
-                if (streakDays >= 7)
-                    streakMessage = `🔥 **${streakDays}-day streak!** ${streakDays === streakRecord ? ' New record!' : `Best: ${streakRecord}d`}`;
-                else if (streakDays > 1)
-                    streakMessage = `🔥 ${streakDays}-day streak`;
-            }
-            catch { /* non-critical */ }
-            // 7. Save session start marker
-            await redis.set('cachly:session:current', JSON.stringify({
-                started: new Date().toISOString(),
-                focus,
-                provider,
-            }), 'EX', 86400); // auto-expire after 24h if session_end never called
-            // 8. Time saved counter
-            let timeSavedMins = 0;
-            try {
-                const raw = await redis.get(`cachly:stats:time_saved_mins:${instance_id}`);
-                timeSavedMins = parseFloat(raw ?? '0');
-            }
-            catch { /* non-critical */ }
-            // ── Build briefing ──────────────────────────────────────────────────────
-            const providerLabel = provider ? ` · ${provider}` : '';
-            const lines = [`🧠 **Session Briefing**${providerLabel}`, ''];
-            if (streakMessage)
-                lines.push(streakMessage, '');
-            // Time saved (only show when meaningful — 30+ minutes)
-            if (timeSavedMins >= 30) {
-                const h = Math.floor(timeSavedMins / 60);
-                const m = Math.round(timeSavedMins % 60);
-                const timeStr = h > 0 ? `${h}h${m > 0 ? ` ${m}m` : ''}` : `${m}m`;
-                lines.push(`⏱️ **Brain saved you ~${timeStr} total** (time not re-researching known fixes)`, '');
-            }
-            // Upgrade nudge — surfaces the free-tier quota BEFORE the wall, once
-            // per session and right next to the value it just proved.
-            const recallGate = await getRecallGate(instance_id, apiFetch);
-            const nudge = upgradeNudge({ used: recallGate.used, limit: recallGate.limit, savedMins: timeSavedMins });
-            if (nudge)
-                lines.push(nudge, '');
-            // Notice from the API — the only channel that reaches a WORKING account.
-            // Everything else we can say today requires denying the user something
-            // first (the 402 goodwill text arrived because it was an error), and most
-            // accounts have no email address on file.
-            //
-            // Once per process, so once per editor session. Repeating it would put it
-            // in front of the user on every prompt via Ambient Recall, and a line
-            // that appears every time stops being read within a day.
-            if (recallGate.notice && !_noticeGezeigt.has(instance_id)) {
-                _noticeGezeigt.add(instance_id);
-                lines.push(recallGate.notice, '');
-            }
-            // ── Welcome-back digest (gap ≥ 7 days) ──────────────────────────────────
-            // When the user has been away a week or more, lead with a short "what
-            // happened while you were gone" digest. All data is already loaded above
-            // (lastSession + lessons), so this adds zero Redis round-trips. The point
-            // is re-entry value: the brain kept compounding (git/CI/teammates) and we
-            // surface the growth before anything else competes for attention.
-            if (lastSession?.ts) {
-                const lastTs = new Date(lastSession.ts).getTime();
-                const daysAway = Math.floor((Date.now() - lastTs) / 86_400_000);
-                if (daysAway >= 7 && !Number.isNaN(lastTs)) {
-                    const newSinceAway = lessons.filter(l => {
-                        const t = new Date(l.ts).getTime();
-                        return !Number.isNaN(t) && t > lastTs;
-                    });
-                    lines.push(`👋 **Welcome back** — it's been ${daysAway} days since your last session.`);
-                    if (newSinceAway.length > 0) {
-                        // lessons is already recency-sorted desc, so take the freshest few.
-                        const topNew = newSinceAway.slice(0, 3).map(l => `\`${l.topic}\``).join(', ');
-                        lines.push(`   🌱 Your Brain grew by **${newSinceAway.length} lesson${newSinceAway.length !== 1 ? 's' : ''}** while you were gone (git, CI & teammates kept it learning): ${topNew}${newSinceAway.length > 3 ? ', …' : ''}`);
-                    }
-                    else {
-                        lines.push(`   🧠 ${lessons.length} lesson${lessons.length !== 1 ? 's' : ''} held steady and ready — recall anything with \`smart_recall\`.`);
-                    }
-                    lines.push(`   💡 Full breakdown: \`npx @cachly-dev/mcp-server@latest digest\``, '');
-                }
-            }
-            // ── What's New (shown once per version update) ──────────────────────────
-            try {
-                const seenVersion = await redis.get('cachly:mcp:version:last_seen');
-                if (seenVersion !== CURRENT_VERSION) {
-                    await redis.set('cachly:mcp:version:last_seen', CURRENT_VERSION, 'EX', 365 * 86400);
-                    const changelog = WHATS_NEW[CURRENT_VERSION];
-                    if (changelog) {
-                        lines.push(...changelog, '');
-                        // For current version, append dynamic tool count if available
-                        const toolCount = getTotalMcpTools();
-                        if (toolCount) {
-                            lines.push(`📊 ${toolCount} MCP tools`, '');
-                        }
-                    }
-                }
-            }
-            catch { /* non-critical */ }
-            // ── First-time welcome (empty brain) ───────────────────────────────────
-            const isFirstSession = !lastSession && lessons.length === 0 && ctxCount === 0;
-            if (isFirstSession) {
-                lines.push('🎉 **Welcome! Your AI Brain is live.**', '');
-                if (workspace_path) {
-                    lines.push(`🚀 **Auto-bootstrapping from your git history...** (this takes a few seconds)`);
-                    lines.push(`   Your brain will learn from your recent commits — no setup needed.`, '');
-                }
-                else {
-                    lines.push('It learns from your work automatically. After your first session it will look like this:', '');
-                    lines.push('  ✅ `api:auth` — Bearer token in header, not cookie; 401 on missing scope');
-                    lines.push('  ✅ `database:migrations` — always run migrations before deploy');
-                    lines.push('  ⚠️ `docker:build` — ARG changes bust all subsequent cache layers');
-                    lines.push('');
-                    lines.push('**Tip:** Pass `workspace_path` to `session_start` to auto-learn from git history instantly.');
-                    lines.push('');
-                }
-                lines.push('**Your brain grows automatically:**');
-                lines.push('  • End each session → `session_end(summary="What I did")` — auto-learns from git commits');
-                lines.push('  • After fixing bugs → `learn_from_attempts(topic="...", outcome="success", what_worked="...")`');
-                lines.push('');
-                lines.push('🌱 **Want answers right now?** Seed 16 universal engineering lessons so your first');
-                lines.push('   `smart_recall` returns a hit instead of nothing:');
-                lines.push(`   \`brain_seed_starter(instance_id="${instance_id}")\``);
-                lines.push('   _(Docker cache, JWT skew, K8s OOM, N+1 queries, cache stampede… — never overrides your own lessons.)_');
-                lines.push('');
-                lines.push('💡 Run `brain_doctor` for a health-check and personalised tips.');
-                lines.push('');
-            }
-            // ── Team-virality: first-team-briefing wow moment ────────────────────
-            // When a user joins a team brain (has team lessons from colleagues but
-            // has never been briefed on them), show a dedicated "Welcome to your
-            // team's brain" section. Only fires once per user.
-            if (author && !isFirstSession) {
-                try {
-                    const briefingKey = `cachly:team:first_briefing:${author}`;
-                    const alreadyBriefed = await redis.get(briefingKey);
-                    if (!alreadyBriefed) {
-                        const teamLessons = lessons.filter(l => l.author && l.author !== author);
-                        if (teamLessons.length > 0) {
-                            // Mark briefed so this only fires once
-                            await redis.set(briefingKey, '1', 'EX', 365 * 86400);
-                            const byAuthor = new Map();
-                            for (const l of teamLessons) {
-                                const a = l.author;
-                                if (!byAuthor.has(a))
-                                    byAuthor.set(a, []);
-                                byAuthor.get(a).push(l);
-                            }
-                            lines.push('');
-                            lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-                            lines.push('🤝 **Your team\'s AI brain has been briefing you.**');
-                            lines.push('');
-                            lines.push(`Your teammates have already solved problems you're about to hit:`);
-                            lines.push('');
-                            for (const [teamAuthor, tls] of byAuthor) {
-                                lines.push(`  👤 **${teamAuthor}** fixed ${tls.length} thing${tls.length > 1 ? 's' : ''}:`);
-                                for (const l of tls.slice(0, 2)) {
-                                    const emoji = l.outcome === 'success' ? '✅' : '⚠️';
-                                    lines.push(`    ${emoji} \`${l.topic}\` — ${l.what_worked.slice(0, 90)}`);
-                                }
-                                if (tls.length > 2)
-                                    lines.push(`    … and ${tls.length - 2} more lessons`);
-                            }
-                            lines.push('');
-                            lines.push(`💡 Use \`team_learn\` after your next fix to pay it forward.`);
-                            lines.push('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-                            lines.push('');
-                        }
-                    }
-                }
-                catch { /* team briefing errors must never break session_start */ }
-            }
-            // Handoff from previous window (if any)
-            const handoffRaw = await redis.get('cachly:session:handoff');
-            if (handoffRaw) {
-                try {
-                    const handoff = JSON.parse(handoffRaw);
-                    const ago = Math.round((Date.now() - new Date(handoff.ts).getTime()) / 60000);
-                    const agoStr = ago < 60 ? `${ago}m ago` : ago < 1440 ? `${Math.round(ago / 60)}h ago` : `${Math.round(ago / 1440)}d ago`;
-                    lines.push(`🤝 **Handoff from previous window** (${agoStr}):`);
-                    if (handoff.context_summary)
-                        lines.push(`   ${handoff.context_summary}`);
-                    if (handoff.remaining_tasks.length > 0) {
-                        lines.push(`   ⏳ **Remaining tasks:**`);
-                        for (const t of handoff.remaining_tasks)
-                            lines.push(`     - ${t}`);
-                    }
-                    if (handoff.completed_tasks.length > 0) {
-                        lines.push(`   ✅ **Already done:** ${handoff.completed_tasks.join(', ')}`);
-                    }
-                    const brokenFiles = (handoff.files_changed ?? []).filter(f => f.status === 'broken' || f.status === 'partial');
-                    if (brokenFiles.length > 0) {
-                        lines.push(`   ⚠️ **Needs fix:** ${brokenFiles.map(f => `\`${f.path}\` (${f.status}${f.description ? ': ' + f.description : ''})`).join(', ')}`);
-                    }
-                    if (handoff.blocked_on)
-                        lines.push(`   🚫 **Blocked on:** ${handoff.blocked_on}`);
-                    if (handoff.instructions)
-                        lines.push(`   📝 **Instructions:** ${handoff.instructions}`);
-                    lines.push('');
-                }
-                catch { /* ignore corrupt handoff */ }
-            }
-            // ── Last checkpoint (session_ping) — shown when no session_end found ────
-            const checkpointRaw = await redis.get('cachly:session:checkpoint');
-            if (checkpointRaw) {
-                try {
-                    const cp = JSON.parse(checkpointRaw);
-                    // Only show checkpoint if it's more recent than last session_end
-                    const cpTime = new Date(cp.ts).getTime();
-                    const lastSessionTime = lastSession ? new Date(lastSession.ts).getTime() : 0;
-                    if (cpTime > lastSessionTime) {
-                        const ago = Math.round((Date.now() - cpTime) / 60000);
-                        const agoStr = ago < 60 ? `${ago}m ago` : ago < 1440 ? `${Math.round(ago / 60)}h ago` : `${Math.round(ago / 1440)}d ago`;
-                        const providerStr = cp.provider ? ` [${cp.provider}]` : '';
-                        lines.push(`📌 **Last checkpoint**${providerStr} (${agoStr}): ${cp.task}`);
-                        if (cp.files_touched.length > 0) {
-                            lines.push(`   Files: ${cp.files_touched.slice(0, 5).map(f => `\`${f}\``).join(', ')}`);
-                        }
-                        if (cp.next_step)
-                            lines.push(`   📍 Next step was: ${cp.next_step}`);
-                        if (!lastSession || cpTime - lastSessionTime > 300_000) {
-                            lines.push(`   ⚠️ No \`session_end\` found — reconstructed from last checkpoint`);
-                        }
-                        lines.push('');
-                    }
-                }
-                catch { /* ignore */ }
-            }
-            // ── Git reconstruction — when no session_end + workspace_path given ─────
-            if (workspace_path && !lastSession) {
-                try {
-                    const { execSync } = await import('node:child_process');
-                    const gitLog = execSync(`git -C "${workspace_path}" log --oneline --format="%h %s" -15 2>/dev/null`, { encoding: 'utf-8', timeout: 5000 }).trim();
-                    const gitDiff = execSync(`git -C "${workspace_path}" diff --stat HEAD~3 2>/dev/null || git -C "${workspace_path}" diff --stat 2>/dev/null`, { encoding: 'utf-8', timeout: 5000 }).trim();
-                    if (gitLog) {
-                        lines.push(`🔍 **Git reconstruction** (no session_end found — reconstructed from git):`);
-                        for (const l of gitLog.split('\n').slice(0, 8))
-                            lines.push(`   ${l}`);
-                        if (gitDiff) {
-                            const diffLines = gitDiff.split('\n').filter(l => l.includes('|') || l.includes('changed'));
-                            if (diffLines.length > 0) {
-                                lines.push(`   **Recent changes:**`);
-                                for (const dl of diffLines.slice(0, 5))
-                                    lines.push(`   ${dl.trim()}`);
-                            }
-                        }
-                        lines.push('');
-                    }
-                }
-                catch { /* git not available or no repo — silent */ }
-            }
-            // Last session
-            if (lastSession) {
-                const ago = Math.round((Date.now() - new Date(lastSession.ts).getTime()) / 60000);
-                const agoStr = ago < 60 ? `${ago}m ago` : ago < 1440 ? `${Math.round(ago / 60)}h ago` : `${Math.round(ago / 1440)}d ago`;
-                lines.push(`📅 **Last session** (${agoStr}): ${lastSession.summary}`);
-                if (lastSession.duration_min)
-                    lines.push(`   Duration: ${lastSession.duration_min} min`);
-                if ((lastSession.files_changed ?? []).length > 0) {
-                    lines.push(`   Files: ${(lastSession.files_changed ?? []).slice(0, 5).map((f) => `\`${f}\``).join(', ')}`);
-                }
-                lines.push('');
-            }
-            // Brain health
-            lines.push(`📊 **Brain:** ${lessons.length} lessons · ${ctxCount} context entries`, '');
-            // ── 📌 Proven Laws — auto-crystallized lessons (quick win 3) ─────────────
-            // A lesson that has proven itself (recalled ≥ CRYSTALLIZE_RECALLS times) or
-            // was explicitly pinned becomes a "law" — surfaced at the top of every
-            // briefing so the most battle-tested knowledge is never buried. This is
-            // the today-safe version of swarm crystallization: enough confirmations
-            // auto-promote a lesson without any manual step.
-            {
-                const CRYSTALLIZE_RECALLS = 5;
-                // Der Startvorrat wird nie zum Gesetz. Eine mitgelieferte Lektion sammelt
-                // Abrufe, weil sie zu allem ein bisschen passt — nicht, weil sie sich
-                // bewaehrt hat. Gemessen am 17.08.2026: Die fuenf obersten "Gesetze"
-                // eines Brains mit 475 Lektionen waren alle aus dem Startvorrat, und die
-                // echten Lektionen standen darunter bei zwei bis fuenf Abrufen.
-                const laws = lessons
-                    .filter(l => !istStarterLektion(l))
-                    .filter(l => l.outcome === 'success' && (l.pinned === true || (l.recall_count ?? 0) >= CRYSTALLIZE_RECALLS))
-                    .sort((a, b) => (b.recall_count ?? 0) - (a.recall_count ?? 0))
-                    .slice(0, 5);
-                if (laws.length > 0) {
-                    lines.push(`📌 **Proven Laws** (auto-crystallized — your most-trusted knowledge):`);
-                    for (const l of laws) {
-                        const sev = l.severity === 'critical' ? '🔴' : l.severity === 'major' ? '🟡' : '';
-                        const rc = l.recall_count ?? 0;
-                        const why = l.pinned === true ? 'pinned' : `recalled ${rc}×`;
-                        const body = lessonPreviewLines(l);
-                        lines.push(`  🏆${sev} \`${l.topic}\` _(${why})_ — ${body[0] ?? ''}`, ...body.slice(1));
-                    }
-                    lines.push('');
-                }
-            }
-            // ── Layer 7: MCM Domain Coverage Map ────────────────────────────────────
-            if (lessons.length >= 3) {
-                const domainMap = new Map();
-                for (const l of lessons) {
-                    const dom = l.topic.split(':')[0] ?? 'other';
-                    if (!domainMap.has(dom))
-                        domainMap.set(dom, { total: 0, success: 0, critical: 0 });
-                    const d = domainMap.get(dom);
-                    d.total++;
-                    if (l.outcome === 'success')
-                        d.success++;
-                    if (l.severity === 'critical')
-                        d.critical++;
-                }
-                const sorted = [...domainMap.entries()].sort((a, b) => b[1].total - a[1].total).slice(0, 6);
-                const hasContestedDomains = sorted.some(([, d]) => d.success < d.total * 0.4 && d.total >= 2);
-                if (sorted.length > 0) {
-                    lines.push(`🗺️ **Knowledge Coverage:**`);
-                    for (const [dom, d] of sorted) {
-                        const pct = Math.round((d.success / d.total) * 100);
-                        const filled = Math.round(pct / 10);
-                        const bar = '█'.repeat(filled) + '░'.repeat(10 - filled);
-                        const flag = d.critical > 0 ? ' 🔴' : pct < 40 && d.total >= 2 ? ' ⚠️' : '';
-                        lines.push(`  ${bar} ${dom.padEnd(18)} ${String(pct).padStart(3)}% (${d.success}/${d.total} confirmed)${flag}`);
-                    }
-                    if (hasContestedDomains) {
-                        lines.push(`  ⚠️ _Some domains have contested beliefs — use \`ckg_inspect\` to review_`);
-                    }
-                    lines.push('');
-                }
-            }
-            // ── Layer 7 MCM: Active belief conflicts ─────────────────────────────────
-            try {
-                const conflictKeys = [];
-                const cfStream = redis.scanStream({ match: 'cachly:ckg:conflict:*', count: 50 });
-                await new Promise((res, rej) => { cfStream.on('data', (b) => conflictKeys.push(...b)); cfStream.on('end', res); cfStream.on('error', rej); });
-                if (conflictKeys.length > 0) {
-                    lines.push(`⚡ **Active belief conflicts (${conflictKeys.length}):**`);
-                    for (const ck of conflictKeys.slice(0, 3)) {
-                        const cr = await redis.get(ck);
-                        if (!cr)
-                            continue;
-                        const cf = safeJsonParse(cr, null);
-                        if (!cf)
-                            continue;
-                        lines.push(`  ⚠️ \`${cf.topic}\` — previously confirmed fix (${(cf.fix_confidence * 100).toFixed(0)}%, n=${cf.fix_trials}) now contradicted. Use \`ckg_inspect(concept="${ckgSlug(cf.topic)}")\``);
-                    }
-                    lines.push('');
-                }
-            }
-            catch { /* non-critical */ }
-            // ── Layer 7 MCM: Blind Spot Detection ────────────────────────────────────
-            // If the focus mentions a domain that has no CKG node → surface blind spot
-            if (focus && focus.length > 3) {
-                try {
-                    const focusTokens = focus.toLowerCase().replace(/[^a-z0-9\s:_-]/g, ' ').split(/\s+/).filter(t => t.length > 3);
-                    const blindSpots = [];
-                    for (const token of focusTokens.slice(0, 6)) {
-                        const nodeExists = await redis.exists(`cachly:ckg:node:${token}`);
-                        if (!nodeExists) {
-                            // Check if any node starts with this token (prefix match)
-                            const prefixKeys = [];
-                            const psStream = redis.scanStream({ match: `cachly:ckg:node:${token}*`, count: 10 });
-                            await new Promise((res, rej) => { psStream.on('data', (b) => prefixKeys.push(...b)); psStream.on('end', res); psStream.on('error', rej); });
-                            if (prefixKeys.length === 0)
-                                blindSpots.push(token);
-                        }
-                    }
-                    if (blindSpots.length > 0) {
-                        lines.push(`🔭 **Blind spots detected for this focus:**`);
-                        for (const bs of blindSpots.slice(0, 3)) {
-                            lines.push(`  ⬜ \`${bs}\` — no CKG knowledge. Suggestions:`);
-                            lines.push(`     • \`brain_from_git(instance_id="...", concept="${bs}")\` — bootstrap from commits`);
-                            lines.push(`     • \`fedbrain_search(query="${bs}")\` — search global commons`);
-                        }
-                        lines.push('');
-                    }
-                }
-                catch { /* non-critical */ }
-            }
-            if (focusLessons.length > 0) {
-                lines.push(`🎯 **Relevant for "${focus}":**`);
-                for (const l of focusLessons.slice(0, 4)) {
-                    const emoji = l.outcome === 'success' ? '✅' : l.outcome === 'partial' ? '⚠️' : '❌';
-                    const sev = l.severity === 'critical' ? '🔴' : l.severity === 'major' ? '🟡' : '';
-                    const body = lessonPreviewLines(l);
-                    lines.push(`  ${emoji}${sev} \`${l.topic}\` — ${body[0] ?? ''}`, ...body.slice(1));
-                }
-                lines.push('');
-            }
-            // Top lessons — sorted by recall_count desc (most-used = most proven value).
-            // If focus is set, focus-matched lessons already shown above; show remaining here.
-            if (lessons.length > 0) {
-                // Auch hier ohne Startvorrat: "Most valuable" soll zeigen, was DIESES
-                // Team gelernt hat, nicht was mitgeliefert wurde.
-                const byRecall = [...lessons].filter(l => !istStarterLektion(l))
-                    .sort((a, b) => (b.recall_count ?? 0) - (a.recall_count ?? 0));
-                const topRecalled = byRecall.filter(l => (l.recall_count ?? 0) > 0).slice(0, 3);
-                const remaining = (focusLessons.length > 0 ? lessons.filter(l => !focusLessons.includes(l)) : lessons)
-                    .filter(l => !topRecalled.includes(l))
-                    .slice(0, focusLessons.length > 0 ? 3 : 4);
-                if (topRecalled.length > 0) {
-                    lines.push(`🏆 **Most valuable** (recalled ${topRecalled[0].recall_count}× before):`);
-                    for (const l of topRecalled) {
-                        const emoji = l.outcome === 'success' ? '✅' : l.outcome === 'partial' ? '⚠️' : '❌';
-                        const sev = l.severity === 'critical' ? '🔴' : l.severity === 'major' ? '🟡' : '';
-                        const rc = l.recall_count ?? 0;
-                        const la = l.authors
-                            ?? (l.author ? [l.author] : []);
-                        const nAuthors = new Set(la.filter(Boolean)).size;
-                        const trust = (nAuthors >= 2 && rc >= 5) || rc >= 10 ? ' 🏆'
-                            : nAuthors >= 2 || rc >= 5 ? ' ✅' : '';
-                        const rct = rc > 1 ? ` _(${rc}× recalled)_` : '';
-                        const body = lessonPreviewLines(l);
-                        lines.push(`  ${emoji}${sev}${trust} \`${l.topic}\`${rct} — ${body[0] ?? ''}`, ...body.slice(1));
-                    }
-                    lines.push('');
-                }
-                if (remaining.length > 0) {
-                    const header = topRecalled.length > 0 ? `🕐 **Recent:**` : `🕐 **Recent lessons:**`;
-                    lines.push(header);
-                    for (const l of remaining) {
-                        const emoji = l.outcome === 'success' ? '✅' : l.outcome === 'partial' ? '⚠️' : '❌';
-                        const sev = l.severity === 'critical' ? '🔴' : l.severity === 'major' ? '🟡' : '';
-                        const body = lessonPreviewLines(l);
-                        lines.push(`  ${emoji}${sev} \`${l.topic}\` — ${body[0] ?? ''}`, ...body.slice(1));
-                    }
-                    lines.push('');
-                }
-            }
-            else {
-                lines.push('📭 No lessons yet. Use `learn_from_attempts` after solving tasks.', '');
-            }
-            // Team invite prompt — fires once after 10th lesson if no team use yet
-            if (lessons.length >= 10) {
-                const hasTeamUse = lessons.some(l => l.author);
-                if (!hasTeamUse) {
-                    lines.push(`🤝 **Your Brain has ${lessons.length} lessons — your team could benefit instantly.**`);
-                    lines.push(`   Share: **cachly.dev/team** · or run \`team_learn\` after the next fix.`, '');
-                }
-            }
-            // Open failures (lessons whose best-key has outcome != success)
-            const openFailures = lessons.filter(l => l.outcome === 'failure' || l.outcome === 'partial');
-            if (openFailures.length > 0) {
-                lines.push(`⚠️ **Unresolved** (${openFailures.length} topic${openFailures.length > 1 ? 's' : ''} with no success yet):`);
-                for (const l of openFailures.slice(0, 3)) {
-                    lines.push(`  ❌ \`${l.topic}\` — ${(l.what_failed ?? l.what_worked).slice(0, 80)}`);
-                }
-                lines.push('');
-            }
-            // ── Stale / low-confidence lessons (confidence decay) ─────────────────
-            const staleSuccessLessons = lessons.filter(l => {
-                if (l.outcome !== 'success' && l.outcome !== 'partial')
-                    return false;
-                return calculateConfidence(l) < CONFIDENCE_WARN_VALUE;
-            });
-            if (staleSuccessLessons.length > 0) {
-                lines.push(`🔴 **Stale lessons** (not recalled in >${CONFIDENCE_WARN_DAYS}d — verify before applying):`);
-                for (const l of staleSuccessLessons.slice(0, 4)) {
-                    const conf = calculateConfidence(l);
-                    const ageDays = Math.round((Date.now() - new Date(l.verified_at ?? l.ts).getTime()) / 86400000);
-                    const flag = conf < CONFIDENCE_STALE_VALUE ? '🔴' : '⚠️';
-                    lines.push(`  ${flag} \`${l.topic}\` — ${ageDays}d stale, ${(conf * 100).toFixed(0)}% confidence`);
-                }
-                lines.push(`  _Run \`recall_best_solution\` on these to reset their confidence clock._`);
-                lines.push('');
-            }
-            // ── Session Replay: show last session's decision log ──────────────────
-            const lastSessionAny = lastSession;
-            if (lastSessionAny?.decision_log?.length) {
-                const dl = lastSessionAny.decision_log;
-                const successes = dl.filter(d => d.outcome === 'success');
-                const failures = dl.filter(d => d.outcome === 'failure');
-                lines.push(`🎬 **Last session decisions** (${dl.length} lessons stored):`);
-                if (successes.length > 0)
-                    lines.push(`  ✅ Worked: ${successes.slice(0, 3).map(d => `\`${d.topic}\``).join(', ')}`);
-                if (failures.length > 0)
-                    lines.push(`  ❌ Failed: ${failures.slice(0, 3).map(d => `\`${d.topic}\``).join(', ')}`);
-                lines.push('');
-            }
-            // ── 🔮 Predictive Pre-Warning — intent-based danger detection ────────────
-            // Fires BEFORE work starts. Uses explicit focus when given; otherwise
-            // derives the likely work area from the last session's changed files +
-            // summary (you usually keep working where you left off). This makes the
-            // warning fire even when the caller forgets to pass `focus`.
-            {
-                // Common path noise / extensions to drop when deriving terms from files.
-                const PATH_NOISE = new Set([
-                    'src', 'lib', 'test', 'tests', 'dist', 'index', 'main', 'app',
-                    'internal', 'pkg', 'cmd', 'node_modules', 'components', 'utils',
-                    'ts', 'tsx', 'js', 'jsx', 'go', 'py', 'rs', 'java', 'json', 'yaml', 'yml',
-                ]);
-                const deriveTermsFromFiles = (files) => {
-                    const terms = new Set();
-                    for (const f of files) {
-                        for (const seg of f.toLowerCase().split(/[/\\._-]/)) {
-                            if (seg.length > 3 && !PATH_NOISE.has(seg))
-                                terms.add(seg);
-                        }
-                    }
-                    return [...terms];
-                };
-                let warnTerms = focusTerms;
-                let warnLabel = focus;
-                let derived = false;
-                if (warnTerms.length === 0 && lastSession) {
-                    const fromFiles = deriveTermsFromFiles(lastSession.files_changed ?? []);
-                    const fromSummary = (lastSession.summary ?? '').toLowerCase()
-                        .replace(/[^a-z0-9\s:_-]/g, ' ').split(/\s+/).filter(t => t.length > 3 && !PATH_NOISE.has(t));
-                    warnTerms = [...new Set([...fromFiles, ...fromSummary])];
-                    warnLabel = 'where you left off last session';
-                    derived = true;
-                }
-                if (warnTerms.length > 0) {
-                    const dangerLessons = lessons.filter(l => {
-                        if (l.outcome === 'success')
-                            return false;
-                        const topicCategory = l.topic.split(':')[0];
-                        return warnTerms.some(term => l.topic.toLowerCase().includes(term) ||
-                            topicCategory === term ||
-                            (l.tags ?? []).some((t) => t.toLowerCase() === term));
-                    });
-                    if (dangerLessons.length >= 1) {
-                        const headline = derived
-                            ? `  You're likely to continue **${warnLabel}** — ${dangerLessons.length} known pitfall${dangerLessons.length > 1 ? 's' : ''} there:`
-                            : `  Known pitfalls for **"${warnLabel}"** (${dangerLessons.length} past failure${dangerLessons.length > 1 ? 's' : ''}):`;
-                        const warning = [
-                            `🚨 **PRE-WARNING** — Read this BEFORE starting:`,
-                            headline,
-                            ...dangerLessons.slice(0, 3).map(l => `  ❌ \`${l.topic}\` — ${(l.what_failed ?? l.what_worked).slice(0, 80)}`),
-                            '',
-                        ];
-                        lines.splice(2, 0, ...warning); // after '🧠 **Session Briefing**' + empty line
-                    }
-                }
-            }
-            // ── 👥 Team Telepathy — what teammates learned this week ─────────────────
-            if (author) {
-                const oneWeekAgo = Date.now() - 7 * 86_400_000;
-                const teamLessons = lessons.filter(l => l.author && l.author !== author && new Date(l.ts).getTime() > oneWeekAgo);
-                if (teamLessons.length > 0) {
-                    // Group by author
-                    const byAuthor = new Map();
-                    for (const l of teamLessons) {
-                        const a = l.author;
-                        if (!byAuthor.has(a))
-                            byAuthor.set(a, []);
-                        byAuthor.get(a).push(l);
-                    }
-                    lines.push(`👥 **Team this week** (${teamLessons.length} lesson${teamLessons.length > 1 ? 's' : ''} from teammates):`);
-                    for (const [teamAuthor, tls] of byAuthor) {
-                        lines.push(`  👤 **${teamAuthor}**:`);
-                        for (const l of tls.slice(0, 3)) {
-                            const emoji = l.outcome === 'success' ? '✅' : l.outcome === 'partial' ? '⚠️' : '❌';
-                            lines.push(`    ${emoji} \`${l.topic}\` — ${l.what_worked.slice(0, 80)}`);
-                        }
-                        if (tls.length > 3)
-                            lines.push(`    … and ${tls.length - 3} more`);
-                    }
-                    lines.push('');
-                }
-            }
-            // ── 💎 Memory Crystal — compressed wisdom from old sessions ──────────────
-            try {
-                const crystalRaw = await redis.get('cachly:crystal:latest');
-                if (crystalRaw) {
-                    const crystal = safeJsonParse(crystalRaw, null);
-                    if (crystal) {
-                        const crystalAge = Math.round((Date.now() - new Date(crystal.ts).getTime()) / 86_400_000);
-                        if (crystalAge <= 90) {
-                            lines.push(`💎 **Memory Crystal** (${crystal.label} · ${crystal.session_count} sessions compressed):`);
-                            for (const p of crystal.top_patterns.slice(0, 3)) {
-                                lines.push(`  • **${p.category}** (${p.count}×): ${p.insight.slice(0, 90)}`);
-                            }
-                            lines.push('');
-                        }
-                    }
-                }
-            }
-            catch { /* non-critical */ }
-            // ── 🗺️ Roadmap — open items at session start ────────────────────────────
-            try {
-                const roadmapAll = await redis.hgetall(`cachly:roadmap:${instance_id}`);
-                if (roadmapAll && Object.keys(roadmapAll).length > 0) {
-                    const PRIORITY_ORDER = { critical: 0, high: 1, medium: 2, low: 3 };
-                    const PRIORITY_ICON = { critical: '🔴', high: '🟠', medium: '🟡', low: '🔵' };
-                    const openStatuses = new Set(['planned', 'in-progress', 'blocked']);
-                    const allItems = Object.values(roadmapAll).flatMap(v => {
-                        const item = safeJsonParse(v, null);
-                        return item ? [item] : [];
-                    });
-                    const openItems = allItems
-                        .filter(i => openStatuses.has(i.status))
-                        .sort((a, b) => {
-                        if (a.status === 'in-progress' && b.status !== 'in-progress')
-                            return -1;
-                        if (b.status === 'in-progress' && a.status !== 'in-progress')
-                            return 1;
-                        return (PRIORITY_ORDER[a.priority] ?? 99) - (PRIORITY_ORDER[b.priority] ?? 99);
-                    });
-                    const doneCount = allItems.filter(i => i.status === 'done').length;
-                    if (openItems.length > 0) {
-                        lines.push(`🗺️ **Roadmap** (${openItems.length} open · ${doneCount} done):`);
-                        for (const it of openItems.slice(0, 5)) {
-                            const statusIcon = it.status === 'in-progress' ? '⚡' : it.status === 'blocked' ? '🚫' : '📋';
-                            lines.push(`  ${statusIcon} ${PRIORITY_ICON[it.priority] ?? '⚪'} \`${it.id}\` **${it.title}**`);
-                        }
-                        if (openItems.length > 5)
-                            lines.push(`  … and ${openItems.length - 5} more`);
-                        lines.push(`  _Use \`roadmap_next\` for the top priority item · \`roadmap_list\` for full view_`);
-                        lines.push('');
-                    }
-                }
-            }
-            catch { /* non-critical */ }
-            // ── 🔮 PPE: Predictive Pre-fetch — CKG-powered risk detection ────────────
-            // Layer 4: Before starting any work, scan the CKG for nodes matching focus
-            // tokens and traverse causal edges to surface predicted failure points inline.
-            // This is the PPE "pre-fetch" that was previously only available via brain_predict.
-            if (focus && focus.length > 3) {
-                try {
-                    const ppeFocusTokens = focus.toLowerCase().replace(/[^a-z0-9\s\-_:]/g, ' ').split(/\s+/).filter(t => t.length > 2).slice(0, 5);
-                    const ppePredictions = [];
-                    for (const token of ppeFocusTokens) {
-                        const nodeKeys = [];
-                        const nStream = redis.scanStream({ match: `cachly:ckg:node:*${token}*`, count: 20 });
-                        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, 3)) {
-                            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, 15)) {
-                                const edgeRaw = await redis.get(ek);
-                                if (!edgeRaw)
-                                    continue;
-                                const edge = safeJsonParse(edgeRaw, null);
-                                if (!edge)
-                                    continue;
-                                if (edge.edgeType !== 'causes' && edge.edgeType !== 'co-occurs' && edge.edgeType !== 'fixes')
-                                    continue;
-                                if (edge.confidence < 0.35)
-                                    continue;
-                                const lessonKey = edge.edgeType === 'fixes' ? `cachly:lesson:best:${edge.from}` : `cachly:lesson:best:${edge.to}`;
-                                const lessonRaw = await redis.get(lessonKey);
-                                const lesson = safeJsonParse(lessonRaw, null);
-                                ppePredictions.push({ concept: node.id, edgeType: edge.edgeType, target: edge.to, confidence: edge.confidence, lesson: lesson ?? undefined });
-                            }
-                        }
-                    }
-                    const ppeSeen = new Set();
-                    const ppeUniq = ppePredictions
-                        .filter(p => { const k = `${p.concept}:${p.target}`; if (ppeSeen.has(k))
-                        return false; ppeSeen.add(k); return true; })
-                        .sort((a, b) => b.confidence - a.confidence)
-                        .slice(0, 4);
-                    if (ppeUniq.length > 0) {
-                        lines.push(`🔮 **Predicted risks for "${focus}"** (PPE pre-fetch):`);
-                        for (const p of ppeUniq) {
-                            const confPct = Math.round(p.confidence * 100);
-                            const icon = p.edgeType === 'causes' ? '⚡' : p.edgeType === 'fixes' ? '🔧' : '🔄';
-                            lines.push(`  ${icon} **${confPct}%** \`${p.concept}\` ${p.edgeType} \`${p.target}\``);
-                            if (p.lesson?.what_worked)
-                                lines.push(`     ✅ ${p.lesson.what_worked.slice(0, 110)}`);
-                        }
-                        lines.push(`  _Full analysis: \`brain_predict(context="${focus}")\`_`);
-                        lines.push('');
-                    }
-                }
-                catch { /* non-critical — never block session start */ }
-            }
-            // ── 📐 MCM Confidence Calibration — 30-day accuracy pass ─────────────────
-            // Layer 7: Periodically check if high-confidence lessons are actually reliable.
-            // If last calibration was >30 days ago (or never), run a quick pass.
-            // Measures: of recalled lessons with confidence > 0.85, what % had outcome=success?
-            try {
-                const calRaw = await redis.get('cachly:mcm:calibration:last');
-                const lastCalMs = safeJsonParse(calRaw, null)?.ts ?? 0;
-                const daysSinceCal = (Date.now() - lastCalMs) / 86_400_000;
-                if (daysSinceCal >= 30 && lessons.length >= 5) {
-                    // Quick calibration pass on recalled lessons (recall_count > 0, outcome=success)
-                    const recalledSuccess = lessons.filter(l => l.outcome === 'success' && (l.recall_count ?? 0) > 0);
-                    const recalledAll = lessons.filter(l => (l.recall_count ?? 0) > 0);
-                    if (recalledAll.length >= 3) {
-                        const precision = recalledAll.length > 0 ? recalledSuccess.length / recalledAll.length : 1;
-                        const lowPrecisionDomains = [];
-                        // Per-domain breakdown
-                        const domCalMap = new Map();
-                        for (const l of recalledAll) {
-                            const dom = l.topic.split(':')[0] ?? 'other';
-                            if (!domCalMap.has(dom))
-                                domCalMap.set(dom, { success: 0, total: 0 });
-                            const d = domCalMap.get(dom);
-                            d.total++;
-                            if (l.outcome === 'success')
-                                d.success++;
-                        }
-                        for (const [dom, d] of domCalMap) {
-                            if (d.total >= 2 && d.success / d.total < 0.6)
-                                lowPrecisionDomains.push(dom);
-                        }
-                        // Save calibration result
-                        await redis.set('cachly:mcm:calibration:last', JSON.stringify({
-                            ts: Date.now(),
-                            precision: precision,
-                            recalled: recalledAll.length,
-                            low_precision_domains: lowPrecisionDomains,
-                        }));
-                        if (lowPrecisionDomains.length > 0 || precision < 0.7) {
-                            lines.push(`📐 **MCM Calibration** (30-day pass — ${recalledAll.length} recalled lessons):`);
-                            lines.push(`  Overall precision: **${(precision * 100).toFixed(0)}%** recalled lessons actually worked`);
-                            if (lowPrecisionDomains.length > 0) {
-                                lines.push(`  ⚠️ Low-precision domains: ${lowPrecisionDomains.map(d => `\`${d}\``).join(', ')} — consider revisiting these lessons`);
-                            }
-                            lines.push(`  💡 Use \`learn_from_attempts\` to update stale lessons and improve accuracy.`);
-                            lines.push('');
-                        }
-                    }
-                    // Even if no issues, stamp the date so we don't re-check for 30d
-                    await redis.set('cachly:mcm:calibration:last', JSON.stringify({ ts: Date.now(), precision: 1, recalled: 0 }), 'EX', 35 * 86400);
-                }
-            }
-            catch { /* non-critical */ }
-            // ── 🌍 Knowledge Commons — community stats banner ───────────────────────
-            try {
-                const commonsStats = await apiFetch('/api/v1/syndication/stats');
-                if (commonsStats.total_lessons > 0) {
-                    lines.push(`🌍 **Commons:** ${commonsStats.total_lessons.toLocaleString()} lessons · ` +
-                        `${commonsStats.total_confirms.toLocaleString()} confirms · ` +
-                        `+${commonsStats.added_last_7_days} this week`);
-                    lines.push('');
-                }
-            }
-            catch { /* non-critical — never block session start */ }
-            // ── Brain Doctor hint (Punkt 6) — surface when brain needs attention ───
-            const hasOpenFailures = lessons.filter(l => l.outcome === 'failure' || l.outcome === 'partial').length > 0;
-            const hasStaleLessons = lessons.some(l => l.outcome === 'success' && calculateConfidence(l) < CONFIDENCE_WARN_VALUE);
-            if (lessons.length === 0 || hasOpenFailures || hasStaleLessons) {
-                const reasons = [];
-                if (lessons.length === 0)
-                    reasons.push('brain is empty');
-                if (hasOpenFailures)
-                    reasons.push('open failures');
-                if (hasStaleLessons)
-                    reasons.push('stale lessons');
-                lines.push(`🩺 _Run \`brain_doctor\` to fix: ${reasons.join(', ')}._`);
-            }
-            // ── Auto-Changelog — new lessons since last session ──────────────────────
-            // Appended at the end so it never competes with the core briefing.
-            // Skipped on: first session, no new lessons, or when disabled via prefs.
-            try {
-                const autoChangelogPref = await redis.get(`cachly:prefs:auto_changelog:${instance_id}`).catch(() => null);
-                const autoChangelogEnabled = autoChangelogPref !== 'false';
-                if (autoChangelogEnabled && lastSession?.ts && !isFirstSession) {
-                    const lastTs = new Date(lastSession.ts).getTime();
-                    if (!Number.isNaN(lastTs)) {
-                        const newLessons = lessons.filter(l => {
-                            const t = new Date(l.ts).getTime();
-                            return !Number.isNaN(t) && t > lastTs;
-                        });
-                        if (newLessons.length > 0) {
-                            const ago = Math.round((Date.now() - lastTs) / 60000);
-                            const agoStr = ago < 60 ? `${ago}m` : ago < 1440 ? `${Math.round(ago / 60)}h` : `${Math.round(ago / 1440)}d`;
-                            lines.push('');
-                            lines.push(`📋 **${newLessons.length} new lesson${newLessons.length !== 1 ? 's' : ''} since your last session** (${agoStr} ago):`);
-                            // Group by category
-                            const catMap = new Map();
-                            for (const l of newLessons.slice(0, 20)) {
-                                const cat = l.topic.includes(':') ? l.topic.split(':')[0] : 'general';
-                                const arr = catMap.get(cat) ?? [];
-                                arr.push(l);
-                                catMap.set(cat, arr);
-                            }
-                            for (const [cat, catLessons] of catMap) {
-                                lines.push(`  **${cat}**`);
-                                for (const l of catLessons) {
-                                    const icon = l.outcome === 'failure' ? '❌' : l.severity === 'critical' ? '🚨' : l.severity === 'major' ? '⚠️' : '✅';
-                                    const body = (l.outcome === 'failure' ? l.what_failed : l.what_worked) ?? '';
-                                    lines.push(`    ${icon} \`${l.topic}\`${body ? ` — ${body.slice(0, 80)}` : ''}`);
-                                }
-                            }
-                            if (newLessons.length > 20) {
-                                lines.push(`  … and ${newLessons.length - 20} more. Call \`brain_changelog\` for the full list.`);
-                            }
-                            lines.push(`  _Disable auto-changelog: \`brain_set_pref(instance_id="${instance_id}", key="auto_changelog", value="false")\`_`);
-                        }
-                    }
-                }
-            }
-            catch { /* changelog must never block session_start */ }
-            return lines.join('\n');
-        }
-        // ── session_start_summary ─────────────────────────────────────────────────
-        case 'session_start_summary': {
-            const { instance_id, focus, top_n: topNRaw = 10, author = '', } = args;
-            if (!focus || !focus.trim()) {
-                throw new Error('focus is required for session_start_summary');
-            }
-            const topN = Math.min(Math.max(1, Math.floor(Number(topNRaw) || 10)), 25);
-            const redis = await getConnection(instance_id);
-            // 1. Scan all best-solution lessons (same as session_start)
-            const lessonKeys = [];
-            const lStream = redis.scanStream({ match: 'cachly:lesson:best:*', count: 200 });
-            await new Promise((resolve, reject) => {
-                lStream.on('data', (batch) => lessonKeys.push(...batch));
-                lStream.on('end', resolve);
-                lStream.on('error', reject);
-            });
-            const lessons = [];
-            if (lessonKeys.length > 0) {
-                const raws = await redis.mget(...lessonKeys);
-                for (const raw of raws) {
-                    const l = safeJsonParse(raw ?? null, null);
-                    if (l)
-                        lessons.push(l);
-                }
-            }
-            // 2. If brain has 0 lessons return graceful empty message
-            if (lessons.length === 0) {
-                return [
-                    `🧠 Brain Summary — no lessons yet`,
-                    ``,
-                    `Your brain is empty. Use \`learn_from_attempts\` after solving tasks to build it up.`,
-                    `💡 Tip: \`brain_seed_starter(instance_id="${instance_id}")\` to bootstrap with 16 universal lessons.`,
-                ].join('\n');
-            }
-            // 3. If lessons.length <= top_n, return all of them (no need to score)
-            const needsRanking = lessons.length > topN;
-            // 4. Score lessons for relevance to focus
-            const focusWords = focus.toLowerCase().split(/\s+/).filter(Boolean);
-            const nowMs = Date.now();
-            const scored = lessons.map(l => {
-                // Keyword relevance: topic or tags contain focus words
-                const inTopic = focusWords.filter(w => l.topic.toLowerCase().includes(w)).length;
-                const inTags = focusWords.filter(w => (l.tags ?? []).some(t => t.toLowerCase().includes(w))).length;
-                const relevance = (inTopic * 2) + inTags;
-                // Recall-count bonus (proven-ness, log-scaled, capped)
-                const rc = Math.max(0, l.recall_count ?? 0);
-                const recallBonus = Math.min(1.5, Math.log1p(rc) / 10);
-                // Severity bonus
-                const sevBonus = l.severity === 'critical' ? 1.0 : l.severity === 'major' ? 0.5 : 0;
-                // Recency bonus: lessons updated in the last 30 days get up to +0.5
-                const ageDays = (nowMs - new Date(l.verified_at ?? l.ts).getTime()) / 86_400_000;
-                const recencyBonus = ageDays < 30 ? 0.5 * (1 - ageDays / 30) : 0;
-                // Outcome bonus: success > partial > failure
-                const outcomeBonus = l.outcome === 'success' ? 0.5 : l.outcome === 'partial' ? 0.2 : 0;
-                const score = relevance + recallBonus + sevBonus + recencyBonus + outcomeBonus;
-                return { lesson: l, score };
-            });
-            // Sort descending by score, then by recency as tiebreak
-            scored.sort((a, b) => {
-                if (b.score !== a.score)
-                    return b.score - a.score;
-                return new Date(b.lesson.ts).getTime() - new Date(a.lesson.ts).getTime();
-            });
-            const selected = (needsRanking ? scored.slice(0, topN) : scored).map(s => s.lesson);
-            const total = lessons.length;
-            const shown = selected.length;
-            // 5. Build concise briefing
-            const divider = '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━';
-            const header = needsRanking
-                ? `🧠 Brain Summary — top ${shown} of ${total} lessons for "${focus}"`
-                : `🧠 Brain Summary — all ${shown} lesson${shown !== 1 ? 's' : ''} for "${focus}"`;
-            const summaryLines = [header, divider, ''];
-            for (const l of selected) {
-                const sevIcon = l.severity === 'critical' ? '🔴' : l.severity === 'major' ? '⚠️' : '✅';
-                const sevLabel = l.severity ? `[${l.severity}] ` : '[minor] ';
-                const rc = l.recall_count ?? 0;
-                const rcStr = rc > 0 ? ` (✓ recalled ${rc}×)` : '';
-                const snippet = l.what_worked.slice(0, 110);
-                // GROW-045: `author` wurde bisher nur entgegengenommen, nie benutzt —
-                // obwohl die Werkzeug-Spezifikation "used for team lesson filtering"
-                // verspricht. Dieselbe Regel wie in smart_recall, jetzt aus EINEM Modul.
-                const autor = autorAbzeichen(l.author, author);
-                summaryLines.push(`${sevIcon} ${sevLabel}\`${l.topic}\` — ${snippet}${rcStr}${autor}`);
-            }
-            summaryLines.push('');
-            // Die Zahl, die nur ein GETEILTES Gedaechtnis liefert. Ist sie null,
-            // wird nichts gesagt: "0 von Teamkollegen" ist keine Nachricht.
-            const fremde = fremdanteil(selected, author);
-            if (fremde > 0) {
-                summaryLines.push(`👥 ${fremde} of these ${fremde === 1 ? 'was' : 'were'} written by a teammate — the value only a shared brain delivers.`, '');
-            }
-            if (needsRanking) {
-                summaryLines.push(`💡 Showing top ${shown} of ${total} lessons · \`session_start\` for full briefing`);
-            }
-            else {
-                summaryLines.push(`💡 All ${shown} lesson${shown !== 1 ? 's' : ''} shown · \`session_start\` for full briefing`);
-            }
-            return summaryLines.join('\n');
-        }
-        // ── session_end ───────────────────────────────────────────────────────────
-        case 'session_end': {
-            const { instance_id, summary, files_changed = [], lessons_learned, workspace_path = '', } = args;
-            const redis = await getConnection(instance_id);
-            const now = new Date();
-            // Calculate duration from session_start marker
-            let durationMin;
-            const currentRaw = await redis.get('cachly:session:current');
-            if (!currentRaw) {
-                return `⚠️ No active session found.\n\nRun \`session_start\` first to begin tracking a session, then call \`session_end\` when you're done.`;
-            }
-            const current = safeJsonParse(currentRaw, null);
-            if (current?.started) {
-                durationMin = Math.round((now.getTime() - new Date(current.started).getTime()) / 60000);
-            }
-            let decisionLog = [];
-            try {
-                const dlEntries = await redis.lrange('cachly:session:decision-log', 0, -1);
-                decisionLog = dlEntries.flatMap(e => {
-                    const entry = safeJsonParse(e, null);
-                    return entry ? [entry] : [];
-                });
-                await redis.del('cachly:session:decision-log');
-            }
-            catch { /* non-critical */ }
-            const sessionRecord = {
-                ts: now.toISOString(),
-                summary,
-                files_changed,
-                ...(lessons_learned !== undefined ? { lessons_learned } : {}),
-                ...(durationMin !== undefined ? { duration_min: durationMin } : {}),
-                ...(decisionLog.length > 0 ? { decision_log: decisionLog } : {}),
-            };
-            // Save as "last session"
-            await redis.set('cachly:session:last', JSON.stringify(sessionRecord));
-            // Append to history list (keep last 50 sessions, TTL 90 days)
-            await redis.lpush('cachly:session:history', JSON.stringify(sessionRecord));
-            await redis.ltrim('cachly:session:history', 0, 49);
-            await redis.expire('cachly:session:history', 90 * 86400);
-            // Clean up current session marker
-            await redis.del('cachly:session:current');
-            // ── AUTO-LEARN from session summary (no manual call needed) ─────────────
-            // Parse the summary for actionable lessons and store them automatically.
-            const autoLearned = [];
-            try {
-                // Extract key sentences from the summary that contain action verbs
-                const actionVerbs = /\b(fixed|deployed|added|removed|refactored|migrated|updated|resolved|implemented|improved|optimized|configured|created|deleted|disabled|enabled|discovered|found|learned|debugged|patched|upgraded|installed|tested|built|rewrote|moved|renamed|split|merged|extracted)\b/i;
-                const sentences = summary
-                    .split(/[.!\n]+/)
-                    .map(s => s.trim())
-                    .filter(s => s.length > 20 && actionVerbs.test(s));
-                for (const sentence of sentences.slice(0, 6)) {
-                    // Build a topic slug from the first meaningful words
-                    const words = sentence.toLowerCase()
-                        .replace(/[^a-z0-9\s]/g, ' ')
-                        .split(/\s+/)
-                        .filter(w => w.length > 3 && !['that', 'this', 'with', 'from', 'have', 'been', 'were', 'they', 'then', 'when', 'also', 'into', 'will', 'would', 'could', 'should'].includes(w));
-                    const slug = words.slice(0, 4).join('-');
-                    if (!slug)
-                        continue;
-                    const topic = `auto:${slug}`;
-                    const key = `cachly:lesson:best:${topic}`;
-                    // Don't overwrite existing successful lessons
-                    const existing = await redis.get(key);
-                    if (existing) {
-                        try {
-                            const ex = JSON.parse(existing);
-                            if (ex.outcome === 'success')
-                                continue;
-                        }
-                        catch { /* ignore */ }
-                    }
-                    const lesson = {
-                        topic,
-                        outcome: 'success',
-                        what_worked: sentence,
-                        context: `Auto-learned from session summary. Full summary: ${summary.slice(0, 300)}`,
-                        severity: 'minor',
-                        ts: now.toISOString(),
-                        recall_count: 0,
-                        auto_learned: true,
-                        session_ts: now.toISOString(),
-                        version: 2,
-                    };
-                    await redis.set(key, JSON.stringify(lesson));
-                    // 90-day TTL for auto-learned lessons
-                    await redis.expire(key, 90 * 86400);
-                    autoLearned.push(topic);
-                }
-            }
-            catch { /* auto-learn errors must never break session_end */ }
-            // ── 🌿 Ambient Git Learning ────────────────────────────────────────────────
-            // Read git commits since session start → auto-learn each meaningful commit.
-            // The commit BODY (%b) carries the reasoning — what was measured, what the
-            // cause was, what trap it avoided. The subject (%s) alone is just a heading.
-            const ambientLearned = [];
-            if (workspace_path) {
-                try {
-                    // Get the session start time (stored by session_start)
-                    const sessionStartTs = currentRaw
-                        ? (() => { try {
-                            return JSON.parse(currentRaw).started ?? '';
-                        }
-                        catch {
-                            return '';
-                        } })()
-                        : '';
-                    const sinceArg = sessionStartTs ? `--since="${sessionStartTs}"` : '--since="1 hour ago"';
-                    // '|||ENDE' terminates one commit's record. A commit body can contain
-                    // blank lines and newlines of its own, so splitting the raw output on
-                    // '\n' would tear a single multi-line body apart into several fake
-                    // "commits" — splitting on the marker keeps each body intact.
-                    const gitOut = execSync(`git -C "${workspace_path}" log ${sinceArg} --oneline --format="%H|||%s|||%b|||%ai|||ENDE"`, { timeout: 5000, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
-                    if (gitOut) {
-                        const commitActionRe = /\b(fix|add|remove|refactor|migrate|update|resolve|implement|improve|optimize|configure|create|delete|disable|enable|debug|patch|upgrade|build|rewrite|deploy|feat|chore|docs|test|perf|ci)\b/i;
-                        const commitBlocks = gitOut.split('|||ENDE').map(b => b.trim()).filter(Boolean);
-                        for (const block of commitBlocks.slice(0, 10)) {
-                            const [hash, msg, rawBody, dateStr] = block.split('|||');
-                            // Files touched together in one commit are recorded as co-occurs
-                            // edges between file nodes in the graph ("who touches A usually
-                            // touches B") — that is independent of whether the commit message
-                            // itself is lesson-worthy, so it runs for every recent commit.
-                            if (hash) {
-                                try {
-                                    // '--root' matters for a repo's very first commit: without it,
-                                    // diff-tree has no parent to compare against and silently
-                                    // reports zero changed files for that commit.
-                                    const nameOut = execSync(`git -C "${workspace_path}" diff-tree --no-commit-id --name-only -r --root "${hash}"`, { timeout: 5000, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
-                                    // Pairing is quadratic, so the cap decides the cost — and this
-                                    // runs inside session_end, which must stay quick. At 12 files
-                                    // that is 66 pairs; at 25 it would be 300, times up to ten
-                                    // commits. Each file node is upserted ONCE up front instead of
-                                    // once per pair: with 12 files that is 12 upserts rather than
-                                    // 132, and it turns ~530 round-trips into ~144.
-                                    const CO_OCCUR_MAX_FILES = 12;
-                                    const changedFiles = nameOut
-                                        ? nameOut.split('\n').map(f => f.trim()).filter(Boolean).slice(0, CO_OCCUR_MAX_FILES)
-                                        : [];
-                                    const fileIds = [];
-                                    for (const f of changedFiles)
-                                        fileIds.push(await ckgUpsertFileNode(redis, f));
-                                    for (let i = 0; i < fileIds.length; i++) {
-                                        for (let j = i + 1; j < fileIds.length; j++) {
-                                            await ckgUpdateEdge(redis, fileIds[i], 'co-occurs', fileIds[j], true);
-                                            await ckgUpdateEdge(redis, fileIds[j], 'co-occurs', fileIds[i], true);
-                                        }
-                                    }
-                                }
-                                catch { /* file co-occurrence is best-effort */ }
-                            }
-                            if (!msg || !commitActionRe.test(msg))
-                                continue;
-                            // A heading alone is not a lesson. Without a substantial body —
-                            // the why, the measurement, the trap — nothing gets stored: better
-                            // no entry than one that fills space and says nothing.
-                            const body = (rawBody ?? '').trim();
-                            if (body.length < 120)
-                                continue;
-                            const slug = msg
-                                .toLowerCase().replace(/^(fix|feat|chore|docs|test|ci|perf|refactor|build|revert)[:(\s]/i, '')
-                                .replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 40);
-                            if (!slug)
-                                continue;
-                            const topic = `git:${slug}`;
-                            const key = `cachly:lesson:best:${topic}`;
-                            const existing = await redis.get(key);
-                            if (existing)
-                                continue; // don't overwrite existing
-                            const commitLesson = {
-                                topic,
-                                outcome: 'success',
-                                what_worked: `${msg}\n\n${body.slice(0, 1200)}`,
-                                context: `Auto-learned from git commit ${(hash ?? '').slice(0, 7)} at ${dateStr ?? ''} in ${workspace_path}`,
-                                severity: 'minor',
-                                ts: now.toISOString(),
-                                recall_count: 0,
-                                auto_learned: true,
-                                source: 'ambient-git',
-                                version: 3,
-                            };
-                            await redis.set(key, JSON.stringify(commitLesson));
-                            await redis.expire(key, 60 * 86400); // 60 day TTL for git lessons
-                            ambientLearned.push(topic);
-                        }
-                    }
-                }
-                catch { /* git not available or not a repo — silent skip */ }
-            }
-            const durationStr = durationMin !== undefined ? ` · ${durationMin} min` : '';
-            const totalAutoLearned = autoLearned.length + ambientLearned.length;
-            // ── Shareable Session Summary Card ────────────────────────────────────────
-            // Generated after each session so the user can share their progress.
-            const tweetLines = [];
-            if (durationMin !== undefined && durationMin > 0)
-                tweetLines.push(`⏱ ${durationMin} min session`);
-            if (totalAutoLearned > 0)
-                tweetLines.push(`🧠 ${totalAutoLearned} lessons saved to Brain`);
-            if (files_changed.length > 0)
-                tweetLines.push(`📁 ${files_changed.length} file${files_changed.length > 1 ? 's' : ''} changed`);
-            const tweetBody = tweetLines.length > 0
-                ? `${tweetLines.join(' · ')}\n\nMy AI Brain remembers this so I never repeat it. @cachlydev\ncachly.dev`
-                : `Session saved to my AI Brain. No more re-explaining this tomorrow. @cachlydev\ncachly.dev`;
-            const tweetURL = `https://twitter.com/intent/tweet?text=${encodeURIComponent(tweetBody)}`;
-            const sessionCard = [
-                ``,
-                `┌─────────────────────────────────────────────┐`,
-                `│  🧠 Session Summary Card                    │`,
-                `│  Share your progress — cached forever       │`,
-                `├─────────────────────────────────────────────┤`,
-                durationMin !== undefined ? `│  ⏱  Duration   : ${String(durationMin + ' min').padEnd(26)}│` : '',
-                totalAutoLearned > 0 ? `│  📚 Learned    : ${String(totalAutoLearned + ' lessons').padEnd(26)}│` : '',
-                files_changed.length > 0 ? `│  📁 Changed    : ${String(files_changed.length + ' file' + (files_changed.length > 1 ? 's' : '')).padEnd(26)}│` : '',
-                `├─────────────────────────────────────────────┤`,
-                `│  📣 Share: ${tweetURL.slice(0, 34).padEnd(34)}│`,
-                `└─────────────────────────────────────────────┘`,
-            ].filter(l => l !== '').join('\n');
-            return [
-                `✅ **Session saved**${durationStr}`,
-                ``,
-                `📋 **Summary:** ${summary}`,
-                files_changed.length > 0 ? `📁 **Files changed:** ${files_changed.map(f => `\`${f}\``).join(', ')}` : '',
-                lessons_learned !== undefined ? `🧠 **Lessons stored:** ${lessons_learned}` : '',
-                autoLearned.length > 0 ? `🤖 **Auto-learned:** ${autoLearned.length} lessons extracted from summary (${autoLearned.slice(0, 3).map(t => `\`${t}\``).join(', ')}${autoLearned.length > 3 ? '…' : ''})` : '',
-                ambientLearned.length > 0 ? `🌿 **Ambient git learning:** ${ambientLearned.length} commit${ambientLearned.length > 1 ? 's' : ''} auto-learned (${ambientLearned.slice(0, 3).map(t => `\`${t}\``).join(', ')}${ambientLearned.length > 3 ? '…' : ''})` : '',
-                sessionCard,
-                ``,
-                `💡 Next session: \`session_start(focus="...")\` to see this summary.`,
-            ].filter(l => l !== '').join('\n');
-        }
-        // ── session_ping — lightweight checkpoint ─────────────────────────────────
-        case 'session_ping': {
-            const { instance_id, task, files_touched = [], next_step = '', provider = '', } = args;
-            const redis = await getConnection(instance_id);
-            const checkpoint = {
-                ts: new Date().toISOString(),
-                task,
-                files_touched,
-                next_step,
-                provider,
-            };
-            // Store as the latest checkpoint — session_start reads this when no session_end found
-            await redis.set('cachly:session:checkpoint', JSON.stringify(checkpoint), 'EX', 86400 * 3); // 3-day TTL
-            // Also keep a short rolling log (last 20 checkpoints for history)
-            await redis.lpush('cachly:session:checkpoint:log', JSON.stringify(checkpoint));
-            await redis.ltrim('cachly:session:checkpoint:log', 0, 19);
-            const providerStr = provider ? ` [${provider}]` : '';
-            const filesStr = files_touched.length > 0 ? ` · ${files_touched.length} file${files_touched.length > 1 ? 's' : ''} touched` : '';
-            const nextStr = next_step ? `\n📍 **Next step:** ${next_step}` : '';
-            return [
-                `📌 **Checkpoint saved**${providerStr} — ${new Date().toLocaleTimeString()}`,
-                `🔨 **Working on:** ${task}${filesStr}`,
-                nextStr,
-                ``,
-                `💡 If you switch providers, \`session_start\` will show this checkpoint automatically.`,
-            ].filter(l => l !== '').join('\n');
-        }
-        // ── session_handoff — cross-window continuity ─────────────────────────────
-        case 'session_handoff': {
-            const { instance_id, completed_tasks = [], remaining_tasks = [], files_changed = [], instructions = '', context_summary = '', blocked_on = '', } = args;
-            const redis = await getConnection(instance_id);
-            const now = new Date();
-            const handoff = {
-                ts: now.toISOString(),
-                completed_tasks,
-                remaining_tasks,
-                files_changed,
-                instructions,
-                context_summary,
-                blocked_on,
-            };
-            // Store handoff — never expires until next handoff overwrites it
-            await redis.set('cachly:session:handoff', JSON.stringify(handoff));
-            // Also append to history
-            await redis.lpush('cachly:session:handoff:history', JSON.stringify(handoff));
-            await redis.ltrim('cachly:session:handoff:history', 0, 19);
-            const totalTasks = completed_tasks.length + remaining_tasks.length;
-            const pct = totalTasks > 0 ? Math.round((completed_tasks.length / totalTasks) * 100) : 0;
-            const brokenFiles = files_changed.filter(f => f.status === 'broken' || f.status === 'partial');
-            return [
-                `🤝 **Handoff saved** — ${completed_tasks.length}/${totalTasks} tasks done (${pct}%)`,
-                ``,
-                completed_tasks.length > 0 ? `✅ **Completed:**\n${completed_tasks.map(t => `  - ${t}`).join('\n')}` : '',
-                remaining_tasks.length > 0 ? `\n⏳ **Remaining for next window:**\n${remaining_tasks.map(t => `  - ${t}`).join('\n')}` : '',
-                brokenFiles.length > 0 ? `\n⚠️ **Needs attention:** ${brokenFiles.map(f => `\`${f.path}\` (${f.status})`).join(', ')}` : '',
-                blocked_on ? `\n🚫 **Blocked on:** ${blocked_on}` : '',
-                instructions ? `\n📝 **Instructions:** ${instructions}` : '',
-                ``,
-                `💡 The next \`session_start\` will include this handoff automatically.`,
-            ].filter(l => l !== '').join('\n');
-        }
-        // ── auto_learn_session ────────────────────────────────────────────────────
-        case 'auto_learn_session': {
-            const { instance_id, observations } = args;
-            const redis = await getConnection(instance_id);
-            const stored = [];
-            const skipped = [];
-            for (const obs of observations) {
-                // Auto-generate topic from action if not provided
-                const rawTopic = obs.topic ?? obs.action
-                    .toLowerCase()
-                    .replace(/[^a-z0-9:\-_\s]/g, '')
-                    .trim()
-                    .split(/\s+/)
-                    .slice(0, 4)
-                    .join('-');
-                const topic = rawTopic.includes(':') ? rawTopic : `auto:${rawTopic}`;
-                const key = `cachly:lesson:best:${topic}`;
-                // Only overwrite if this is a success and existing is failure, or topic is new
-                const existing = await redis.get(key);
-                if (existing) {
-                    const existingLesson = JSON.parse(existing);
-                    if (existingLesson.outcome === 'success' && obs.outcome !== 'success') {
-                        skipped.push(topic);
-                        continue;
-                    }
-                }
-                const lesson = {
-                    topic,
-                    outcome: obs.outcome,
-                    what_worked: obs.outcome === 'success' ? obs.action : (obs.details ?? obs.action),
-                    what_failed: obs.outcome === 'failure' ? obs.action : undefined,
-                    context: obs.details,
-                    severity: obs.severity ?? 'minor',
-                    ts: new Date().toISOString(),
-                    // Give auto-learned lessons the same baseline confidence field the
-                    // quality rerank / decay logic expect, so they are ranked like any
-                    // other lesson instead of being treated as signal-less.
-                    confidence: 1.0,
-                    recall_count: 0,
-                    auto_learned: true,
-                    version: 2,
-                };
-                const lessonStr = JSON.stringify(lesson);
-                await redis.set(key, lessonStr);
-                // Make auto-learned lessons FIRST-CLASS, not just a bare best-key pointer:
-                // append to the topic history (audit + consolidation source) and register
-                // the concept in the Causal Knowledge Graph so causal_trace / brain_predict
-                // / memory_consolidate can see them. Mirrors the learn_from_attempts path;
-                // best-effort so a graph hiccup never fails the learn.
-                const listKey = `cachly:lessons:${topic}`;
-                await redis.rpush(listKey, lessonStr);
-                await redis.ltrim(listKey, -100, -1);
-                await redis.expire(listKey, 90 * 86400);
-                try {
-                    const domain = topic.split(':')[0] ?? 'auto';
-                    const conceptId = ckgSlug(topic);
-                    await ckgUpsertNode(redis, conceptId, domain, domain);
-                    // A successful action that resolved a described problem becomes
-                    // causal-traceable via a `fixes` edge.
-                    if (obs.outcome === 'success' || obs.outcome === 'partial') {
-                        const problemConcept = obs.details ? extractProblemConcept(obs.details) : null;
-                        if (problemConcept) {
-                            const problemId = ckgSlug(`problem:${problemConcept}`);
-                            await ckgUpsertNode(redis, problemId, 'problem', 'problem');
-                            await ckgUpdateEdge(redis, conceptId, 'fixes', problemId, obs.outcome === 'success', obs.outcome === 'partial');
-                        }
-                    }
-                }
-                catch { /* CKG is best-effort */ }
-                stored.push(`${obs.outcome === 'success' ? '✅' : obs.outcome === 'partial' ? '⚠️' : '❌'} \`${topic}\``);
-            }
-            const lines = [
-                `🤖 **Auto-learn complete**: ${stored.length} stored, ${skipped.length} skipped`,
-                '',
-            ];
-            if (stored.length > 0)
-                lines.push('**Stored:**', ...stored.map(s => '  ' + s), '');
-            if (skipped.length > 0)
-                lines.push(`**Skipped** (better lesson already exists): ${skipped.map(t => `\`${t}\``).join(', ')}`);
-            return lines.join('\n');
-        }
-        // ── brain_who_knows ───────────────────────────────────────────────────────
-        // Phase 3A: Org-wide people intelligence. Returns ranked list of contributors
-        // whose authored edges in the CKG match the query topic.
-        case 'brain_who_knows': {
-            const { instance_id, topic, limit = 10, } = args;
-            if (!topic || typeof topic !== 'string' || !topic.trim()) {
-                return '⚠️ `brain_who_knows` requires a non-empty `topic`. Example: `brain_who_knows(topic="kubernetes deployment")`.';
-            }
-            const safeLimit = Math.max(1, Math.min(Number(limit) || 10, 50));
-            const redis = await getConnection(instance_id);
-            // Step 1: Find candidate concept node IDs matching the query
-            const querySlug = ckgSlug(topic);
-            const qTokens = tokenize(topic).filter((t) => t.length >= 3).slice(0, 5);
-            const candidateConceptIds = new Set([querySlug]);
-            for (const token of qTokens.slice(0, 3)) {
-                const nodeStream = redis.scanStream({ match: `cachly:ckg:node:*${token}*`, count: 30 });
-                await new Promise((res, rej) => {
-                    nodeStream.on('data', (batch) => {
-                        for (const k of batch.slice(0, 10)) {
-                            const nodeId = k.replace('cachly:ckg:node:', '');
-                            if (!nodeId.startsWith('person:') && !nodeId.startsWith('file:'))
-                                candidateConceptIds.add(nodeId);
-                        }
-                    });
-                    nodeStream.on('end', res);
-                    nodeStream.on('error', rej);
-                });
-            }
-            const personScores = new Map();
-            for (const conceptId of [...candidateConceptIds].slice(0, 25)) {
-                const inboundEdgeKeys = await redis.smembers(`cachly:ckg:idx:to:${conceptId}`);
-                for (const ek of inboundEdgeKeys) {
-                    const er = await redis.get(ek);
-                    if (!er)
-                        continue;
-                    const edge = safeJsonParse(er, null);
-                    if (!edge || edge.edgeType !== 'authored')
-                        continue;
-                    const personNodeRaw = await redis.get(`cachly:ckg:node:${edge.from}`);
-                    if (!personNodeRaw)
-                        continue;
-                    const personNode = safeJsonParse(personNodeRaw, null);
-                    if (!personNode || personNode.type !== 'person')
-                        continue;
-                    const existing = personScores.get(edge.from);
-                    if (existing) {
-                        existing.lessonCount++;
-                        existing.totalConfidence += edge.confidence;
-                        existing.domains.add(personNode.domain);
-                        if (edge.last_updated > existing.lastActive)
-                            existing.lastActive = edge.last_updated;
-                    }
-                    else {
-                        personScores.set(edge.from, {
-                            handle: personNode.handle,
-                            lessonCount: 1,
-                            totalConfidence: edge.confidence,
-                            domains: new Set([personNode.domain]),
-                            lastActive: personNode.last_active ?? edge.last_updated,
-                        });
-                    }
-                }
-            }
-            if (personScores.size === 0) {
-                return [
-                    `## 👥 Who Knows About \`${topic}\`?`,
-                    ``,
-                    `No attributed lessons found yet.`,
-                    ``,
-                    `Knowledge attribution builds automatically — add \`author="name"\` to \`learn_from_attempts\` calls:`,
-                    `\`learn_from_attempts(topic="${topic}", author="your-handle", ...)\``,
-                ].join('\n');
-            }
-            // Step 3: Sort by expertise score (lesson count × avg confidence)
-            const ranked = [...personScores.entries()]
-                .map(([id, s]) => ({
-                id,
-                handle: s.handle,
-                lessonCount: s.lessonCount,
-                avgConfidence: s.totalConfidence / s.lessonCount,
-                domains: [...s.domains].slice(0, 3).join(', '),
-                lastActive: s.lastActive,
-            }))
-                .sort((a, b) => (b.lessonCount * b.avgConfidence) - (a.lessonCount * a.avgConfidence))
-                .slice(0, safeLimit);
-            // Step 4: For the top expert, find frequent collaborators (person↔person edges).
-            const topCollaborators = [];
-            const topExpert = ranked[0];
-            if (topExpert) {
-                try {
-                    const edgeKeys = await redis.smembers(`cachly:ckg:idx:from:${topExpert.id}`);
-                    const collabs = [];
-                    for (const ek of edgeKeys) {
-                        const er = await redis.get(ek);
-                        if (!er)
-                            continue;
-                        const edge = safeJsonParse(er, null);
-                        if (!edge || edge.edgeType !== 'collaborates')
-                            continue;
-                        const pr = await redis.get(`cachly:ckg:node:${edge.to}`);
-                        const pn = pr ? safeJsonParse(pr, null) : null;
-                        if (pn?.handle)
-                            collabs.push({ handle: pn.handle, trials: edge.trials });
-                    }
-                    collabs.sort((a, b) => b.trials - a.trials);
-                    for (const c of collabs.slice(0, 3))
-                        topCollaborators.push(c.handle);
-                }
-                catch { /* non-critical */ }
-            }
-            const lines = [
-                `## 👥 Who Knows About \`${topic}\`?`,
-                ``,
-                `**${ranked.length}** contributor${ranked.length !== 1 ? 's' : ''} with relevant lessons:`,
-                ``,
-            ];
-            for (const [i, p] of ranked.entries()) {
-                const medal = i === 0 ? '🥇' : i === 1 ? '🥈' : i === 2 ? '🥉' : `${i + 1}.`;
-                const conf = (p.avgConfidence * 100).toFixed(0);
-                const daysSince = Math.floor((Date.now() - new Date(p.lastActive).getTime()) / 86400000);
-                const recency = daysSince < 1 ? 'today' : daysSince < 7 ? `${daysSince}d ago` : daysSince < 30 ? `${Math.floor(daysSince / 7)}w ago` : `${Math.floor(daysSince / 30)}mo ago`;
-                // Show role badge if assigned (non-blocking — role lookup is best-effort)
-                const roleVal = await getRole(redis, instance_id, p.handle).catch(() => null);
-                const roleBadge = roleVal ? ` ${ROLE_BADGE[roleVal]}` : '';
-                lines.push(`${medal} **${p.handle}**${roleBadge} — ${p.lessonCount} lesson${p.lessonCount !== 1 ? 's' : ''} · ${conf}% confidence · last active ${recency}`, `   _domains: ${p.domains}_`, ``);
-            }
-            if (topCollaborators.length > 0 && topExpert) {
-                lines.push(`🤝 **${topExpert.handle}** frequently works with: ${topCollaborators.map(h => `**${h}**`).join(', ')}`, `   _(ask them together — they've solved structurally similar things on shared files)_`, ``);
-            }
-            lines.push(`---`, `_Attribution grows with every \`learn_from_attempts(author="...", ...)\` call._`);
-            return lines.join('\n');
-        }
-        // ── brain_file_map ────────────────────────────────────────────────────────
-        // Phase 3B: "What do we know about these files?" — experts + lessons per file.
-        case 'brain_file_map': {
-            const { instance_id, file_paths = [], } = args;
-            // Defensive: accept only a non-empty array of non-empty strings.
-            const cleanPaths = (Array.isArray(file_paths) ? file_paths : [])
-                .filter((p) => typeof p === 'string' && p.trim().length > 0)
-                .map(p => p.trim());
-            if (!cleanPaths.length)
-                return '⚠️ Pass at least one file path. Example: `brain_file_map(file_paths=["src/auth/jwt.ts"])`.';
-            const redis = await getConnection(instance_id);
-            const lines = [
-                `## 📁 File Knowledge Map`,
-                ``,
-                `_What cachly knows about the files you're about to touch:_`,
-                ``,
-            ];
-            for (const fp of cleanPaths.slice(0, 10)) {
-                lines.push(`### \`${fp}\``);
-                // ── Experts via CKG file nodes ─────────────────────────────────────
-                const fileId = `file:${ckgSlug(fp)}`;
-                const inbound = await redis.smembers(`cachly:ckg:idx:to:${fileId}`);
-                const experts = [];
-                for (const ek of inbound) {
-                    const er = await redis.get(ek);
-                    if (!er)
-                        continue;
-                    const edge = safeJsonParse(er, null);
-                    if (!edge || edge.edgeType !== 'touched')
-                        continue;
-                    const personRaw = await redis.get(`cachly:ckg:node:${edge.from}`);
-                    if (!personRaw)
-                        continue;
-                    const pn = safeJsonParse(personRaw, null);
-                    if (!pn || pn.type !== 'person')
-                        continue;
-                    experts.push({ handle: pn.handle, touches: edge.trials, lastSeen: edge.last_updated });
-                }
-                experts.sort((a, b) => b.touches - a.touches);
-                if (experts.length > 0) {
-                    const expLine = experts.slice(0, 5).map((e, i) => {
-                        const medal = i === 0 ? '🥇' : i === 1 ? '🥈' : i === 2 ? '🥉' : `${i + 1}.`;
-                        const days = Math.floor((Date.now() - new Date(e.lastSeen).getTime()) / 86400000);
-                        const ago = days < 1 ? 'today' : days < 7 ? `${days}d ago` : `${Math.floor(days / 7)}w ago`;
-                        return `${medal} **${e.handle}** (${e.touches}× · ${ago})`;
-                    }).join(' · ');
-                    lines.push(`**Experts:** ${expLine}`);
-                }
-                else {
-                    lines.push(`**Experts:** _None yet — add \`author\` to \`learn_from_attempts\` calls_`);
-                }
-                // ── Related lessons via BM25 on filename tokens ────────────────────
-                const tokens = fp.replace(/[^a-z0-9]/gi, ' ').split(/\s+/).filter(t => t.length >= 4);
-                const lessonQuery = tokens.slice(0, 3).join(' ');
-                const relatedLessons = [];
-                if (lessonQuery) {
-                    try {
-                        const hits = await keywordSearch(redis, ['cachly:lesson:best:*'], lessonQuery, 4);
-                        for (const h of hits) {
-                            const ld = safeJsonParse(h.content, {});
-                            if (ld.visibility === 'private')
-                                continue;
-                            const emoji = ld.outcome === 'success' ? '✅' : ld.outcome === 'partial' ? '⚠️' : '❌';
-                            const sev = ld.severity === 'critical' ? ' 🔴' : ld.severity === 'major' ? ' 🟡' : '';
-                            const by = ld.author ? ` · 👤 ${ld.author}` : '';
-                            const topic = h.key.replace('cachly:lesson:best:', '');
-                            relatedLessons.push(`  - ${emoji} \`${topic}\`${sev}${by} — ${(ld.what_worked ?? '').slice(0, 100)}`);
-                        }
-                    }
-                    catch { /* non-critical */ }
-                }
-                // Also: exact file_paths match via lesson scan
-                if (relatedLessons.length < 2) {
-                    const allLessonKeys = await scanKeys(redis, 'cachly:lesson:best:*', { max: 1500 });
-                    for (const k of allLessonKeys.slice(0, 300)) {
-                        const raw = await redis.get(k);
-                        if (!raw)
-                            continue;
-                        const ld = safeJsonParse(raw, {});
-                        if (ld.visibility === 'private')
-                            continue;
-                        if (!(ld.file_paths ?? []).includes(fp))
-                            continue;
-                        const topic = k.replace('cachly:lesson:best:', '');
-                        if (relatedLessons.some(l => l.includes(`\`${topic}\``)))
-                            continue;
-                        const emoji = ld.outcome === 'success' ? '✅' : ld.outcome === 'partial' ? '⚠️' : '❌';
-                        const sev = ld.severity === 'critical' ? ' 🔴' : ld.severity === 'major' ? ' 🟡' : '';
-                        const by = ld.author ? ` · 👤 ${ld.author}` : '';
-                        relatedLessons.push(`  - ${emoji} \`${topic}\`${sev}${by} — ${(ld.what_worked ?? '').slice(0, 100)}`);
-                    }
-                }
-                if (relatedLessons.length > 0) {
-                    lines.push(`**Related lessons:**`);
-                    lines.push(...relatedLessons.slice(0, 5));
-                }
-                else {
-                    lines.push(`**Related lessons:** _None yet_`);
-                }
-                lines.push(``);
-            }
-            lines.push(`---`, `_Attribution builds with \`learn_from_attempts(file_paths=[...], author="...")\`. Run this before committing to track what changed and why._`);
-            return lines.join('\n');
-        }
-        // ── team_expertise_map ────────────────────────────────────────────────────
-        // Phase 3B: Full team expertise overview — who knows what, at a glance.
-        case 'team_expertise_map': {
-            const { instance_id, top_n = 20, } = args;
-            const redis = await getConnection(instance_id);
-            // Scan all person nodes (capped + timed out so a huge keyspace can't hang the agent)
-            const personKeys = await scanKeys(redis, 'cachly:ckg:node:person:*', { max: 2000 });
-            if (personKeys.length === 0) {
-                return [
-                    `## 🗺️ Team Expertise Map`,
-                    ``,
-                    `No contributors yet.`,
-                    ``,
-                    `Add \`author="handle"\` to any \`learn_from_attempts\` call to start building the map.`,
-                ].join('\n');
-            }
-            const people = [];
-            for (const pk of personKeys) {
-                const raw = await redis.get(pk);
-                if (!raw)
-                    continue;
-                const pn = safeJsonParse(raw, null);
-                if (!pn || pn.type !== 'person')
-                    continue;
-                // Count authored lessons + collect domains from authored edges
-                const outEdgeKeys = await redis.smembers(`cachly:ckg:idx:from:${pn.id}`);
-                const domainCounts = new Map();
-                let lessonCount = 0;
-                for (const ek of outEdgeKeys) {
-                    const er = await redis.get(ek);
-                    if (!er)
-                        continue;
-                    const edge = safeJsonParse(er, null);
-                    if (!edge || edge.edgeType !== 'authored')
-                        continue;
-                    lessonCount++;
-                    const domain = edge.to.split(':')[0] ?? 'unknown';
-                    domainCounts.set(domain, (domainCounts.get(domain) ?? 0) + 1);
-                }
-                people.push({ handle: pn.handle, lessonCount, domains: domainCounts, lastActive: pn.last_active });
-            }
-            people.sort((a, b) => b.lessonCount - a.lessonCount);
-            const topPeople = people.slice(0, top_n);
-            const lines = [
-                `## 🗺️ Team Expertise Map`,
-                ``,
-                `**${topPeople.length}** contributor${topPeople.length !== 1 ? 's' : ''} tracked:`,
-                ``,
-                `| # | Handle | Lessons | Top domains | Last active |`,
-                `|---|--------|---------|-------------|-------------|`,
-            ];
-            for (const [i, p] of topPeople.entries()) {
-                const medal = i === 0 ? '🥇' : i === 1 ? '🥈' : i === 2 ? '🥉' : `${i + 1}`;
-                const days = Math.floor((Date.now() - new Date(p.lastActive).getTime()) / 86400000);
-                const ago = days < 1 ? 'today' : days < 7 ? `${days}d ago` : days < 30 ? `${Math.floor(days / 7)}w ago` : `${Math.floor(days / 30)}mo ago`;
-                const domainStr = [...p.domains.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([d, c]) => `${d}(${c})`).join(', ') || '—';
-                lines.push(`| ${medal} | **${p.handle}** | ${p.lessonCount} | ${domainStr} | ${ago} |`);
-            }
-            lines.push(``, `---`, `_Use \`brain_who_knows(topic="...")\` to find the expert for a specific problem._`);
-            return lines.join('\n');
-        }
-        // ── skill_gaps ────────────────────────────────────────────────────────────
-        // Phase 3C: Show knowledge blind spots — domains/files with no success lessons,
-        // no attribution, or only failures.
-        case 'skill_gaps': {
-            const { instance_id, min_failures = 1, } = args;
-            const redis = await getConnection(instance_id);
-            // Scan all best lessons (capped + timed out)
-            const lessonKeys = await scanKeys(redis, 'cachly:lesson:best:*', { max: 3000 });
-            const domainMap = new Map();
-            let totalAttributed = 0;
-            let totalPrivate = 0;
-            for (const k of lessonKeys) {
-                const raw = await redis.get(k);
-                if (!raw)
-                    continue;
-                const l = safeJsonParse(raw, {});
-                const domain = (l.topic ?? '').split(':')[0] ?? 'unknown';
-                const s = domainMap.get(domain) ?? { successes: 0, failures: 0, attributed: 0, topics: [] };
-                if (l.outcome === 'success' || l.outcome === 'partial')
-                    s.successes++;
-                else
-                    s.failures++;
-                if (l.author) {
-                    s.attributed++;
-                    totalAttributed++;
-                }
-                if (l.visibility === 'private')
-                    totalPrivate++;
-                s.topics.push(l.topic ?? '');
-                domainMap.set(domain, s);
-            }
-            const gaps = [];
-            for (const [domain, s] of domainMap) {
-                if (s.failures >= min_failures && s.successes === 0) {
-                    gaps.push({
-                        domain, type: 'unresolved failures',
-                        severity: s.failures >= 3 ? '🔴 critical' : '🟡 warn',
-                        detail: `${s.failures} failure${s.failures !== 1 ? 's' : ''}, 0 solutions — use \`learn_from_attempts\` to store what fixed it`,
-                    });
-                }
-                if (s.successes + s.failures >= 3 && s.attributed === 0) {
-                    gaps.push({
-                        domain, type: 'no attribution',
-                        severity: '🔵 info',
-                        detail: `${s.successes + s.failures} lessons with no \`author\` field — attribution lost, \`brain_who_knows\` can't help here`,
-                    });
-                }
-            }
-            const lines = [
-                `## 🔍 Skill Gaps — Knowledge Blind Spots`,
-                ``,
-                `**${lessonKeys.length}** lessons scanned · **${totalAttributed}** attributed · **${gaps.length}** gap${gaps.length !== 1 ? 's' : ''} found`,
-                totalPrivate > 0 ? `_(${totalPrivate} private lessons excluded from gap analysis)_` : '',
-                ``,
-            ].filter(Boolean);
-            if (gaps.length === 0) {
-                lines.push(`✅ No significant knowledge gaps detected. All domains with failures have at least one success lesson.`);
-            }
-            else {
-                const bySev = [
-                    ...gaps.filter(g => g.severity.includes('critical')),
-                    ...gaps.filter(g => g.severity.includes('warn')),
-                    ...gaps.filter(g => g.severity.includes('info')),
-                ];
-                for (const g of bySev.slice(0, 15)) {
-                    lines.push(`${g.severity} **\`${g.domain}\`** — ${g.type}`);
-                    lines.push(`  ${g.detail}`);
-                    lines.push(``);
-                }
-                if (gaps.length > 15)
-                    lines.push(`_…and ${gaps.length - 15} more gaps. Fix critical ones first._`);
-            }
-            lines.push(`---`, `_Fix gaps with \`learn_from_attempts(topic="${gaps[0]?.domain ?? 'your:topic'}", outcome="success", what_worked="...")\`_`, `_Add \`author="name"\` to every call to enable \`brain_who_knows\` + \`team_expertise_map\`._`);
-            return lines.join('\n');
-        }
-        // ── brain_coverage ────────────────────────────────────────────────────────
-        // Phase 3C: Knowledge-coverage health score for the repository.
-        case 'brain_coverage': {
-            const { instance_id, repo_path = '.', } = args;
-            const redis = await getConnection(instance_id);
-            // Count lessons, person + file nodes (each capped + timed out, gathered in parallel)
-            const [lessonKeys, personKeys, fileKeys] = await Promise.all([
-                scanKeys(redis, 'cachly:lesson:best:*', { max: 5000 }),
-                scanKeys(redis, 'cachly:ckg:node:person:*', { max: 2000 }),
-                scanKeys(redis, 'cachly:ckg:node:file:*', { max: 5000 }),
-            ]);
-            // Get git file count for comparison (optional — non-critical if not a git repo)
-            let gitFileCount = 0;
-            let _gitFileCountLabel = 'n/a';
-            try {
-                const { execSync } = await import('node:child_process');
-                const { resolve } = await import('node:path');
-                const repoDir = resolve(repo_path);
-                const output = execSync('git ls-files', { cwd: repoDir, encoding: 'utf-8', stdio: 'pipe' });
-                gitFileCount = output.trim().split('\n').filter(Boolean).length;
-                _gitFileCountLabel = String(gitFileCount);
-            }
-            catch { /* not a git repo — skip */ }
-            // Lesson quality breakdown
-            let successCount = 0;
-            let failureCount = 0;
-            let attributedCount = 0;
-            const domainSet = new Set();
-            for (const k of lessonKeys) {
-                const raw = await redis.get(k);
-                if (!raw)
-                    continue;
-                const l = safeJsonParse(raw, {});
-                if (l.outcome === 'success' || l.outcome === 'partial')
-                    successCount++;
-                else
-                    failureCount++;
-                if (l.author)
-                    attributedCount++;
-                domainSet.add((l.topic ?? '').split(':')[0] ?? 'unknown');
-            }
-            const fileCoverage = gitFileCount > 0
-                ? `${Math.round((fileKeys.length / gitFileCount) * 100)}% (${fileKeys.length}/${gitFileCount} files)`
-                : `${fileKeys.length} files tracked`;
-            const attributionPct = lessonKeys.length > 0
-                ? Math.round((attributedCount / lessonKeys.length) * 100)
-                : 0;
-            const overallScore = Math.round((Math.min(1, lessonKeys.length / 50) * 25) + // lesson volume (25 pts)
-                (Math.min(1, successCount / Math.max(1, lessonKeys.length)) * 25) + // success ratio (25 pts)
-                (Math.min(1, attributionPct / 100) * 25) + // attribution completeness (25 pts)
-                (Math.min(1, personKeys.length / 5) * 25) // team engagement (25 pts)
-            );
-            const scoreEmoji = overallScore >= 80 ? '🟢' : overallScore >= 50 ? '🟡' : '🔴';
-            return [
-                `## 📊 Brain Coverage Report`,
-                ``,
-                `${scoreEmoji} **Overall score: ${overallScore}/100**`,
-                ``,
-                `| Metric | Value |`,
-                `|--------|-------|`,
-                `| Total lessons | **${lessonKeys.length}** (${successCount} success · ${failureCount} failure) |`,
-                `| Problem domains | **${domainSet.size}** |`,
-                `| Attribution | **${attributedCount}/${lessonKeys.length}** (${attributionPct}%) |`,
-                `| Contributors | **${personKeys.length}** tracked in knowledge graph |`,
-                `| File coverage | **${fileCoverage}** |`,
-                ``,
-                `**Score breakdown (each 0–25):**`,
-                `- Lesson volume: **${Math.round(Math.min(1, lessonKeys.length / 50) * 25)}/25** _(target: 50+ lessons)_`,
-                `- Success ratio: **${Math.round(Math.min(1, successCount / Math.max(1, lessonKeys.length)) * 25)}/25** _(target: all lessons resolved)_`,
-                `- Attribution: **${Math.round(Math.min(1, attributionPct / 100) * 25)}/25** _(target: 100% attributed)_`,
-                `- Team engagement: **${Math.round(Math.min(1, personKeys.length / 5) * 25)}/25** _(target: 5+ contributors)_`,
-                ``,
-                `---`,
-                `_Boost score: run \`brain_from_git\` · add \`author\` to \`learn_from_attempts\` · fix gaps with \`skill_gaps\`_`,
-            ].join('\n');
-        }
-        // ── brain_metrics ─────────────────────────────────────────────────────────
-        // The three decisive metrics (PROGRESS.md §3 / VISION_10X.md §4):
-        //   1. Time-to-first-recall  — onboarding friction
-        //   2. Recall-lift           — the moat proof (vs. raw BM25)
-        //   3. Team-knowledge-reuse  — the value only a shared brain delivers
-        case 'brain_metrics': {
-            const { instance_id } = args;
-            const redis = await getConnection(instance_id);
-            const [bornAt, firstRecallAt, recallsTotalRaw, crossAuthorRaw, timeSavedRaw, reusePairs] = await Promise.all([
-                redis.get(`cachly:stats:born_at:${instance_id}`).catch(() => null),
-                redis.get(`cachly:stats:first_recall_at:${instance_id}`).catch(() => null),
-                redis.get(`cachly:stats:recalls_total:${instance_id}`).catch(() => null),
-                redis.get(`cachly:stats:cross_author_recalls:${instance_id}`).catch(() => null),
-                redis.get(`cachly:stats:time_saved_mins:${instance_id}`).catch(() => null),
-                redis.smembers(`cachly:stats:reuse_pairs:${instance_id}`).catch(() => []),
-            ]);
-            // ── GROW-046: welche Werkzeuge dieses Brain wirklich benutzt ────────────
-            // Bewusst HIER und nicht in einem eigenen Werkzeug: ein 123. Werkzeug,
-            // um zu messen, dass es zu viele Werkzeuge gibt, waere die Pointe, die
-            // niemand will.
-            // try/catch und nicht nur .catch(): faellt die Methode ganz aus (aelterer
-            // Client, anderer Redis-Aufsatz), wirft schon der AUFRUF, und eine
-            // Zusagen-Absicherung greift dann nicht. Eine Messzeile darf das
-            // Werkzeug nie stoppen.
-            let werkzeugRoh = {};
-            try {
-                werkzeugRoh = (await redis.hgetall(nutzungsSchluessel(instance_id))) ?? {};
-            }
-            catch {
-                werkzeugRoh = {};
-            }
-            const nutzung = verdichte(werkzeugRoh, 10);
-            // ── Die GEMESSENE Ersparnis, neben der gerechneten ─────────────────────
-            // Heinrich am 19.08.2026: "Bei der Schaetzung der Tokenersparnis sollten
-            // wir schauen, dass wir nicht nur schaetzen, denn das nervt Leute sehr
-            // stark." Dies hier ist eine Summe, keine Rechnung: die Laenge dessen,
-            // was das Brain wirklich zurueckgegeben hat. Dieselbe try/catch-Vorsicht
-            // wie oben — eine Messzeile darf das Werkzeug nie stoppen.
-            let lieferRoh = { token: 0, abrufe: 0, treffer: 0 };
-            try {
-                const token = await redis.get(lieferSchluessel(instance_id));
-                const quoten = (await redis.hgetall(trefferSchluessel(instance_id))) ?? {};
-                lieferRoh = { token: token ?? 0, abrufe: quoten.abrufe ?? 0, treffer: quoten.treffer ?? 0 };
-            }
-            catch {
-                // still
-            }
-            const lieferung = lieferBild(lieferRoh);
-            // ── Metric 1: Time-to-first-recall ──────────────────────────────────────
-            let ttfrLine;
-            if (bornAt && firstRecallAt) {
-                const ms = new Date(firstRecallAt).getTime() - new Date(bornAt).getTime();
-                const mins = Math.max(0, Math.round(ms / 60000));
-                const human = mins < 1 ? '<1 min' : mins < 60 ? `${mins} min` : `${(mins / 60).toFixed(1)} h`;
-                const target = ms <= 2 * 60000 ? '🟢 under 2 min target' : ms <= 60 * 60000 ? '🟡 over 2 min' : '🔴 over 1 h';
-                ttfrLine = `**${human}** from first lesson → first proven recall · ${target}`;
-            }
-            else if (bornAt && !firstRecallAt) {
-                ttfrLine = `🟡 Brain has knowledge but no proven recall yet — try \`smart_recall\``;
-            }
-            else {
-                ttfrLine = `⚪ Not enough data yet — store a lesson, then recall it`;
-            }
-            // ── Metric 2: Recall-lift ────────────────────────────────────────────────
-            //
-            // HIER STAND EINE FEST EINGEBAUTE ZAHL.
-            //
-            // "+33.3 % Precision@1 vs. raw BM25" war eine Zeichenkette, keine Messung.
-            // Der Kommentar darueber behauptete "CI-defended" und liess sie wie einen
-            // Messwert aussehen. Gefunden am 20.08.2026 beim ersten Lauf der Gegenrede.
-            //
-            // Die Zahl stammte ausserdem aus einer Formel, die am 19.08.2026
-            // ABGELOEST wurde: auf 498 echten Lektionen erreichte sie 15 Prozent, die
-            // Nachfolgerin 30. Der kleine Pruefstand (17 Lektionen, 13 Fragen) belohnte
-            // dabei die schlechtere Fassung mit 92,3 gegen 69,2 Prozent — seine Zahl
-            // bewegt sich ENTGEGENGESETZT zur Wirklichkeit. Belegt in src/bench/gate.ts.
-            //
-            // Eine Kennzahl, die der Server nicht selbst erhebt, gehoert nicht in seine
-            // Ausgabe. Sie kann nicht fallen, also misst sie nichts. Ein leeres Feld ist
-            // ehrlicher als eine Zahl, die immer gut aussieht.
-            //
-            // Dieselbe Entscheidung wurde am 19.08.2026 eine Kennzahl weiter unten schon
-            // einmal getroffen (die erfundenen "1.429,5 h"). Sie galt hier genauso und
-            // wurde nur nicht angewandt.
-            const recallLiftLine = [
-                '⚪ **Nicht gemessen** — diese Zahl erhebt der Server nicht selbst.',
-                '  Selbst messen: `npm run bench` in `sdk/mcp`.',
-                '  Achtung, der Pruefstand hat 17 Lektionen und 13 Fragen — ein Beispielsatz, kein Bestand.',
-                '  Auf 498 ECHTEN Lektionen gemessen am 19.08.2026: Precision@1 **30 %** (vorher 15 %).',
-            ].join('\n');
-            // ── Metric 3: Team-knowledge-reuse ──────────────────────────────────────
-            const recallsTotal = Number(recallsTotalRaw ?? 0);
-            const crossAuthor = Number(crossAuthorRaw ?? 0);
-            const reusePct = recallsTotal > 0 ? Math.round((crossAuthor / recallsTotal) * 100) : 0;
-            const reuseTarget = reusePct >= 30 ? '🟢 above 30 % target' : recallsTotal === 0 ? '⚪ no recalls yet' : '🟡 below 30 % target';
-            /*
-             * ── Die geschaetzten Stunden stehen nicht mehr im Kundenblick ─────────
-             *
-             * "1.429,5 h total saved not re-researching known fixes" war die
-             * groesste erfundene Zahl, die wir gezeigt haben. Sie ist gerechnet:
-             * Minuten je Lektion nach Schwere, mal Abrufzahl. Der Faktor ist
-             * geraten, und die Zahl waechst mit jedem Abruf mit — auch mit einem,
-             * der nichts gefunden hat.
-             *
-             * Heinrich am 19.08.2026 zur alten Fassung: "Ich tue mich schwer mit den
-             * 1200 h. Das haette vielleicht frueher zugetroffen, zu
-             * Entwicklungszeiten ohne AI, aber heutzutage nicht mehr. Die erscheint
-             * laecherlich hoch."
-             *
-             * Genau so ist es. Die Annahme dahinter — 30 bis 240 Minuten Recherche
-             * je Lektion — ist der Preis von VOR den Assistenten. Heute findet ein
-             * Modell dasselbe in Sekunden. Die Zahl misst eine Welt, die es nicht
-             * mehr gibt.
-             *
-             * FREMDBELEG dazu (Artikel 4278052, METR-Studie): erfahrene Entwickler
-             * FUEHLTEN sich mit KI schneller und waren gemessen 19 Prozent
-             * langsamer. Selbstauskunft und Messung zeigen in entgegengesetzte
-             * Richtungen — eine geschaetzte Zeitersparnis ist die schnellste Art,
-             * Vertrauen fuer alle anderen Zahlen gleich mit zu verlieren.
-             *
-             * Sie wird nicht geloescht, sondern ZURUECKGESTUFT: sie steht weiterhin
-             * da, aber klein, mit ihrer Annahme im selben Satz, und unter der
-             * gemessenen Liefermenge. Eine erfundene Zahl ALLEIN nervt; eine
-             * gemessene daneben traegt sie.
-             */
-            const timeSaved = Math.round(Number(timeSavedRaw ?? 0));
-            const timeSavedHuman = timeSaved < 60 ? `${timeSaved} min` : `${(timeSaved / 60).toFixed(1)} h`;
-            const lines = [
-                `## 📈 Brain Metrics — the three that decide everything`,
-                ``,
-                `### 1. Time-to-first-recall _(onboarding friction)_`,
-                ttfrLine,
-                ``,
-                `### 2. Recall-lift _(the moat proof)_`,
-                recallLiftLine,
-                `_Reproduce: \`npm run bench\` · CI-defended in \`rerank.test.ts\` · details in BENCH.md_`,
-                ``,
-                `### 3. Team-knowledge-reuse _(the value only a shared brain delivers)_`,
-                `**${reusePct}%** of proven recalls used a teammate's lesson (${crossAuthor}/${recallsTotal}) · ${reuseTarget}`,
-                reusePairs.length > 0 ? `**${reusePairs.length}** distinct reuse relationship${reusePairs.length !== 1 ? 's' : ''} across the team` : '',
-                ``,
-                `---`,
-                // GEMESSEN zuerst, GESCHAETZT darunter — in dieser Reihenfolge, immer.
-                // Vorher stand die gerechnete Stundenzahl ganz oben und fett; die
-                // einzige Zahl ohne Annahme kam gar nicht vor.
-                `### 📦 Aus dem Brain geliefert _(gemessen, nicht gerechnet)_`,
-                lieferungInWorten(lieferung),
-                ``,
-                lieferung.abrufe > 0
-                    ? `_Daneben eine **Schätzung**: ${timeSavedHuman} nicht neu recherchiert — gerechnet mit 30–240 Min. je Lektion nach Schwere, nicht gemessen. Die Zahl darüber braucht diese Annahme nicht._`
-                    : `_Eine **Schätzung** von ${timeSavedHuman} „nicht neu recherchiert" wäre hier gerechnet, nicht gemessen — sie erscheint erst, wenn daneben eine gemessene Zahl steht._`,
-                recallsTotal === 0
-                    ? `_Tip: pass \`author="your-handle"\` to \`smart_recall\` so cross-author reuse can be tracked._`
-                    : `_These numbers compound: every learned lesson and every teammate raises all three._`,
-                ``,
-                `### 🔧 Werkzeug-Nutzung _(erst messen, dann zusammenlegen)_`,
-                nutzungInWorten(nutzung, TOOLS.length),
-                ...(nutzung.spitze.length > 0
-                    ? nutzung.spitze.map((z, i) => `  ${String(i + 1).padStart(2)}. \`${z.name}\` — ${z.aufrufe}× (${Math.round(z.anteil * 100)} %)`)
-                    : []),
-            ].filter(Boolean);
-            return lines.join('\n');
-        }
-        // ── brain_service_map ───────────────────────────────────────────────────────
-        // Phase 3: "Who owns this service, and what's gone wrong with it before?"
-        // Bridges a running system (e.g. a restarting prometheus pod) to the people who
-        // operate it, the files that run in it, and the lessons learned operating it.
-        case 'brain_service_map': {
-            const { instance_id, service, } = args;
-            if (!service || typeof service !== 'string' || !service.trim()) {
-                return '⚠️ `brain_service_map` requires a non-empty `service`. Example: `brain_service_map(service="prometheus")`.';
-            }
-            const redis = await getConnection(instance_id);
-            const serviceId = `service:${ckgSlug(service.trim())}`;
-            const nodeRaw = await redis.get(`cachly:ckg:node:${serviceId}`).catch(() => null);
-            const node = nodeRaw ? safeJsonParse(nodeRaw, null) : null;
-            // Inbound edges: person→operates, concept→affects, file→runs_in
-            const inbound = await redis.smembers(`cachly:ckg:idx:to:${serviceId}`).catch(() => []);
-            const operators = [];
-            const files = [];
-            const concepts = [];
-            for (const ek of inbound) {
-                const er = await redis.get(ek).catch(() => null);
-                if (!er)
-                    continue;
-                const edge = safeJsonParse(er, null);
-                if (!edge)
-                    continue;
-                if (edge.edgeType === 'operates') {
-                    const pr = await redis.get(`cachly:ckg:node:${edge.from}`).catch(() => null);
-                    const pn = pr ? safeJsonParse(pr, null) : null;
-                    if (pn?.handle)
-                        operators.push({ handle: pn.handle, trials: edge.trials });
-                }
-                else if (edge.edgeType === 'runs_in') {
-                    const fr = await redis.get(`cachly:ckg:node:${edge.from}`).catch(() => null);
-                    const fn = fr ? safeJsonParse(fr, null) : null;
-                    if (fn?.path)
-                        files.push({ path: fn.path, trials: edge.trials });
-                }
-                else if (edge.edgeType === 'affects') {
-                    concepts.push({ id: edge.from, confidence: edge.confidence });
-                }
-            }
-            operators.sort((a, b) => b.trials - a.trials);
-            files.sort((a, b) => b.trials - a.trials);
-            concepts.sort((a, b) => b.confidence - a.confidence);
-            const lessons = [];
-            const lessonKeys = await scanKeys(redis, 'cachly:lesson:best:*', { max: 1500 });
-            const svcLower = service.trim().toLowerCase();
-            for (const k of lessonKeys.slice(0, 400)) {
-                const raw = await redis.get(k).catch(() => null);
-                if (!raw)
-                    continue;
-                const ld = safeJsonParse(raw, {});
-                if (ld.visibility === 'private')
-                    continue;
-                if ((ld.service ?? '').toLowerCase() !== svcLower)
-                    continue;
-                lessons.push({ ...ld, topic: k.replace('cachly:lesson:best:', '') });
-            }
-            if (!node && lessons.length === 0 && operators.length === 0) {
-                return [
-                    `## 🛰️ Service Map — \`${service}\``,
-                    ``,
-                    `Nothing known about this service yet.`,
-                    ``,
-                    `Tag lessons with the service they concern so the brain can build this map:`,
-                    `\`learn_from_attempts(topic="...", service="${service}", author="you", file_paths=[...])\``,
-                ].join('\n');
-            }
-            const kindLabel = node?.kind === 'system' ? '🖥️ system' : '🛰️ service';
-            const lines = [
-                `## ${node?.kind === 'system' ? '🖥️' : '🛰️'} Service Map — \`${service}\``,
-                ``,
-                node ? `_${kindLabel} · ${node.count} lesson${node.count !== 1 ? 's' : ''} referenced · domain: ${node.domain}_` : `_No graph node yet — built from tagged lessons below._`,
-                ``,
-            ];
-            // Operators (who owns it)
-            if (operators.length > 0) {
-                const owners = operators.slice(0, 5).map((o, i) => {
-                    const medal = i === 0 ? '🥇' : i === 1 ? '🥈' : i === 2 ? '🥉' : `${i + 1}.`;
-                    return `${medal} **${o.handle}** (${o.trials}×)`;
-                }).join(' · ');
-                lines.push(`**Operators:** ${owners}`, ``);
-            }
-            else {
-                lines.push(`**Operators:** _None attributed — add \`author\` when learning about this service_`, ``);
-            }
-            // Recent failures first — the triage gold for an incident
-            const failures = lessons.filter(l => l.outcome === 'failure');
-            const successes = lessons.filter(l => l.outcome !== 'failure');
-            if (failures.length > 0) {
-                lines.push(`**⚠️ Known failures (${failures.length}):**`);
-                for (const l of failures.slice(0, 6)) {
-                    const sev = l.severity === 'critical' ? ' 🔴' : l.severity === 'major' ? ' 🟡' : '';
-                    const by = l.author ? ` · 👤 ${l.author}` : '';
-                    lines.push(`  - ❌ \`${l.topic}\`${sev}${by} — ${(l.what_worked ?? '').slice(0, 100)}`);
-                }
-                lines.push(``);
-            }
-            if (successes.length > 0) {
-                lines.push(`**✅ Proven fixes (${successes.length}):**`);
-                for (const l of successes.slice(0, 6)) {
-                    const emoji = l.outcome === 'partial' ? '⚠️' : '✅';
-                    const by = l.author ? ` · 👤 ${l.author}` : '';
-                    lines.push(`  - ${emoji} \`${l.topic}\`${by} — ${(l.what_worked ?? '').slice(0, 100)}`);
-                }
-                lines.push(``);
-            }
-            // Files that run in this service
-            if (files.length > 0) {
-                lines.push(`**Files in this service:** ${files.slice(0, 8).map(f => `\`${f.path}\``).join(', ')}`, ``);
-            }
-            lines.push(`---`, `_Tag lessons with \`service="${service}"\` to keep this map current. For infra, pass \`service_kind="system"\`._`);
-            return lines.join('\n');
-        }
-        // ── brain_collab_pairs ───────────────────────────────────────────────────
-        // W5: Person↔Person Collaboration Graph. Shows who works with whom on the
-        // team — built from (a) shared file-touches during learn_from_attempts and
-        // (b) cross-author knowledge-reuse events from smart_recall. Answers the
-        // onboarding question: "Frag X und Y — they solved that together."
-        case 'brain_collab_pairs': {
-            const { instance_id, min_weight = 1 } = args;
-            const redis = await getConnection(instance_id);
-            const minW = typeof min_weight === 'number' && min_weight >= 1 ? Math.floor(min_weight) : 1;
-            // Collect all person nodes.
-            const personKeys = await scanKeys(redis, 'cachly:ckg:node:person:*', { max: 500 });
-            const persons = new Map();
-            for (const k of personKeys) {
-                const raw = await redis.get(k);
-                if (!raw)
-                    continue;
-                const pn = safeJsonParse(raw, null);
-                if (!pn || pn.type !== 'person')
-                    continue;
-                persons.set(pn.id, { id: pn.id, handle: pn.handle, domain: pn.domain, count: pn.count });
-            }
-            if (persons.size === 0) {
-                return [
-                    `## 🤝 Team Collaboration Graph`,
-                    ``,
-                    `No contributors found yet.`,
-                    ``,
-                    `The graph builds automatically as teammates store lessons with \`author="name"\`:`,
-                    `\`learn_from_attempts(topic="...", author="alice", file_paths=["src/auth.ts"], ...)\``,
-                ].join('\n');
-            }
-            const pairMap = new Map();
-            for (const [personId, pInfo] of persons) {
-                const edgeKeys = await redis.smembers(`cachly:ckg:idx:from:${personId}`);
-                for (const ek of edgeKeys) {
-                    const er = await redis.get(ek);
-                    if (!er)
-                        continue;
-                    const edge = safeJsonParse(er, null);
-                    if (!edge || edge.edgeType !== 'collaborates')
-                        continue;
-                    const otherInfo = persons.get(edge.to);
-                    if (!otherInfo)
-                        continue;
-                    // Canonical pair key: alphabetically smaller id first.
-                    const [idA, idB] = personId < edge.to ? [personId, edge.to] : [edge.to, personId];
-                    const pairKey = `${idA}||${idB}`;
-                    const existing = pairMap.get(pairKey);
-                    if (existing) {
-                        existing.trials += edge.trials;
-                    }
-                    else {
-                        const [pA, pB] = personId < edge.to ? [pInfo, otherInfo] : [otherInfo, pInfo];
-                        pairMap.set(pairKey, { a: pA, b: pB, trials: edge.trials, confidence: edge.confidence });
-                    }
-                }
-            }
-            const pairs = [...pairMap.values()]
-                .filter(p => p.trials >= minW)
-                .sort((a, b) => b.trials - a.trials);
-            // Find solo contributors (no collaborators).
-            const connectedIds = new Set();
-            for (const p of pairs) {
-                connectedIds.add(p.a.id);
-                connectedIds.add(p.b.id);
-            }
-            const soloPersons = [...persons.values()].filter(p => !connectedIds.has(p.id));
-            const lines = [
-                `## 🤝 Team Collaboration Graph`,
-                ``,
-            ];
-            if (pairs.length === 0) {
-                lines.push(`No collaboration pairs yet (min weight: ${minW}).`, ``, `Pairs appear when two contributors touch the same file in \`learn_from_attempts\``, `or when someone recalls a teammate's lesson via \`smart_recall(requester="...")\`.`);
-            }
-            else {
-                lines.push(`**${pairs.length} collaboration pair${pairs.length !== 1 ? 's' : ''}** across ${connectedIds.size} contributor${connectedIds.size !== 1 ? 's' : ''}:`, ``);
-                for (const p of pairs.slice(0, 20)) {
-                    const conf = (p.confidence * 100).toFixed(0);
-                    const sharedDomains = [p.a.domain, p.b.domain]
-                        .filter((d, i, arr) => d && arr.indexOf(d) === i)
-                        .map(d => `\`${d}\``)
-                        .join(', ');
-                    lines.push(`### @${p.a.handle} ↔ @${p.b.handle}`, `- **${p.trials} collaboration event${p.trials !== 1 ? 's' : ''}** · ${conf}% confidence`, `- Domains: ${sharedDomains || '_unknown_'}`, `> 💬 _"Frag **@${p.a.handle}** und **@${p.b.handle}** — they've solved problems together in these areas."_`, ``);
-                }
-                if (pairs.length > 20) {
-                    lines.push(`_...and ${pairs.length - 20} more pairs. Use \`min_weight\` to filter._`, ``);
-                }
-            }
-            if (soloPersons.length > 0) {
-                lines.push(`---`, `### ⚠️ Bus Factor Alert — No Collaborators Yet`, ``, `${soloPersons.length} contributor${soloPersons.length !== 1 ? 's have' : ' has'} knowledge that no teammate has recalled or co-touched:`, ``, ...soloPersons.slice(0, 10).map(p => `- **@${p.handle}** — ${p.count} lesson${p.count !== 1 ? 's' : ''} · domain: \`${p.domain}\``), ``, `_Tip: pair these contributors with teammates on shared files to reduce bus factor._`);
-            }
-            lines.push(``, `---`, `_Collaboration edges build from \`learn_from_attempts(author=..., file_paths=[...])\` and \`smart_recall(requester=...)\` cross-author reuse._`);
-            return lines.join('\n');
-        }
-        // ── brain_portability ─────────────────────────────────────────────────────
-        case 'brain_portability': {
-            const { instance_id } = args;
-            const clients = [
-                {
-                    name: 'Claude Code',
-                    slug: 'claude-code',
-                    icon: '🤖',
-                    configPath: '~/.claude/settings.json',
-                    configBlock: JSON.stringify({
-                        mcpServers: {
-                            cachly: {
-                                command: 'npx',
-                                args: ['@cachly-dev/mcp-server@latest'],
-                                env: { CACHLY_JWT: '<cky_live_...>', CACHLY_BRAIN_INSTANCE_ID: instance_id },
-                            },
-                        },
-                    }, null, 2),
-                },
-                {
-                    name: 'Cursor',
-                    slug: 'cursor',
-                    icon: '🖱️',
-                    configPath: '~/.cursor/mcp.json',
-                    configBlock: JSON.stringify({
-                        mcpServers: {
-                            cachly: {
-                                command: 'npx',
-                                args: ['@cachly-dev/mcp-server@latest'],
-                                env: { CACHLY_JWT: '<cky_live_...>', CACHLY_BRAIN_INSTANCE_ID: instance_id },
-                            },
-                        },
-                    }, null, 2),
-                },
-                {
-                    name: 'Windsurf',
-                    slug: 'windsurf',
-                    icon: '🏄',
-                    configPath: '~/.windsurf/mcp.json',
-                    configBlock: JSON.stringify({
-                        mcpServers: {
-                            cachly: {
-                                command: 'npx',
-                                args: ['@cachly-dev/mcp-server@latest'],
-                                env: { CACHLY_JWT: '<cky_live_...>', CACHLY_BRAIN_INSTANCE_ID: instance_id },
-                            },
-                        },
-                    }, null, 2),
-                },
-                {
-                    name: 'GitHub Copilot (VS Code)',
-                    slug: 'copilot',
-                    icon: '🐙',
-                    configPath: '.vscode/mcp.json (workspace)',
-                    configBlock: JSON.stringify({
-                        servers: {
-                            cachly: {
-                                type: 'stdio',
-                                command: 'npx',
-                                args: ['@cachly-dev/mcp-server@latest'],
-                                env: { CACHLY_JWT: '<cky_live_...>', CACHLY_BRAIN_INSTANCE_ID: instance_id },
-                            },
-                        },
-                    }, null, 2),
-                },
-                {
-                    name: 'Cline',
-                    slug: 'cline',
-                    icon: '⚡',
-                    configPath: '~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json',
-                    configBlock: JSON.stringify({
-                        mcpServers: {
-                            cachly: {
-                                command: 'npx',
-                                args: ['@cachly-dev/mcp-server@latest'],
-                                env: { CACHLY_JWT: '<cky_live_...>', CACHLY_BRAIN_INSTANCE_ID: instance_id },
-                            },
-                        },
-                    }, null, 2),
-                },
-                {
-                    name: 'Zed',
-                    slug: 'zed',
-                    icon: '⚡',
-                    configPath: '~/.config/zed/settings.json',
-                    configBlock: JSON.stringify({
-                        context_servers: {
-                            cachly: {
-                                command: { path: 'npx', args: ['@cachly-dev/mcp-server@latest'] },
-                                env: { CACHLY_JWT: '<cky_live_...>', CACHLY_BRAIN_INSTANCE_ID: instance_id },
-                            },
-                        },
-                    }, null, 2),
-                },
-                {
-                    name: 'Continue',
-                    slug: 'continue',
-                    icon: '▶️',
-                    configPath: '~/.continue/config.json',
-                    configBlock: JSON.stringify({
-                        mcpServers: [
-                            {
-                                name: 'cachly',
-                                command: 'npx @cachly-dev/mcp-server@latest',
-                                env: { CACHLY_JWT: '<cky_live_...>', CACHLY_BRAIN_INSTANCE_ID: instance_id },
-                            },
-                        ],
-                    }, null, 2),
-                },
-            ];
-            const lines = [
-                `## 🌐 Brain Portability — Same Brain, Any Model`,
-                ``,
-                `> _"Bring your own model, keep your brain."_`,
-                ``,
-                `**Your Brain ID:** \`${instance_id}\``,
-                ``,
-                `Replace \`<cky_live_...>\` below with your own API key (get one at https://cachly.dev/setup-ai) — the Brain ID alone does not authenticate you.`,
-                ``,
-                `This Brain ID is model-agnostic. Every lesson you've learned, every Memory Crystal you've distilled,`,
-                `and every prediction from your Causal Knowledge Graph is accessible from **any MCP-compatible AI client**.`,
-                ``,
-                `---`,
-                ``,
-                `### Compatible Clients (${clients.length} supported)`,
-                ``,
-            ];
-            for (const c of clients) {
-                lines.push(`#### ${c.icon} ${c.name}`, `Config: \`${c.configPath}\``, ``, '```json', c.configBlock, '```', ``);
-            }
-            lines.push(`---`, ``, `### What travels with you`, ``, `| Data | Model-neutral? |`, `|------|---------------|`, `| Lessons (learn_from_attempts) | ✅ Full access in all clients |`, `| Memory Crystals (memory_crystalize) | ✅ Included in every session_start |`, `| Causal Knowledge Graph (brain_predict) | ✅ Same graph, same predictions |`, `| Team lessons (team_learn, team_confirm) | ✅ Team is per-Brain, not per-model |`, `| Domain Brain Marketplace installs | ✅ Installed once, available everywhere |`, `| Session handoffs (session_handoff) | ✅ Cross-client continuity |`, ``, `---`, ``, `### One-command setup for any new client`, ``, '```bash', `npx @cachly-dev/mcp-server@latest autopilot`, '```', ``, `Autopilot detects all installed editors and writes the config for each — with your \`${instance_id}\` Brain ID pre-filled.`, ``, `---`, `_Docs: cachly.dev/docs/model-neutral • Your Brain, Any Model_`);
-            return lines.join('\n');
-        }
-        // ── brain_changelog ───────────────────────────────────────────────────────
-        // Generates a human-readable Markdown changelog of recent lessons.
-        // Useful for weekly standups, sprint reviews, or async team updates.
-        case 'brain_changelog': {
-            const { instance_id, days = 7, max_lessons = 30, include_failures = true, } = args;
-            const redis = await getConnection(instance_id);
-            const cutoff = Date.now() - Number(days) * 86_400_000;
-            const keys = await scanKeys(redis, 'cachly:lesson:best:*', { max: 4000, timeoutMs: 4000 });
-            const recent = [];
-            for (const k of keys) {
-                const raw = await redis.get(k).catch(() => null);
-                if (!raw)
-                    continue;
-                const lesson = safeJsonParse(raw, {});
-                const ts = lesson.ts ? new Date(lesson.ts).getTime() : 0;
-                if (ts < cutoff)
-                    continue;
-                if (!include_failures && lesson.outcome === 'failure')
-                    continue;
-                const topic = k.replace('cachly:lesson:best:', '');
-                recent.push({ ...lesson, topic });
-            }
-            recent.sort((a, b) => {
-                const ta = a.ts ? new Date(a.ts).getTime() : 0;
-                const tb = b.ts ? new Date(b.ts).getTime() : 0;
-                return tb - ta;
-            });
-            const lessons = recent.slice(0, Number(max_lessons));
-            if (lessons.length === 0) {
-                return [
-                    `## 📋 Brain Changelog — last ${days} day${Number(days) !== 1 ? 's' : ''}`,
-                    ``,
-                    `_No new lessons learned in this window. Your Brain already knows everything it knows — add new lessons with \`learn_from_attempts\`._`,
-                ].join('\n');
-            }
-            const groups = new Map();
-            for (const l of lessons) {
-                const cat = l.topic.includes(':') ? l.topic.split(':')[0] : 'general';
-                const arr = groups.get(cat) ?? [];
-                arr.push(l);
-                groups.set(cat, arr);
-            }
-            const severityEmoji = (s) => s === 'critical' ? '🚨' : s === 'major' ? '⚠️' : s === 'minor' ? '💡' : '✨';
-            const outcomeEmoji = (o) => o === 'failure' ? '❌' : o === 'partial' ? '🔶' : '✅';
-            const dateStr = new Date().toISOString().slice(0, 10);
-            const lines = [
-                `## 📋 Brain Changelog — ${dateStr} (last ${days} day${Number(days) !== 1 ? 's' : ''})`,
-                ``,
-                `_${lessons.length} lesson${lessons.length !== 1 ? 's' : ''} learned across ${groups.size} topic area${groups.size !== 1 ? 's' : ''}_`,
-                ``,
-            ];
-            for (const [cat, catLessons] of Array.from(groups.entries()).sort((a, b) => b[1].length - a[1].length)) {
-                lines.push(`### ${cat}`);
-                lines.push('');
-                for (const l of catLessons) {
-                    const icon = l.outcome === 'failure' ? outcomeEmoji(l.outcome) : severityEmoji(l.severity);
-                    const body = l.outcome === 'failure' ? l.what_failed : l.what_worked;
-                    const meta = [];
-                    if (l.author)
-                        meta.push(`by **${l.author}**`);
-                    if (l.recall_count)
-                        meta.push(`${l.recall_count} recall${l.recall_count !== 1 ? 's' : ''}`);
-                    if (l.confidence !== undefined)
-                        meta.push(`${Math.round(l.confidence * 100)}% confidence`);
-                    lines.push(`- ${icon} **${l.topic}**${body ? ` — ${body}` : ''}`);
-                    if (meta.length)
-                        lines.push(`  _${meta.join(' · ')}_`);
-                }
-                lines.push('');
-            }
-            lines.push('---', `_Generated from Brain \`${instance_id}\` · Share this in your standup or Slack_`);
-            return lines.join('\n');
-        }
-        // ── brain_set_pref ────────────────────────────────────────────────────────
-        case 'brain_set_pref': {
-            const { instance_id, key, value, } = args;
-            if (!key || !key.trim())
-                throw new Error('key is required');
-            const redis = await getConnection(instance_id);
-            const redisKey = `cachly:prefs:${key.trim()}:${instance_id}`;
-            await redis.set(redisKey, String(value));
-            return `✅ Preference \`${key}\` set to \`${value}\` for this Brain instance.`;
-        }
-        // ── brain_get_pref ────────────────────────────────────────────────────────
-        case 'brain_get_pref': {
-            const { instance_id, key } = args;
-            const redis = await getConnection(instance_id);
-            if (key && key.trim()) {
-                const val = await redis.get(`cachly:prefs:${key.trim()}:${instance_id}`).catch(() => null);
-                return val === null
-                    ? `ℹ️ Preference \`${key}\` is not set (using default).`
-                    : `🔧 Preference \`${key}\` = \`${val}\``;
-            }
-            const prefKeys = await scanKeys(redis, `cachly:prefs:*:${instance_id}`, { max: 200, timeoutMs: 2000 });
-            if (prefKeys.length === 0)
-                return 'ℹ️ No preferences set for this Brain instance.';
-            const vals = await redis.mget(...prefKeys);
-            const lines = ['🔧 **Brain preferences:**', ''];
-            for (let i = 0; i < prefKeys.length; i++) {
-                const k = prefKeys[i].replace('cachly:prefs:', '').replace(`:${instance_id}`, '');
-                lines.push(`- \`${k}\` = \`${vals[i] ?? '(null)'}\``);
-            }
-            return lines.join('\n');
-        }
-        // ── sync_file_changes ─────────────────────────────────────────────────────
-        default:
-            return null;
-    }
-}
-//# sourceMappingURL=brain.js.map
+import{execSync as Me}from"node:child_process";import{createRequire as Ne}from"node:module";import{calculateConfidence as ge,confidenceBadge as Ye,STRUCTURED_TEMPLATES as Ue,CONFIDENCE_WARN_VALUE as Ae,CONFIDENCE_STALE_VALUE as Ve,CONFIDENCE_WARN_DAYS as Xe}from"../confidence.js";import{ckgSlug as Z,extractProblemConcept as $e,ckgUpsertNode as de,ckgUpdateEdge as ne,ckgUpsertPersonNode as Ze,ckgUpsertFileNode as Ie,ckgRecordCollaboration as Qe,ckgUpsertServiceNode as et}from"../ckg.js";import{safeJsonParse as P,scanKeys as ce}from"../utils.js";import{ersparteMinuten as Ee,istStarterLektion as ye,zaehltAlsErsparnis as Re}from"../wertbeitrag.js";import{lessonPreviewLines as me,trimTo as tt}from"../lesson-preview.js";import{meldeEinmal as fe,meldeUndVermerke as st,fehlerText as ve,OHNE_VEKTOREN as nt,OHNE_DIENST as ot,OHNE_FRAGEVEKTOR as at,SINNPFAD_ABBRUCH as it,OHNE_SCHREIBVEKTOR as ke}from"../aussetzer.js";import{versuchStart as rt,neueKennung as ct,wendeZuteilungAn as lt,schliesseVersuchAb as ut}from"../versuch.js";function Le(te,G,q){if(te.includes("lesson:best:")){const b=P(G,{});if(b&&typeof b=="object"&&(b.what_worked||b.what_failed||b.commands?.length))return me(b,{maxChars:q,indent:"  "})}const ae=tt(G,q);return ae?[ae]:[]}import{getRole as Be,ROLE_BADGE as ht,getScopes as dt,lessonVisibleToScope as ft,reviewModeEnabled as pt,storeLessonProposal as mt}from"./team.js";import{keywordSearch as Pe,wortindexEntwerten as gt,tokenize as Se,splitMultiQuery as yt,levenshtein as wt,indexVocab as De}from"../search.js";import{rerankByQuality as _t,qualityMultiplier as bt,extractLessonQuality as $t}from"../rerank.js";import{computeEmbedding as pe,hasEmbedProvider as we,EMBED_PROVIDER as Ce}from"../embeddings.js";import{repariereFelder as vt}from"../feldreparatur.js";import{VEKTOR_PRAEFIX as kt,NAME_VEKTOR_PRAEFIX as Oe,packe as je,textFuerVektor as St,textFuerNamensVektor as Ct,Vektorbestand as We}from"../bedeutung.js";import{schreibeEingaenge as xt,Eingangsbestand as Tt}from"../eingaenge.js";import{Seltenheitsbestand as Mt}from"../seltenheitsbestand.js";import{spurLegen as Nt}from"../spuren.js";import{bewerteTopf as At,spreizeImTopf as It,reichereAn as Et,inhaltsWoerter as Fe,grobStamm as Rt,GEWICHTE as Lt}from"../rangfolge.js";import{pruefeWirkung as Bt,werteAus as Pt,lehrwert as Dt,leiteAb as Ot}from"../wirkungsspur.js";import{SINN_TOPF as jt,EINGANG_SCHWELLE as Wt,EINGANG_SORTIER_GEWICHT as Ft}from"../rangfolge-stellschrauben.js";const ue=new We,xe=new We(6e4,Oe),Te=new Tt,_e=new Mt,zt=jt,Kt=Wt,Gt=Ft;import{upgradeNudge as qt}from"../upgrade-nudge.js";import{recallTiefe as ze,TIEFE_VOLL as Ht,TIEFE_VOLL_MEHRTHEMIG as Jt}from"../recall-tiefe.js";import{nutzungInWorten as Yt,nutzungsSchluessel as Ut,verdichte as Vt}from"../werkzeug-nutzung.js";import{inWorten as Xt,lieferBild as Zt,lieferSchluessel as Qt,trefferSchluessel as es}from"../geliefert.js";import{COAUTHOR_PREF_KEY as ts,autorHinweis as ss,coautorAus as ns,echterGitLeser as os,ermittleAutor as as,mitCoautor as is,nurMensch as Ke}from"../autor.js";import{TOOLS as rs}from"../tools.js";import{vorspannHinweis as cs}from"../vorspann.js";import{autorAbzeichen as ls,fremdanteil as us}from"../autor-abzeichen.js";import{cachlyUrl as hs}from"../cachly-url.js";const be=(()=>{try{const te=Ne(import.meta.url);for(const G of["../../../package.json","../../package.json"])try{const q=te(G);if(q.name==="@cachly-dev/mcp-server"&&q.version)return q.version}catch{}}catch{}return"0.10.100"})(),ds=()=>{try{return Ne(import.meta.url)("../../../CACHLY_CAPABILITIES.json").mcp?.total_tools??null}catch{}return null},fs={"0.10.119":["\u{1F50D} **Explainable briefings \u2014 provenance in every warning**","  \u{1F4CE} `/briefing` warnings now carry `outcome`, `author`, `learned_at` and `matched_on` (the context tokens that triggered the warning) \u2014 editors can show WHY a fix hint fired, not just what it claims.",'  \u{1F9F0} VS Code 0.12.0 uses this: severity + confidence in the toast, full lesson card with provenance, "Not helpful" per-file suppression, reviewable CLS auto-learns.',"  \u{1F9F9} CI docs now describe exactly what ships: scan mode uses the REST `/scan` endpoint, the GitLab template covers learn/scan/confirm."],"0.10.115":["\u{1F527} **`brain_get_pref` + `brain_set_pref` \u2014 persistent Brain preferences**","  \u{1F4D6} `brain_get_pref` reads back any stored preference (omit key to list all).","  \u270F\uFE0F `brain_set_pref` saves a preference to Redis \u2014 survives restarts, scoped per Brain instance.",'  \u{1F4A1} Known key: `auto_changelog` \u2014 set to "false" to silence the new-lessons digest at session_start.',"  \u{1F4CA} 140 MCP tools"],"0.10.114":["\u{1F4CB} **`brain_changelog` \u2014 weekly knowledge digest in one call**","  \u{1F4C5} Generates a grouped Markdown changelog of lessons learned in the last N days.","  \u{1F465} Grouped by topic category, annotated with author, recall count, and confidence \u2014 paste directly into standup or Slack.","  \u2699\uFE0F Params: `days` (default 7), `max_lessons` (default 30), `include_failures` (default true).","  \u{1F4CA} 138 MCP tools"],"0.10.113":["\u{1F4C8} **Week-over-week savings trend in `cache_stats`**","  \u{1F4C5} `cache_stats` now shows **7-day hits** + **WoW trend %** (e.g. `+23.0% vs prev week`) so ROI momentum is visible, not just the cumulative total.","  \u2B07\uFE0F Goes red (\u{1F4C9}) on drops, green (\u{1F4C8}) on growth \u2014 first week always shows +100% (new).","  \u{1F527} Backed by new `CountHitsInWindow` repo method + `hits_last_7d`, `hits_prev_7d`, `week_over_week_pct` fields in `SavingsEstimate`.","  \u{1F4CA} 137 MCP tools"],"0.10.112":["\u2699\uFE0F **Configurable cost_per_call_usd \u2014 accurate ROI for any LLM**","  \u{1F4A1} New `set_cost_per_call` tool: set your real per-call cost (claude-opus-4.8 \u2192 $0.02, gpt-5.5 \u2192 $0.015, claude-sonnet-4.6 \u2192 $0.009, claude-haiku-4.5 \u2192 $0.001) so savings estimates in `cache_stats` reflect your actual bill.","  \u{1F527} New API: `PUT /api/v1/instances/:id/cost-per-call` \u2014 persisted per instance, used by `cache_stats`, org savings, and SSE analytics stream.","  \u{1F4CA} 137 MCP tools"],"0.10.111":["\u{1F3E2} **Org-wide ROI + GitLab CI \u2014 the CFO number, aggregated**","  \u{1F4B0} `cache_org_stats` now shows **org-wide Tokenmaxxing ROI**: total savings summed across every instance in your org, monthly projection, top-5 instances by savings. One number for the whole team.","  \u{1F50C} Backed by new API endpoint `GET /api/v1/orgs/:id/savings` (org members only)","  \u{1F98A} GitLab CI integration: `brain-from-ci-gitlab.yml` \u2014 two `.post` jobs (on_success/on_failure), same helper script, pipeline never fails because of Brain push","  \u{1F6E0}\uFE0F GitHub Action template fixed: `secrets.*` in job-level `if` is invalid \u2014 guard removed (helper script skips cleanly on missing secrets)","  \u{1F4CA} 136 MCP tools"],"0.10.110":["\u{1F3E2} **Zero friction: ROI-Projektor, Org-Shared-Cache, CI ready-to-paste**","  \u{1F4C8} `cache_stats` \u2014 zero-hit projection calculator: shows expected monthly savings for 5/10/20-dev teams before a single cache hit lands. ROI visible from day 1.","  \u{1F3E2} New `cache_org_stats` \u2014 shared org-level cache stats across multiple instances. Convention-based (`org:{id}:sem`), zero API changes needed.","  \u{1F517} `cache_set`/`cache_get` now accept optional `org_id` \u2014 write to personal + org namespace, fall back to org on miss. Fully backwards-compatible.","  \u{1F4CB} Copy-paste CI integration: `brain-from-ci-action.yml` \u2192 Brain self-calibrates confidence on every GitHub Actions run. No config beyond two repo secrets.","  \u{1F4CA} 136 MCP tools"],"0.10.109":["\u{1F4B0} **Tokenmaxxing ROI + Closed-loop CI learning**","  \u{1F4CA} `cache_stats` now shows a **Tokenmaxxing ROI** section \u2014 total tokens saved, monthly cost projection, and top 3 most-cached prompts. Finally a number you can show the CFO.","  \u{1F504} New `brain_from_ci` \u2014 bulk-ingest CI history into the Brain (red\u2192green = learned fix, green\u2192red = CKG causal edge). The brain_from_git equivalent for CI. Bootstrap the Brain from your CI logs in one call.","  \u{1F4CA} 134 MCP tools"],"0.10.108":["\u{1F9E0} **Focused briefing + trustworthy autopilot**","  \u{1F3AF} New `session_start_summary` \u2014 top-N focused briefing by topic. Scores lessons by relevance \xD7 confidence + recall_count + severity + recency. Use it for a quick pre-brief without loading the full Brain.",'  \u{1F91D} Autopilot template now explains the data flow upfront ("your own Brain, EU-hosted, no third parties") \u2014 no more friction with cautious AI assistants during onboarding',"  \u{1F4CA} 132 MCP tools"],"0.10.107":["\u{1F3AF} **Recall@3 gap closed \u2014 the moat proof got sharper (the head-to-head that matters)**","  \u{1F50D} External-corpus Recall@3 **82.1% \u2192 98.2%** \xB7 Precision@1 **80.4%** \xB7 MRR **89.0%** \u2014 now ahead of flat-file memory on every metric","  \u{1F9EC} Root-cause fix: documents are no longer indexed with cross-lingual synonyms (the symmetric-expansion bug inflated any doc containing a common word ~28\xD7, burying topic-specific lessons). Queries still expand \u2014 a \u65E5\u672C\u8A9E query still finds English lessons.","  \u2696\uFE0F Reranker now compresses BM25 with score^0.3 before applying lesson quality, so a proven success can overtake a text-similar failed attempt even when the distractor scores 5\u20136\xD7 higher in raw BM25","  \u{1F6E1}\uFE0F CI bench gate widened to both home + external corpora with committed floors (`npm run bench:gate`) \u2014 recall quality can never silently regress again","  \u{1F4CA} 121 MCP tools"],"0.10.98":['\u{1F310} **Model-Neutrality as Feature (W9) \u2014 "Bring your own model, keep your brain."**',"  \u{1F50C} New `brain_portability()` \u2014 shows your Brain ID, all compatible MCP clients, and ready-to-paste config snippets for each; proves the same Brain works in Claude, Cursor, Copilot, Windsurf, Cline, Zed and more","  \u{1F9E0} Your lessons, crystals, and predictions are model-agnostic \u2014 no vendor lock-in at the memory layer",'  \u{1F4D6} New docs: cachly.dev/docs/model-neutral \u2014 "Same Brain, Any Model" guide with live config examples',"  \u{1F4CA} 121 MCP tools (new: `brain_portability`)"],"0.10.97":['\u{1F4A0} **Team Crystallize (W8) \u2014 the team-wide, causal counter to per-user "Dreaming"**',"  \u{1F9EC} New `team_crystallize()` \u2014 surfaces fixes that 2+ teammates *independently converged on*, the one thing a single-user memory structurally can't build",'  \u{1F9E9} Cross-person clustering: groups structurally similar problems across people & namespaces (e.g. "pool exhaustion" solved the same way in payments, auth & db)','  \u{1F465} Each pattern names who converged \u2014 instant "ask @alice and @bob, they both hit this"',"  \u{1F48E} Shows up in `crystal_view` alongside your per-brain crystal","  \u{1F4CA} 120 MCP tools (new: `team_crystallize`)"],"0.10.96":["\u{1F510} **Roles & Team-Scopes now ENFORCED (W6) \u2014 the enterprise governance layer**","  \u{1F6E1}\uFE0F `team_confirm` is now reviewer-gated, `team_learn` blocks viewers (recall-only) \u2014 roles stop being cosmetic the moment an admin is assigned","  \u{1F4DC} New `team_audit` tool \u2014 immutable, admin-only trail of every role change & lesson confirmation, for compliance & security reviews","  \u{1F513} Zero impact on open teams: governance activates only once you bootstrap an admin; before that everything works exactly as before","  \u{1F4CA} 119 MCP tools (new: `team_audit`)"],"0.10.95":["\u{1F9E0} **Domain Brain Marketplace (W10) \u2014 bootstrap your Brain with curated community knowledge**","  \u{1F6D2} `brain_marketplace()` \u2014 browse installable packs of high-trust lessons by domain: \u2638\uFE0F Kubernetes, \u{1F510} Auth, \u{1F5C4}\uFE0F Database, \u269B\uFE0F React, \u{1F4B3} Payments & more",'  \u{1F4E6} `brain_install(slug="k8s")` \u2014 merges a domain\'s verified lessons into your Brain; live in `smart_recall` instantly, even offline','  \u{1F6E1}\uFE0F Idempotent + non-destructive: installed lessons are tagged `source:"marketplace:<slug>"` and NEVER override your own',"  \u{1F50C} New gRPC `Subscribe` RPC \u2014 agents get new lessons streamed live the moment they're learned (completes the M2M loop with `Learn`)","  \u{1F4CA} 118 MCP tools (new: `brain_marketplace`, `brain_install`)"],"0.10.94":['\u{1F91D} **Person\u2194Person Collaboration Graph (W5) \u2014 "Frag X und Y, die haben das zusammen gel\xF6st"**',"  \u{1F578}\uFE0F New `brain_collab_pairs()` tool: shows every contributor pair who've touched the same files or recalled each other's lessons \u2014 ideal for onboarding and bus-factor analysis","  \u{1F4E1} `smart_recall` now wires CKG `collaborates` edges live when cross-author reuse fires \u2014 collaboration graph grows with every team recall","  \u26A0\uFE0F Bus-factor section: flags solo contributors whose knowledge no teammate has yet recalled","  \u{1F4CA} 116 MCP tools (new: `brain_collab_pairs`)"],"0.10.93":['\u{1F5FA}\uFE0F **`brain_plan` \u2014 your Brain goes from "what did we learn?" to "what should I do?"**',`  \u{1F9ED} Give it a task you're about to start ("upgrade Postgres 14\u219216") and it returns an ordered, grounded action plan: ranked failure modes to avoid, proven fix steps (dependency-aware, with commands), and a pre-flight checklist \u2014 all from your own lessons`,'  \u{1F52C} Generative layer on the CKG: where `brain_predict` answers "what might fail?", `brain_plan` answers "what, in what order?"',"  \u{1F4CA} 115 MCP tools (new: `brain_plan`)"],"0.10.92":["\u{1F44B} **Welcome-back digest \u2014 re-entry after a week away now leads with what changed**","  \u{1F331} `session_start` detects a gap \u2265 7 days and surfaces how many lessons your Brain gained while you were gone (git, CI & teammates kept it learning), with the freshest topics","  \u{1F9E0} Zero extra latency \u2014 the digest is computed from data session_start already loads","  \u{1F50C} New gRPC `Learn` RPC (M2M write path) \u2014 agents & CI can now teach the Brain directly, byte-compatible with the MCP lesson format","  \u{1F4CA} 115 MCP tools"],"0.10.91":["\u{1F550} **Lesson-anchored time attribution \u2014 every recall shows when it was learned and how much it saves**",`  \u{1F4A1} "Brain saved you" banner now includes: when the lesson was learned (e.g. "12 May"), estimated original debug cost by severity (critical=2h, major=1h, minor=20min), and team attribution when a teammate's lesson fires`,'  \u{1F4C5} Origin date formatted as "12 May" (same year) or "12 May 2024" (different year) \u2014 no clutter','  \u{1F465} Cross-author recalls now show "@author" on the same banner line \u2014 the "team knowledge reuse" value is front-and-center',"  \u{1F4CA} 115 MCP tools"],"0.10.90":["\u{1F4CA} **External benchmark corpus v2 \u2014 the proof is now statistically solid**","  \u{1F9EA} Expanded from 8 queries \u2192 61 lessons / 56 queries across 10 real-world engineering domains (k8s, DB, auth, CI, frontend, API, payments, observability, network, Node.js, security, infra)","  \u2694\uFE0F  10 adversarial distractors added \u2014 failure lessons that share the exact same vocabulary as the query, forcing the quality reranker to earn its lift","  \u{1F4C8} Results on the larger corpus: cachly +2.9% Precision@1 vs flat-file, +12.5% vs raw BM25 baseline \u2014 on a harder dataset, not an easy one","  \u{1F4CA} 115 MCP tools"],"0.10.89":["\u26A1 **One-command onboarding \u2014 `autopilot` is now the single canonical setup**","  \u{1F680} Every surface (README, docs, emails, dashboard, blog) now leads with `npx @cachly-dev/mcp-server@latest autopilot` \u2014 one command signs you in, configures every editor, and bootstraps from git",'  \u{1F9F9} Retired the split-brain instructions (legacy `@cachly-dev/init` wrapper + the old "three steps") so there\'s exactly one thing to copy-paste',"  \u{1F527} Fixed a build-breaking duplicate `export` on buildClaudeMdBlock that failed CI on v0.10.88","  \u{1F522} Version hygiene \u2014 package.json, server.json, lockfile and MCP_VERSION resynced (server.json/lockfile were stuck at 0.10.85)","  \u{1F4CA} 115 MCP tools"],"0.10.88":["\u2705 **Honest setup + tested config writer (v0.10.88)**",'  \u{1F512} setup/autopilot now report the truth: if no editor config could be written it exits non-zero with the exact failures instead of falsely claiming "Brain is ready"',"  \u{1F4CA} New setup_config_write_failed telemetry \u2014 permission/path failures that block activation are now visible in reporting","  \u{1F9EA} 24 new unit tests for the config writer (buildServerEnv, buildMcpConfig, mergeMcpConfig, buildClaudeMdBlock) \u2014 the merge logic that must never clobber your other MCP servers is now regression-guarded","  \u{1F4CA} 115 MCP tools"],"0.10.87":["\u{1F310} **Multi-editor auth persistence + full activation telemetry (v0.10.87)**","  \u2705 JWT + instance_id now persisted to Cursor (`~/.cursor/mcp.json`) and Windsurf configs on auth \u2014 no more infinite re-auth for non-Claude-Code users",'  \u{1F4E1} `device_flow_failed(reason="timeout")` now fires when sign-in window expires \u2014 blind spot in the funnel is gone',"  \u{1F4E1} `auto_provision_failed` now fires on network errors too (was only HTTP non-2xx)","  \u{1F4E1} `brain_from_git_failed` fires with error reason when auto-bootstrap throws \u2014 no more empty brain with no explanation",'  \u2728 Git bootstrap shows lesson count in session_start: "Brain bootstrapped \u2014 23 lessons loaded" \u2014 the WOW moment',"  \u{1F527} API: McpEvent stores brain quality metrics (fixes/features/refactors/total) \u2014 git learning quality now measurable","  \u{1F4CA} 115 MCP tools"],"0.10.86":["\u{1F6E1}\uFE0F **Zero-friction activation \u2014 your Brain self-heals into existence**","  \u{1F527} Auto-provision now runs on *any* tool call, not just at sign-in \u2014 if instance creation ever fails once, the next call recovers it automatically","  \u{1F91D} Parallel tool calls on startup are coalesced into one resolve (no more duplicate-instance races)",'  \u{1F4AC} Clearer "instance still starting" message \u2014 leads with "just retry", no manual config needed',"  \u{1F4C8} New activation-funnel telemetry: install \u2192 sign-in \u2192 provision, so silent churn is visible","  \u{1F4CA} 115 MCP tools"],"0.10.85":["\u{1F680} **One-command onboarding \u2014 `npx @cachly-dev/mcp-server@latest autopilot`**","  \u26A1 Single command does it all: auth \u2192 instance \u2192 every editor config \u2192 CLAUDE.md \u2192 Brain bootstrap \u2192 health","  \u{1F331} Seeds the 16-lesson starter corpus when git history is empty \u2014 your first smart_recall hits instantly","  \u{1F916} Fully automatic (zero prompts); `setup` remains for interactive, pick-your-editors onboarding"],"0.10.84":["\u{1F916} **M2M & agent-ecosystem reach \u2014 cachly for every caller, human or machine**","  \u{1F511} OAuth2 `client_credentials` grant \u2014 set CACHLY_CLIENT_ID + CACHLY_CLIENT_SECRET for fully headless auth (CI, agents, AI-to-AI)","  \u{1F5C2}\uFE0F `npx ... tool-specs --format=openai|anthropic|langchain` \u2014 export all 121 tools in any framework's dialect","  \u{1F310} `npx ... openapi` \u2014 OpenAPI 3.1 doc (1 POST path per tool) for Assistants / codegen / Postman","  \u{1F9EA} 14 new tests: client_credentials helpers, all four spec dialects, OpenAPI required-body inference"],"0.10.83":["\u{1F9E0} **Brain Viz \u2014 3D graph export**","  \u{1F310} `brain_graph(instance_id)` \u2014 exports the Causal Knowledge Graph as a render-ready {nodes, links} payload","  \u{1F3A8} Schema `cachly.brain_graph/v1`: node kinds (concept/person/file/service) with color groups + size, edges with confidence","  \u{1F5A5}\uFE0F Consumed verbatim by the 3D frontend (react-force-graph-3d / three.js) \u2014 the visual brain map",'  \u{1F50E} Filters: `domain`, `min_confidence`, `max_nodes` (with truncation flag), `format="summary"`',"  \u{1F9EA} 10 tests: kind detection, dangling-edge pruning, confidence/domain filters, schema contract","  \u{1F4CA} 115 MCP tools"],"0.10.82":["\u{1F4E1} **Telemetry API contracts \u2014 dashboard ingest pipeline prepared**","  \u{1F5C2}\uFE0F `src/telemetry-types.ts` \u2014 canonical event types + resolved event format (TelemetryEventRaw / TelemetryEventResolved)","  \u{1F510} `user_fingerprint` \u2014 non-reversible JWT sub hash, PII-free user clustering for dashboard","  \u{1F4CA} `metrics` block on key events: smart_recall (hit/topic), brain_from_git (fixes/features/total), brain_seed_starter (seeded_count)","  \u{1F6A6} Internal API contract documented: GET /internal/telemetry/stream \u2192 TelemetryEventResolved[]"],"0.10.81":["\u23F1\uFE0F **Onboarding-Bench \u2014 time-to-first-recall, now measured**","  \u{1F4D0} `npm run bench:onboarding` \u2014 cold (empty) vs seeded (starter) first-query hit rate via the real search engine","  \u{1F4CA} Result: first-query hit@1 **0% \u2192 87.5%**, hit@3 **0% \u2192 100%**, MRR **0% \u2192 93.8%**","  \u{1F6E1}\uFE0F CI-defended in `onboarding-bench.test.ts` (cold must answer 0%, seeded thresholds enforced)","  \u{1F4CB} `PLAN-DASHBOARD.md` \u2014 full build spec for the external Team-Knowledge-Reuse dashboard (separate repo)"],"0.10.80":["\u{1F331} **Starter corpus \u2014 first recall in seconds, not sessions**","  \u{1F4DA} `brain_seed_starter(instance_id)` \u2014 seed 16 curated universal lessons (Docker cache, JWT skew, K8s OOM, N+1, cache stampede\u2026)","  \u{1F680} Auto-seeds on first session when git history is empty/shallow \u2014 your first `smart_recall` returns a real hit",'  \u{1F6E1}\uFE0F Tagged `source:"starter"`, idempotent, never overrides your own lessons',"  \u23F1\uFE0F Directly attacks time-to-first-recall (<2 min goal); stamps `born_at` on seed","  \u{1F9EA} 18 new tests: seeding, idempotency, topic_filter, force, user-lesson protection","  \u{1F4CA} 113 MCP tools"],"0.10.79":["\u{1F310} **Brain Marketplace \u2014 full shareable Brain lifecycle**","  \u{1F4CB} `brain_share_list(instance_id)` \u2014 see all your public shares with lesson counts + share IDs","  \u{1F5D1}\uFE0F `brain_unshare(share_id)` \u2014 revoke a share; link goes dead immediately","  \u{1F50D} `brain_discover(query, topic)` \u2014 search public Brains in the cachly marketplace","  \u{1F4E4} `publish` CLI \u2014 fancy card + share URL; `--public` for discoverable; `--title` custom name","  \u{1F9EA} stress tests: team_expertise_map with 50 contributors, chain import/unshare, discover fallback","  \u{1F4CA} 112 MCP tools"],"0.10.78":["\u{1F310} **Phase 3: Shareable / Public Brains**",'  \u{1F4E4} `brain_share(instance_id="...")` \u2014 export a Brain snapshot as a shareable link (public or unlisted)','  \u{1F4E5} `brain_import(instance_id="...", share_id="...")` \u2014 import any public Brain into yours (1-line)',"  \u{1F50D} Optional topic_filter, min_confidence, topic_prefix \u2014 precise control over what gets shared/imported","  \u{1F512} dry_run mode on both tools \u2014 preview before committing","  \u{1F9EA} Regression suite added: share handler, buildServerEnv, stdout cleanness","  \u{1F4CA} 109 MCP tools"],"0.10.77":["\u{1FA79} **Frictionless onboarding + first-class self-hosting/BYOK**","  \u{1F680} Editor-launched server now serves all tools even before sign-in \u2014 zero-credential device flow finally triggers on first tool call","  \u{1F512} No more stdout pollution: stdio JSON-RPC stream stays clean when no JWT is set","  \u{1F3E0} `setup --api-url` / `init --api-url` point at a self-hosted backend; URL baked into config only when non-default",'  \u{1F9EC} `health` now shows your BYOK embedding provider + accepts cky_ long-lived keys (was a false "invalid token" failure)'],"0.10.76":["\u{1F4CA} **Agent-trace benchmark + editor matrix + setup timer**","  \u{1F4C2} New `agent-traces-corpus.json` \u2014 22 lessons, 15 queries, realistic AI-agent debug patterns","  \u{1F3C6} Benchmark result: **P@1 +66.7%, MRR +9.5% vs flat-file** (adversarial failure-distractors per category)","  \u{1F4CB} README: first-class editor support matrix (Claude Code, Cursor, Windsurf, VSCode, Cline, Continue.dev, Zed)",'  \u23F1\uFE0F  setup now shows elapsed time + "Brain is ready" banner at the end'],"0.10.75":["\u{1FA79} **Setup hardened \u2014 works from the VSCode plugin & any non-TTY terminal**","  \u{1F50C} `setup` no longer hangs on a non-interactive stdin (VSCode tasks, CI) \u2014 auto-detects + runs in automatic mode","  \u{1F510} Device-flow now uses the API proxy first (the old direct-Keycloak call returned 403) \u2014 sign-in actually completes","  \u{1F310} When auto sign-in is unavailable, the browser opens with a step-by-step API-key guide instead of a silent paste prompt","  \u{1F4CA} Funnel fix: `device_flow_completed` / `device_flow_failed(reason)` now emitted from setup too"],"0.10.73":["\u{1F510} **Team visibility scopes + one-command init + external bench**",'  \u{1F195} `team_grant_scope` / `team_scopes` \u2014 scope lessons to a sub-team (group="security"); only members + admins recall them','  \u{1F3F7}\uFE0F `learn_from_attempts(group="...")` \u2014 orthogonal to private; smart_recall enforces it per requester',"  \u26A1 `init` is now zero-arg + idempotent (reuses saved creds, only writes what changed, <60s)","  \u{1F4E6} `npm run bench:external` \u2014 prove recall-lift on a third-party-labeled corpus (portable JSON format)","  \u{1F4CA} 107 MCP tools"],"0.10.72":["\u{1F451} **Role model \u2014 admin \xB7 reviewer \xB7 contributor \xB7 viewer (Phase 3)**","  \u{1F195} `team_assign_role` \u2014 establish governance; first call bootstraps, admins manage the rest","  \u{1F195} `team_whoami` \u2014 see your own role and capabilities","  \u{1F195} `team_roster` \u2014 full team role table (\u{1F451}\u{1F6E1}\uFE0F\u270F\uFE0F\u{1F441}\uFE0F)","  \u{1F6E1}\uFE0F `team_confirm` is now role-aware \u2014 admin/reviewer auto-get senior weight; contributor gets peer; no self-promotion","  \u{1F451} Setup CLI now prompts for governance bootstrap (idempotent). 105 MCP tools"],"0.10.71":['\u{1F6E1}\uFE0F **Self-healing auth** \u2014 no more silent "0 recalls because the token quietly died"',"  \u267B\uFE0F Near-expiry tokens auto-refresh into a long-lived key while still valid (zero interaction)","  \u{1F501} A rejected (401) call self-heals once and retries before surfacing an error","  \u{1F4E3} If the credential is truly dead, session_start + get_api_status say so plainly + how to fix"],"0.10.70":["\u{1F6F0}\uFE0F **Service/System nodes in the graph (Phase 3)** \u2014 the brain now models running systems",'  \u{1F195} `brain_service_map(service="prometheus")` \u2014 who owns it + every failure/fix known','  \u{1F3F7}\uFE0F Tag lessons with `service="..."` (`service_kind="system"` for infra) \u2014 person\u2192operates, file\u2192runs_in edges',`  \u{1F6A8} Incident triage: a restarting pod \u2192 instant "who knows this and what's broken before"`,"  \u{1F4CA} 102 MCP tools"],"0.10.69":["\u{1F4C1} **Personalized context-aware recall (Phase 3)** \u2014 pass `context_files` to `smart_recall`","  \u{1F3AF} Lessons learned on your current files bubble up \u2014 even when the query doesn't name the file","  \u{1F3F7}\uFE0F `\u{1F4C1} context match` badge on every file-boosted result so you know WHY it ranked up","  \u2705 Works alongside keyword, semantic, CKG, and governance signals \u2014 a 6th ranking dimension"],"0.10.68":["\u{1F91D} **Collaboration graph (Phase 3)** \u2014 person\u2194person edges from shared files","  \u{1F465} `brain_who_knows` now shows who the top expert frequently works with",'  \u{1F68C} Bus-factor insight: "ask X and Y together \u2014 they solved this on shared files"',"  \u{1F6E1}\uFE0F Stability: every network call in the agent hot path is now timeout-bounded"],"0.10.64":["\u{1F4C8} **The three decisive metrics, now measurable**","  \u23F1\uFE0F `brain_metrics()` \u2014 time-to-first-recall, recall-lift, team-knowledge-reuse in one view","  \u{1F465} Cross-author reuse tracked: recall a teammate's lesson \u2192 counted + surfaced inline","  \u{1F6E1}\uFE0F Stability: scans now capped + timed out (a huge keyspace can't hang the agent)"],"0.10.61":["\u{1F3AF} **Phase 3C: 100 MCP tools milestone \u2014 zero-setup knowledge graph**","  \u{1F504} `brain_from_git` now auto-builds Person+File nodes from git history (zero setup!)","  \u{1F50D} `skill_gaps()` \u2014 find domains with unresolved failures, missing attribution","  \u{1F4CA} `brain_coverage()` \u2014 scored 0-100 health report: lessons \xB7 attribution \xB7 file coverage"],"0.10.60":["\u{1F195} **Phase 3B: File map + team overview + visibility**","  \u{1F4C1} `brain_file_map(file_paths=[...])` \u2014 experts + lessons per file before you touch it","  \u{1F5FA}\uFE0F `team_expertise_map()` \u2014 full team skills matrix in one table",'  \u{1F512} `visibility: "private"` on `learn_from_attempts` \u2014 private notes never leak to smart_recall',"  \u{1F4CA} 98 MCP tools"],"0.10.59":["\u{1F195} **Phase 3A: Org-wide knowledge graph**",'  \u{1F465} `brain_who_knows(topic="...")` \u2014 find your team\'s experts on any topic instantly','  \u{1F578}\uFE0F Person + File nodes auto-built from `learn_from_attempts(author="...", file_paths=[...])`',"  \u{1F464} Author attribution now shown inline in `smart_recall` results","  \u{1F4CA} 96 MCP tools \xB7 386 tests green"],"0.10.58":["\u{1F9F9} Zero lint warnings \u2014 all unused imports cleaned across every handler","\u2705 Build: 0 errors, 0 warnings \xB7 379 tests green"],"0.10.57":[`\u{1F195} **What's new in v${be}:**`,"  \u{1F527} **Critical fix** \u2014 corrected the npm bin/main entry path (`dist/src/index.js`); 0.10.50\u20130.10.52 shipped a broken entry point","  \u{1F527} Version hygiene \u2014 synced package.json, server.json, lockfile, MCP_VERSION; `latest` now points forward again","  \u2705 Accurate tool count (95) across README, server.json, CLI banners","  \u2705 Includes all Phase 2/3 work: quality reranking, Cachly-Bench, hybrid + CKG recall, team_confirm governance"],"0.10.52":["  \u2705 `smart_recall` \u2014 CKG traversal as Layer 3: finds lessons that FIXED causal-graph-similar problems (\u{1F578}\uFE0F causal graph badge)","  \u2705 Bench corpus expanded: governance adversarial pair proves review-boost end-to-end (+22% P@1 headline)","  \u{1F527} Import cleanup: unused symbols removed from brain.ts (no functional change)","  \u{1F4A1} `smart_recall` now shows keyword / semantic / CKG / hybrid match type for every result"],"0.10.51":["  \u2705 `team_confirm` \u2014 human review raises lesson recall ranking (\u{1F6E1}\uFE0F senior / \u2714\uFE0F peer)","  \u2705 Governance-aware recall \u2014 confirmed lessons outrank unreviewed auto-learned entries"],"0.10.50":["  \u2705 `smart_recall` \u2014 unified keyword + semantic hybrid list (one ranked result, not two sections)",'  \u2705 `smart_recall` \u2014 "Brain saved you here" banner surfaces time saved inline per proven lesson',"  \u2705 Quality reranking \u2014 proven successes outrank symptom-dense failures (+11% Precision@1)","  \u2705 Cachly-Bench \u2014 IR benchmark with CI regression guard (see BENCH.md for the proof)","  \u{1F527} Contradiction resolution now persisted to Redis (90-day TTL)","  \u{1F4A1} Run `smart_recall` to see your Brain's recall quality in action"],"0.10.49":["  \u2705 `brain_from_git` \u2014 auto-seed your Brain from git history in seconds","  \u2705 `brain_predict_failures` \u2014 predict CI/build failures before they happen","  \u2705 VS Code extension \u2014 Brain status bar, ambient learning, CodeLens hints","  \u2705 Team Brain \u2014 share lessons across your whole engineering team","  \u{1F527} Stability \u2014 auto-expiring memory keys, longer provisioning wait, robust recall"]},Js=new Set(["learn_from_attempts","recall_best_solution","smart_recall","recall_feedback","session_start","session_start_summary","session_end","session_ping","session_handoff","auto_learn_session","brain_who_knows","brain_file_map","team_expertise_map","skill_gaps","brain_coverage","brain_metrics","brain_service_map","brain_collab_pairs","brain_portability","brain_changelog","brain_set_pref","brain_get_pref"]),ps=hs("/billing","upgrade"),Ge=new Map,qe=new Set,ms=1680*60*60;function gs(te=new Date){return`cachly:quota:recalls:${te.toISOString().slice(0,7)}`}async function He(te){try{const G=gs();await te.incr(G)===1&&await te.expire(G,ms)}catch{}}async function Je(te,G){const q=Ge.get(te);if(q&&q.expiresAt>Date.now())return q.gate;try{const ae=await G(`/api/v1/instances/${te}/memory`),b=ae?.recall_limit??-1,t=ae?.total_recall_count??0,o={reached:b>0&&t>=b,limit:b,used:t,goodwillMessage:ae?.goodwill_message,notice:ae?.notice};return Ge.set(te,{gate:o,expiresAt:Date.now()+6e4}),o}catch{return{reached:!1,limit:-1,used:0}}}async function Ys(te,G,q,ae){switch(te){case"learn_from_attempts":{const{instance_id:b,topic:t,outcome:o,what_worked:S,what_failed:A="",context:p="",severity:l="major",file_paths:$=[],commands:s=[],tags:M=[],depends_on:g=[],author:x="",visibility:v="team",service:f="",service_kind:c="service",group:k=""}=G,{what_worked:m,what_failed:_="",context:I=""}=vt({what_worked:S,what_failed:A,context:p}),h=await q(b),e=new Date().toISOString(),D=as({uebergeben:x,umgebung:process.env.CACHLY_AUTHOR,git:os(process.env.CACHLY_WORKSPACE??process.cwd())});let O="";try{O=ns(await h.get(`cachly:prefs:${ts}:${b}`))}catch{}const F=is(D.autor,O),H=ss(D);if(v!=="private"&&await pt(h,b))return mt(h,t,{topic:t,outcome:o,what_worked:m,what_failed:_,context:I,severity:l,file_paths:$,commands:s,tags:M,depends_on:g,...F?{author:F}:{},...f?{service:f}:{},...k?{group:String(k).toLowerCase().trim()}:{},visibility:v,recall_count:0,ts:e,confidence:1,version:3});const W=t.split(":")[0],J=Ue[W],U=[];if(J)for(const T of J.required)T==="commands"&&s.length===0&&U.push(`\u{1F4CB} ${J.hint}`);let Q=!1,V=0,se,n=[];const y=await h.get(`cachly:lesson:best:${t}`);if(y)try{const T=JSON.parse(y);V=T.recall_count??0,se=T.last_recalled_at,n=T.audit_trail??[],n.push({ts:e,action:"updated",prev_outcome:T.outcome}),n.length>20&&(n=n.slice(-20)),Q=!0;const N=[];if(T.outcome==="success"&&o==="failure"?N.push("\u26A0\uFE0F **Contradiction detected!** Existing lesson has outcome: `success`, but you're storing `failure`.",'The existing "success" lesson will be preserved. Only the audit trail is updated.',"If you meant to mark this as failed permanently, store a new lesson with a distinct topic slug."):T.outcome==="failure"&&o==="success"&&N.push("\u2705 **Conflict resolved!** Previous lesson was `failure` \u2014 now overwriting with `success`."),N.length>0){n[n.length-1].action="contradiction-resolved";try{const B=Z(t),R=Z(`resolution:${t}`);await ne(h,B,"contradicts",R,!1)}catch{}try{const B=`cachly:contradictions:${t}`,R=T.outcome==="success"&&o==="failure"?"kept-success":"overwrote-failure";await h.rpush(B,JSON.stringify({ts:e,prev_outcome:T.outcome,new_outcome:o,direction:R})),await h.ltrim(B,-50,-1),await h.expire(B,180*86400)}catch{}N.push(`\u{1F5F3}\uFE0F Run \`madc_deliberate(topic="${t}")\` to resolve via expert agent voting.`)}}catch{}else n=[{ts:e,action:"created"}];const i=[];if(o==="failure"){const T=[],N=h.scanStream({match:"cachly:lesson:best:*",count:100});await new Promise((R,E)=>{N.on("data",j=>T.push(...j)),N.on("end",R),N.on("error",E)});const B=t.split(/[:\-_]/).filter(R=>R.length>2);for(const R of T.slice(0,50)){const E=await h.get(R);if(E)try{const j=JSON.parse(E);if(j.outcome!=="success")continue;const Y=(j.topic??"").split(/[:\-_]/).filter(oe=>oe.length>2);if(B.filter(oe=>Y.includes(oe)).length>=1&&j.topic!==t){i.push(`\u26A0\uFE0F **"I Was Wrong"**: lesson \`${j.topic}\` (success, ${j.severity??"major"}) might have prevented this failure.`,`   \u2192 Use \`recall_best_solution(topic="${j.topic}")\` before next attempt.`,`   \u2192 To mark it critical: \`learn_from_attempts(topic="${j.topic}", ..., severity="critical")\``);break}}catch{}}}for(const T of g){const N=`cachly:dep:${T}`,B=await h.get(N),R=P(B,[]);R.includes(t)||R.push(t),await h.set(N,JSON.stringify(R),"EX",90*86400)}const u={topic:t,outcome:o,what_worked:m,what_failed:_,context:I,severity:l,file_paths:$,commands:s,tags:M,depends_on:g,...F?{author:F}:{},...f?{service:f}:{},...k?{group:String(k).toLowerCase().trim()}:{},visibility:v,recall_count:V,...se?{last_recalled_at:se}:{},ts:e,verified_at:o==="success"||o==="partial"?e:void 0,confidence:1,audit_trail:n,version:3},r=JSON.stringify(u);h.set(`cachly:stats:born_at:${b}`,e,"EX",365*86400,"NX").catch(()=>{});const C=`cachly:lessons:${t}`;await h.rpush(C,r),await h.ltrim(C,-100,-1),await h.expire(C,90*86400);let L=!1;o==="success"||o==="partial"?(await h.set(`cachly:lesson:best:${t}`,r),L=!0):y||(await h.set(`cachly:lesson:best:${t}`,r),L=!0),L&&gt(),L&&we()&&(async()=>{const T=P(r,{});try{const N=await pe(St(T));N?.length&&await h.set(`${kt}${t}`,je(N))}catch(N){fe(ke,`Volltext-Vektor nicht geschrieben (${Ce}): ${ve(N)} \u2014 die Lektion ist gespeichert, der Bedeutungsabgleich uebergeht sie.`)}try{const N=await pe(Ct(t));N?.length&&await h.set(`${Oe}${t}`,je(N))}catch(N){fe(ke,`Namens-Vektor nicht geschrieben (${Ce}): ${ve(N)} \u2014 siehe oben, die Lektion selbst ist gespeichert.`)}try{await xt(h,t,T,pe)}catch(N){fe(ke,`Eingaenge nicht geschrieben (${Ce}): ${ve(N)} \u2014 siehe oben, die Lektion selbst ist gespeichert.`)}})();try{const T="cachly:session:decision-log",N=JSON.stringify({ts:e,topic:t,outcome:o,what_worked:m.slice(0,120)});await h.rpush(T,N),await h.ltrim(T,-50,-1)}catch{}let a=null;try{const T=Z(t),N=t.split(":")[0]??"unknown";await de(h,T,N,N);for(const R of M){const E=Z(`tag:${R}`);await de(h,E,"tag","tag"),await ne(h,T,"co-occurs",E,o==="success",o==="partial")}for(const R of g){const E=Z(R);await ne(h,T,"requires",E,!0)}if((N==="fix"||N==="debug")&&(o==="success"||o==="partial")){const R=_||I||"",E=R?$e(R):null;if(E){const j=Z(`problem:${E}`);await de(h,j,"problem","problem"),await ne(h,T,"fixes",j,o==="success",o==="partial")}}if(o==="failure"&&(_||m)){const E=$e(_||m);if(E){const j=Z(`cause:${E}`);await de(h,j,"cause","cause"),await ne(h,T,"causes",j,!1)}}if(o==="failure"){const R=await h.smembers(`cachly:ckg:idx:from:${T}`);for(const E of R){const j=await h.get(E);if(!j)continue;const Y=P(j,null);if(Y&&Y.edgeType==="fixes"&&Y.confidence>.7&&Y.trials>=3){a=`\u26A0\uFE0F **belief_conflict** on \`${t}\`: previously confirmed fix (confidence ${Y.confidence.toFixed(2)}, n=${Y.trials}) now reports failure. Both beliefs retained as \`contested\`. Use \`brain_resolve_conflict(instance_id="...", topic="${t}", winner="success"|"failure")\` to arbitrate, or \`ckg_inspect(concept="${T}")\` to review.`;const X=`cachly:ckg:conflict:${T}`;await h.set(X,JSON.stringify({topic:t,concept_id:T,detected_at:new Date().toISOString(),fix_confidence:Y.confidence,fix_trials:Y.trials,failure_outcome:o,reported_by:F||"unknown",what_failed:_||"",resolved:!1}),"EX",3600*24*90)}}}if(o==="success"&&(N==="fix"||N==="debug")){const R=await h.smembers(`cachly:ckg:idx:from:${T}`);for(const E of R.slice(0,10)){const j=await h.get(E);if(!j)continue;const Y=P(j,null);if(!Y||Y.edgeType!=="fixes")continue;const X=await h.smembers(`cachly:ckg:idx:from:${Y.to}`);for(const oe of X.slice(0,5)){const re=await h.get(oe);if(!re)continue;const ee=P(re,null);ee&&ee.edgeType==="co-occurs"&&(ee.successes=(ee.successes||0)+.1,ee.trials=(ee.trials||0)+.1,ee.confidence=(ee.successes+1)/(ee.trials+2),ee.last_updated=new Date().toISOString(),await h.set(oe,JSON.stringify(ee)))}}}if(Math.random()<.01){const R=Date.now()-7776e6,E=await h.smembers(`cachly:ckg:idx:from:${T}`);for(const j of E){const Y=await h.get(j);if(!Y)continue;const X=P(Y,null);X&&X.trials<3&&X.last_updated&&new Date(X.last_updated).getTime()<R&&(X.confidence=X.confidence*.9,X.last_updated=new Date().toISOString(),await h.set(j,JSON.stringify(X)))}}}catch{}if(F){h.set(`cachly:agents:active:${F}`,JSON.stringify({author:F,last_topic:t,last_outcome:o,ts:new Date().toISOString()}),"EX",3600).catch(()=>{});try{const T=t.split(":")[0]??"unknown",N=await Ze(h,Ke(F),T),B=Z(t);await ne(h,N,"authored",B,o==="success",o==="partial");for(const R of $.slice(0,8)){const E=await Ie(h,R);await ne(h,N,"touched",E,!0),await Qe(h,E,N)}}catch{}}if(f&&typeof f=="string"&&f.trim())try{const T=t.split(":")[0]??"unknown",N=c==="system"?"system":"service",B=await et(h,f.trim(),T,N),R=Z(t);if(await ne(h,R,"affects",B,o==="success",o==="partial"),F){const E=`person:${Z(Ke(F))}`;await ne(h,E,"operates",B,!0)}for(const E of $.slice(0,8)){const j=`file:${Z(E)}`;await ne(h,j,"runs_in",B,!0)}}catch{}if(F&&(o==="success"||o==="partial")){const T={topic:t,outcome:o,what_worked:m,what_failed:_??"",severity:l,author:F,file_paths:$,commands:s,tags:[...new Set([...M,"team"])],timestamp:new Date().toISOString(),recall_count:0,version:2,auto_propagated:!0},N=`cachly:lessons:${t}`;h.rpush(N,JSON.stringify(T)).catch(()=>{})}return[`${o==="success"?"\u2705":o==="partial"?"\u26A0\uFE0F":"\u274C"} **Lesson ${Q?"updated":"stored"}:** \`${t}\` (${o}) ${l==="critical"?"\u{1F534}":l==="major"?"\u{1F7E1}":"\u{1F7E2}"} ${l}`,a??"","",`**What worked:** ${m}`,_?`**What failed:** ${_}`:"",I?`**Context:** ${I}`:"",$.length>0?`**Files:** ${$.map(T=>`\`${T}\``).join(", ")}`:"",s.length>0?`**Commands:** ${s.map(T=>`\`${T}\``).join(", ")}`:"",M.length>0?`**Tags:** ${M.map(T=>`#${T}`).join(" ")}`:"","",Q?`\u267B\uFE0F Updated (recall count: ${V} \xB7 audit entries: ${n.length})`:`\u{1F4A1} Recall later with \`recall_best_solution(topic="${t}")\``,F&&(o==="success"||o==="partial")?`\u{1F465} Auto-shared with team (by _${F}_${D.quelle!=="uebergeben"?` \xB7 aus ${D.quelle}`:""}) \u2014 visible in \`team_recall\``:"",H??"",g.length>0?`\u{1F517} Depends on: ${g.map(T=>`\`${T}\``).join(", ")} \u2192 trace with \`trace_dependency\``:"",...U,...i,cs(m)??""].filter(T=>T!=="").join(`
+`)}case"recall_feedback":{const{instance_id:b}=G,t=await q(b),o=Bt(G,new Date().toISOString());if(!o.ok)return[`\u26A0\uFE0F ${o.grund}`,"","Beispiel:","```",'recall_feedback(instance_id="\u2026", query="warum bricht der Deploy ab",','  topic="ci:zeitgrenze-meldet-cancelled", helped=true, rank=0)',"```","rank=0 heisst: die Lektion stand GAR NICHT in der Antwort.","Das ist die wertvollste Rueckmeldung von allen."].join(`
+`);const S=o.eintrag,A=`cachly:wirkung:${b}`;await t.rpush(A,JSON.stringify(S));const l=(await t.lrange(A,0,-1).catch(()=>[])).map(x=>P(x,null)).filter(Boolean),$=Pt(l),s=Dt(S),M={"fehlender-treffer":"Sie half, stand aber gar nicht in der Antwort \u2014 der Topf hat sie nicht aufgenommen. Das ist der wertvollste Fall.","zu-weit-hinten":`Sie half, stand aber auf Platz ${S.platz} \u2014 die Sortierung war zu schwach.`,"falsch-und-sicher":`Sie stand auf Platz ${S.platz} und half nicht \u2014 die Sortierung war sich sicher und lag falsch.`,bestaetigung:"Sie stand vorn und half. Bestaetigung.",unauffaellig:"Half nicht und stand hinten. Sagt wenig."},g=$.trefferquote===null?"noch keine hilfreiche Rueckmeldung":`${($.trefferquote*100).toFixed(0)} % der hilfreichen Lektionen standen unter den ersten dreien`;return[`\u2705 Notiert: **${S.thema}** \u2014 ${S.geholfen?"hat geholfen":"hat nicht geholfen"}, Platz ${S.platz===0?"\u2014 (stand nicht drin)":S.platz}`,"",M[s],"",`Spur: ${$.gesamt} Rueckmeldungen, ${g}.`,`Davon: ${$.nachLehrwert["fehlender-treffer"]} nicht gefunden \xB7 ${$.nachLehrwert["zu-weit-hinten"]} zu weit hinten \xB7 ${$.nachLehrwert["falsch-und-sicher"]} falsch und sicher.`].join(`
+`)}case"recall_best_solution":{const{instance_id:b,topic:t}=G,o=await q(b);try{const s=await o.get(`cachly:letzter-recall:${b}`),M=s?P(s,null):null,g=Ot(M,t,new Date().toISOString());g&&(await o.rpush(`cachly:wirkung:${b}`,JSON.stringify(g)),await o.del(`cachly:letzter-recall:${b}`))}catch{}const S=await o.get(`cachly:lesson:best:${t}`);if(S){const s=P(S,null);if(!s)return`\u26A0\uFE0F Lesson data for \`${t}\` is corrupted. Re-store it with \`learn_from_attempts\`.`;const M=ge(s),g=s.verified_at??s.ts,x=(Date.now()-new Date(g).getTime())/864e5,v=Ye(M,x),f=new Date().toISOString(),c={...s,recall_count:(s.recall_count??0)+1,verified_at:f,last_recalled_at:f,confidence:1};await o.set(`cachly:lesson:best:${t}`,JSON.stringify(c)),He(o);const k=Re(s)?Ee(s):0;k>0&&o.incrbyfloat(`cachly:stats:time_saved_mins:${b}`,k).catch(()=>{});const m=s.severity==="critical"?"\u{1F534}":s.severity==="major"?"\u{1F7E1}":s.severity?"\u{1F7E2}":"",_=(s.audit_trail??[]).length>1?`_Audit: ${(s.audit_trail??[]).length} changes \xB7 stored ${new Date(s.ts).toLocaleDateString("de-DE")}_`:"",I=(Date.now()-new Date(s.ts).getTime())/864e5,h=I>60?`\u{1F4AD} _Remember when you solved this ${Math.round(I/30)} months ago? Still works._`:"",e=c.recall_count===3&&!s.pinned?"\u{1F4CC} **You've looked this up 3 times.** Consider pinning it for instant access: add `pinned: true` via `learn_from_attempts` to always surface it first.":"",D=s.authors??(s.author?[s.author]:[]),O=[...new Set(D.filter(Boolean))],F=c.recall_count;let H="";return O.length>=2&&F>=5?H=`\u{1F3C6} **Battle-tested** \u2014 recalled ${F}\xD7 \xB7 verified by ${O.length} developers. Trust this.`:F>=10?H=`\u{1F3C6} **Battle-tested** \u2014 recalled ${F}\xD7. This is one of your most-proven solutions.`:O.length>=2?H=`\u2705 **Team-verified** \u2014 confirmed by ${O.length} developers.`:F>=5&&(H=`\u2705 **Proven** \u2014 recalled ${F}\xD7 without contradiction.`),[h,H,`${v} **Best solution for \`${t}\`** ${m}${s.severity?` (${s.severity})`:""} \xB7 recalled ${c.recall_count}\xD7`,"",s.what_worked?`**What worked:** ${s.what_worked}`:"",s.what_failed?`**What failed (avoid this):** ${s.what_failed}`:"",s.context?`**Context:** ${s.context}`:"",(s.file_paths??[]).length>0?`**Files:** ${(s.file_paths??[]).map(W=>`\`${W}\``).join(", ")}`:"",(s.commands??[]).length>0?`**Commands:** ${(s.commands??[]).map(W=>`\`${W}\``).join(", ")}`:"",(s.tags??[]).length>0?`**Tags:** ${(s.tags??[]).map(W=>`#${W}`).join(" ")}`:"",_,e].filter(W=>W!=="").join(`
+`)}const A=[],p=o.scanStream({match:"cachly:lesson:best:*",count:100});await new Promise((s,M)=>{p.on("data",g=>A.push(...g)),p.on("end",s),p.on("error",M)});const l=A.filter(s=>s.toLowerCase().includes(t.toLowerCase()));if(l.length===0){const s=`cachly:lessons:${t}`,M=await o.lrange(s,-3,-1);if(M.length>0){const x=M.map(v=>P(v,null)).filter(Boolean).map(v=>`- ${v.outcome==="success"?"\u2705":"\u274C"} ${v.what_worked.slice(0,120)} (${new Date(v.ts).toLocaleDateString("de-DE")})`);return`\u26A0\uFE0F No successful solution for \`${t}\` yet. Last attempts:
+
+${x.join(`
+`)}`}return`\u{1F4ED} No lessons found for \`${t}\`. Use \`learn_from_attempts\` after solving it.`}const $=[];for(const s of l.slice(0,5)){const M=await o.get(s);if(!M)continue;const g=P(M,null);g&&$.push(`**\`${g.topic}\`** \u2014 ${g.what_worked.slice(0,200)}`)}return`\u{1F50D} **Partial matches for \`${t}\`:**
+
+${$.join(`
+
+`)}`}case"smart_recall":{const{instance_id:b,query:t,threshold:o=.78,author:S="",context_files:A=[]}=G,p=Array.isArray(A)?A.filter(a=>typeof a=="string"):[],l=await q(b);let $=new Set,s=!1;S&&($=await dt(l,b,S).catch(()=>new Set),s=await Be(l,b,S).catch(()=>null)==="admin");const M=await Pe(l,["cachly:ctx:*","cachly:lesson:best:*","cachly:idx:*"],t,25),g=_t(M);let x=!1;const v=await(async()=>{if(!we())return fe(ot,"kein Einbettungsdienst eingerichtet \u2014 die Suche laeuft nur ueber Woerter"),g;try{if(await ue.aktualisiere(l),ue.groesse===0)return fe(nt,"keine einzige Lektion hat eine Einbettung \u2014 die Suche laeuft nur ueber Woerter. Nachruesten mit eingaenge-nachruesten, pruefen mit brain_doctor"),g;const a=await pe(t);if(!a?.length)return fe(at,"die Frage liess sich nicht einbetten \u2014 diese Suche laeuft nur ueber Woerter"),g;await xe.aktualisiere(l),await Te.aktualisiere(l),await _e.aktualisiere(l);const d=g.filter(K=>K.key.startsWith("cachly:lesson:best:")).map(K=>K.key.slice(19)),w=K=>Math.max(ue.naehe(a,K),xe.naehe(a,K)),z=[..._e.themen()],T=(z.length>0?z:ue.aehnlichste(a,500).map(K=>K.topic)).map(K=>({t:K,n:w(K)})).sort((K,ie)=>ie.n-K.n).slice(0,zt).map(K=>K.t),N=[...new Set([...d,...T])],B=T.slice(0,3).map(K=>ue.rohvektor(K)).filter(Boolean),R=B.length?Et(a,B):a,E=Fe(t),j=_e.statistik,Y=N.map(K=>({naeheText:ue.naehe(a,K),naeheThema:xe.naehe(a,K),naeheRueckkopplung:ue.naehe(R,K),seltenheitsDeckung:j?j.deckung(E,new Set([...Fe(_e.textVon(K))].map(Rt))):0}));let X=At(Y,Lt);if(Te.groesse>0){const K=N.map(he=>{const le=Te.besteNaehe(a,he);return le>=Kt?le:-2}),ie=It(K);X=X.map((he,le)=>he+Gt*ie[le])}const oe=N.map((K,ie)=>({t:K,p:X[ie]})).sort((K,ie)=>ie.p-K.p).map(K=>K.t),re=new Map(g.map(K=>[K.key,K])),ee=[];for(const K of oe){const ie=`cachly:lesson:best:${K}`,he=re.get(ie);if(he){ee.push(he),re.delete(ie);continue}const le=await l.get(ie).catch(()=>null);le&&ee.push({key:ie,content:le,score:0,matchedWords:[],finalScore:0,qualityBoost:1})}return ee.push(...re.values()),x=!0,ee}catch(a){return await st(l,it,`der Bedeutungspfad brach ab (${a instanceof Error?a.message:String(a)}) \u2014 diese Suche lief nur ueber Woerter`),g}})();if(He(l),we()){const a=v.filter(d=>d.key.startsWith("cachly:lesson:best:")).slice(0,3).map(d=>d.key.slice(19));Nt(l,t,a,pe).catch(()=>{})}const f=[],c=v.filter(a=>a.key.startsWith("cachly:lesson:best:"));let k=0,m=0;for(const a of c.slice(0,5)){const d=await l.get(a.key).catch(()=>null);if(d){const w=P(d,null);if(w?.state==="archived")continue;if(w){const z=new Date().toISOString(),T={...w,recall_count:(w.recall_count??0)+1,verified_at:z,last_recalled_at:z};l.set(a.key,JSON.stringify(T)).catch(()=>{});const N=Re(w)?Ee(w):0;if(N>0&&l.incrbyfloat(`cachly:stats:time_saved_mins:${b}`,N).catch(()=>{}),l.incr(`cachly:stats:recalls_total:${b}`).catch(()=>{}),w.author&&S&&w.author!==S){k++,l.incr(`cachly:stats:cross_author_recalls:${b}`).catch(()=>{}),l.sadd(`cachly:stats:reuse_pairs:${b}`,`${S}<-${w.author}`).catch(()=>{});const B=`person:${Z(S)}`,R=`person:${Z(w.author)}`;ne(l,B,"collaborates",R,!0).catch(()=>{}),ne(l,R,"collaborates",B,!0).catch(()=>{})}w.outcome==="success"&&m++,w.outcome==="success"&&(w.recall_count??0)>=1&&!ye(w)&&f.push({topic:a.key.replace("cachly:lesson:best:",""),severity:w.severity??"major",recall_count:(w.recall_count??0)+1,savedMins:N,ts:w.ts,author:w.author})}}}m>0&&l.set(`cachly:stats:first_recall_at:${b}`,new Date().toISOString(),"EX",365*86400,"NX").catch(()=>{});const _=await ae(`/api/v1/instances/${b}`).catch(()=>null),I=!_?.tier||_.tier.toLowerCase()==="free",h=[];if(!I&&_?.vector_token&&we())try{const a=await pe(t),d=`https://api.cachly.dev/v1/sem/${_.vector_token}`,w=await fetch(`${d}/search`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({embedding:a,namespace:"cachly:ctx",threshold:o,top_k:5}),signal:AbortSignal.timeout(8e3)});if(w.ok){const z=await w.json();for(const T of z.filter(N=>N.found&&N.id)){const N=T.id.replace("ctx:","").split(":"),B=N[0],R=N.slice(1).join(":"),E=`cachly:ctx:${B}:${R}`,j=await l.get(E).catch(()=>null);h.push({key:E,similarity:T.similarity??0,content:j??"(evicted)"})}}}catch{}const e=v.map(a=>a.score),D=e.length?Math.min(...e):0,O=e.length&&Math.max(...e)-D||1,F=a=>(a-D)/O,H=new Map;for(const a of v){const d=F(a.score);H.set(a.key,{key:a.key,content:a.content,bm25Score:d,hybridScore:d*(h.length>0?.7:1),matchedWords:a.matchedWords,matchType:"keyword",subQuery:a.subQuery})}for(const a of h){const d=H.get(a.key);d?(d.semScore=a.similarity,d.hybridScore=(d.bm25Score??0)*.6+a.similarity*.4,d.matchType="hybrid"):H.set(a.key,{key:a.key,content:a.content,semScore:a.similarity,hybridScore:a.similarity*.5,matchType:"semantic"})}try{const a=Se(t).filter(z=>z.length>=4).slice(0,4),d=new Set;for(const z of a){const T=l.scanStream({match:`cachly:ckg:node:*${z}*`,count:20});await new Promise((N,B)=>{T.on("data",R=>{for(const E of R.slice(0,5))d.add(E.replace("cachly:ckg:node:",""))}),T.on("end",N),T.on("error",B)})}const w=new Set;for(const z of[...d].slice(0,12)){const T=await l.smembers(`cachly:ckg:idx:to:${z}`);for(const N of T.slice(0,6)){const B=await l.get(N);if(!B)continue;const R=P(B,null);if(!R||R.edgeType!=="fixes"||R.confidence<.35||w.has(R.from))continue;w.add(R.from);const E=`cachly:lesson:best:${R.from}`,j=H.get(E);if(j)j.ckgScore=Math.max(j.ckgScore??0,R.confidence),j.hybridScore=j.hybridScore*.88+R.confidence*.12,j.matchType==="keyword"&&(j.matchType="hybrid");else{const Y=await l.get(E).catch(()=>null);if(!Y)continue;H.set(E,{key:E,content:Y,ckgScore:R.confidence,hybridScore:R.confidence*.3,matchType:"ckg"})}}}}catch{}if(p.length>0){const a=new Set(p.map(d=>d.replace(/\\/g,"/")));for(const d of H.values()){if(!d.key.startsWith("cachly:lesson:best:"))continue;const w=P(d.content,{});(Array.isArray(w.file_paths)?w.file_paths.filter(T=>typeof T=="string").map(T=>T.replace(/\\/g,"/")):[]).some(T=>a.has(T))&&(d.hybridScore*=1.15,d.contextBoost=!0)}}for(const a of H.values()){if(a.matchType!=="semantic"&&a.matchType!=="ckg")continue;const d=$t({key:a.key,content:a.content});d&&(a.hybridScore*=bt(d))}const W=[...H.values()].filter(a=>{if(!a.key.startsWith("cachly:lesson:best:"))return!0;const d=P(a.content,{});return!(d.visibility==="private"||!ft(d.group,$,s))}).sort((a,d)=>d.hybridScore-a.hybridScore),J=rt();let U="",Q=null;if(J!==null){U=ct();const a=W[0]?.hybridScore??0,d=lt(W.map(w=>({key:w.key,content:w.content,punktzahl:w.hybridScore})),U,J,a);d.weggelassenesThema!==void 0?W.splice(0,1):d.markierungGesetzt&&W[0]&&d.treffer[0]&&(W[0]={...W[0],content:d.treffer[0].content}),Q={frage:t,hoechstePunktzahl:a,themen:[],zulassungsfaehig:d.zulassungsfaehig,zulassungsGrund:d.zulassungsGrund,zuteilung:d.zuteilung,weggelassenesThema:d.weggelassenesThema,markierungGesetzt:d.markierungGesetzt}}const V=await Je(b,ae),se=V.reached,n=ze({ueberLimit:se,gesamt:W.length,volleTiefe:Ht}),y=n.sichtbar,i=[`\u{1F9E0} **Smart Recall** for: _"${t}"_
+`];V.goodwillMessage&&i.push(`${V.goodwillMessage}
+`);const u={critical:0,major:1,minor:2},r=f.sort((a,d)=>(u[a.severity]??1)-(u[d.severity]??1))[0];if(r){const a=N=>N>=60?`${N/60}h`:`${N}min`,d=(()=>{if(!r.ts)return null;const N=new Date(r.ts);if(isNaN(N.getTime()))return null;const B=new Date,R=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];return N.getFullYear()===B.getFullYear()?`${N.getDate()} ${R[N.getMonth()]}`:`${N.getDate()} ${R[N.getMonth()]} ${N.getFullYear()}`})(),w=r.severity==="critical"?120:r.severity==="major"?60:20,z=r.author&&r.author!==S?` \xB7 by @${r.author}`:"",T=d?` \xB7 learned ${d} (was a ${a(w)} debug)`:"";i.push(`> \u{1F4A1} **Brain saved you ~${a(r.savedMins)} here** \u2014 \`${r.topic}\`${T} \xB7 recalled ${r.recall_count}\xD7${z}
+`)}k>0&&i.push(`> \u{1F465} **Team knowledge reuse** \u2014 ${k} of these lesson${k!==1?"s were":" was"} written by a teammate. This is the value only a shared brain delivers.
+`);const C=W.filter(a=>a.contextBoost).length;C>0&&i.push(`> \u{1F4C1} **Personalized** \u2014 ${C} lesson${C!==1?"s":""} boosted because ${C!==1?"they match":"it matches"} your current file context (${p.slice(0,3).join(", ")}${p.length>3?", \u2026":""})
+`);const L=yt(t);if(L.length>1&&i.push(`_Detected ${L.length} sub-topics:_ ${L.map((a,d)=>`${d+1}. "${a}"`).join(", ")}
+`),W.length>0){const a=W.some(w=>w.ckgScore!==void 0),d=h.length>0&&a?"keyword + semantic + CKG hybrid":h.length>0?"keyword + semantic hybrid":a?"keyword + CKG hybrid":"keyword";if(i.push(`### \u{1F50D} Results (${W.length} \u2014 ${d})
+`),L.length>1){const w=new Map,z=ze({ueberLimit:se,gesamt:W.length,volleTiefe:Jt});for(const B of W.slice(0,z.sichtbar)){const R=B.subQuery??t;w.has(R)||w.set(R,[]),w.get(R).push(B)}for(const[B,R]of w){i.push(`**Topic: "${B}"** (${R.length} results)
+`);for(const E of R.slice(0,4)){const j=E.key.replace("cachly:ctx:","\u{1F4DD} ").replace("cachly:lesson:best:","\u{1F4A1} ").replace("cachly:idx:","\u{1F4C2} "),Y=E.matchType==="ckg"?`CKG: ${(E.ckgScore??0).toFixed(2)}, \u{1F578}\uFE0F causal graph`:E.ckgScore!==void 0&&E.bm25Score!==void 0?`BM25: ${E.bm25Score.toFixed(2)}, CKG: ${E.ckgScore.toFixed(2)}, \u{1F500} hybrid`:E.matchType==="hybrid"?`BM25: ${(E.bm25Score??0).toFixed(2)}, sem: ${((E.semScore??0)*100).toFixed(0)}%, \u{1F500} hybrid`:E.matchType==="semantic"?`sem: ${((E.semScore??0)*100).toFixed(0)}%, \u{1F3AF} semantic`:`BM25: ${(E.bm25Score??0).toFixed(2)}, matched: ${E.matchedWords?.join(", ")}`,X=Le(E.key,E.content,300);if(i.push(`  **${j}** _(${Y})_`),E.key.startsWith("cachly:lesson:best:")){const oe=await l.get(E.key.replace("lesson:best:","lesson:human:")).catch(()=>null)??await l.get(E.key.replace("cachly:lesson:best:","lesson:human:")).catch(()=>null),re=oe?P(oe,{}):{};re.title&&i.push(`  \u{1F4D6} **${re.title}** \u2014 ${re.summary??""}`)}for(const oe of X)i.push(`  > ${oe}`);i.push("")}}const T=[...w.keys()],N=L.filter(B=>!T.includes(B));N.length>0&&i.push(`
+\u26A0\uFE0F **No results for:** ${N.map(B=>`"${B}"`).join(", ")}`)}else for(const w of W.slice(0,y)){const z=w.key.replace("cachly:ctx:","\u{1F4DD} ").replace("cachly:lesson:best:","\u{1F4A1} ").replace("cachly:idx:","\u{1F4C2} ");let T="";if(w.key.startsWith("cachly:lesson:best:")){const E=P(w.content,{});E.author&&(T=` \xB7 \u{1F464} ${E.author}`)}const N=w.contextBoost?" \xB7 \u{1F4C1} context match":"",B=w.matchType==="hybrid"?`BM25: ${(w.bm25Score??0).toFixed(2)}, sem: ${((w.semScore??0)*100).toFixed(0)}%, \u{1F500} hybrid`:w.matchType==="semantic"?`sem: ${((w.semScore??0)*100).toFixed(0)}%, \u{1F3AF} semantic`:`BM25: ${(w.bm25Score??0).toFixed(2)}, matched: ${w.matchedWords?.join(", ")}`,R=Le(w.key,w.content,400);if(i.push(`**${z}**${T}${N} _(${B})_`),w.key.startsWith("cachly:lesson:best:")){const E=await l.get(w.key.replace("lesson:best:","lesson:human:")).catch(()=>null)??await l.get(w.key.replace("cachly:lesson:best:","lesson:human:")).catch(()=>null),j=E?P(E,{}):{};j.title&&i.push(`\u{1F4D6} **${j.title}** \u2014 ${j.summary??""}`)}for(const E of R)i.push(`> ${E}`);i.push("")}if(se&&n.zurueckgehalten>0){const w=n.zurueckgehalten;i.push(`\u{1F512} **Free recall limit reached** (${V.used}/${V.limit} this month). Showing your top match; ${w} further relevant lesson${w!==1?"s are":" is"} withheld. Your limit resets next month, or unlock your full Brain now \u2192 ${ps}
+`)}}else{i.push(`\u26A0\uFE0F No matches found for: "${t}"`);const a=Se(t),d=[];if(De.size>0&&a.length>0)for(const w of a.slice(0,3)){if(w.length<4)continue;let z=3,T="";for(const N of De){if(N.length<3||Math.abs(N.length-w.length)>4)continue;const B=wt(w,N);B>0&&B<z&&(z=B,T=N)}T&&d.push(`"${T}" (instead of "${w}")`)}d.length>0?i.push(`\u{1F4A1} **Did you mean:** ${d.join(", ")}?`):(i.push(`
+\u{1F4A1} Tips:`),i.push("  \u2022 Try different keywords"),i.push("  \u2022 Use `list_remembered` to see available context"),i.push('  \u2022 Use `recall_best_solution("topic")` for exact topic lookup'))}if(W.length>0){i.push(""),i.push("\u21A9\uFE0E Hat eine davon geholfen? `recall_feedback(query=\u2026, topic=\u2026, helped=true, rank=N)` \u2014 und wenn die richtige Lektion **nicht** dabei war: dieselbe Meldung mit `rank=0`. Das ist die einzige Zahl, die die Sortierung besser macht.");const a=W.filter(d=>d.key.startsWith("cachly:lesson:best:")).map(d=>d.key.slice(19));if(a.length>0)try{await l.setex(`cachly:letzter-recall:${b}`,7200,JSON.stringify({frage:t,themen:a}))}catch{}}if(J!==null&&Q){const a=W.slice(0,y).filter(d=>d.key.startsWith("cachly:lesson:best:")).map(d=>d.key.slice(19));return ut(l,U,{...Q,themen:a},i.join(`
+`))}return i.join(`
+`)}case"session_start":{const{instance_id:b,focus:t="",author:o="",provider:S="",workspace_path:A=""}=G,p=await q(b),l=[],$=p.scanStream({match:"cachly:lesson:best:*",count:200});await new Promise((n,y)=>{$.on("data",i=>l.push(...i)),$.on("end",n),$.on("error",y)});const s=[];if(l.length>0){const n=await p.mget(...l);for(const y of n){const i=P(y??null,null);i&&s.push(i)}}s.sort((n,y)=>new Date(y.ts).getTime()-new Date(n.ts).getTime());let M=0;const g=p.scanStream({match:"cachly:ctx:*",count:200});await new Promise((n,y)=>{g.on("data",i=>{M+=i.filter(u=>!u.endsWith(":meta")).length}),g.on("end",n),g.on("error",y)});const x=await p.get("cachly:session:last"),v=P(x,null),f=t.toLowerCase().split(/\s+/).filter(Boolean),c=f.length>0?s.filter(n=>f.some(y=>n.topic.toLowerCase().includes(y)||(n.tags??[]).some(i=>i.toLowerCase().includes(y)))):[];let k=0,m=0,_="";try{const n=await p.get("cachly:streak:current"),y=P(n,null),i=new Date().toISOString().slice(0,10);if(y){const u=y.last_date,r=new Date(Date.now()-864e5).toISOString().slice(0,10);u===i?(k=y.days,m=y.record):u===r?(k=y.days+1,m=Math.max(k,y.record),await p.set("cachly:streak:current",JSON.stringify({days:k,last_date:i,record:m}))):(k=1,m=y.record,await p.set("cachly:streak:current",JSON.stringify({days:1,last_date:i,record:m})))}else k=1,m=1,await p.set("cachly:streak:current",JSON.stringify({days:1,last_date:i,record:1}));k>=7?_=`\u{1F525} **${k}-day streak!** ${k===m?" New record!":`Best: ${m}d`}`:k>1&&(_=`\u{1F525} ${k}-day streak`)}catch{}await p.set("cachly:session:current",JSON.stringify({started:new Date().toISOString(),focus:t,provider:S}),"EX",86400);let I=0;try{const n=await p.get(`cachly:stats:time_saved_mins:${b}`);I=parseFloat(n??"0")}catch{}const e=[`\u{1F9E0} **Session Briefing**${S?` \xB7 ${S}`:""}`,""];if(_&&e.push(_,""),I>=30){const n=Math.floor(I/60),y=Math.round(I%60),i=n>0?`${n}h${y>0?` ${y}m`:""}`:`${y}m`,u=s.filter(C=>!ye(C)&&(C.recall_count??0)>0).length,r=u>0?` \u2014 ${u} of your own lessons that already helped, counted once each`:" (time not re-researching known fixes)";e.push(`\u23F1\uFE0F **Brain saved you ~${i} total**${r}`,"")}const D=await Je(b,ae),O=qt({used:D.used,limit:D.limit,savedMins:I});if(O&&e.push(O,""),D.notice&&!qe.has(b)&&(qe.add(b),e.push(D.notice,"")),v?.ts){const n=new Date(v.ts).getTime(),y=Math.floor((Date.now()-n)/864e5);if(y>=7&&!Number.isNaN(n)){const i=s.filter(u=>{const r=new Date(u.ts).getTime();return!Number.isNaN(r)&&r>n});if(e.push(`\u{1F44B} **Welcome back** \u2014 it's been ${y} days since your last session.`),i.length>0){const u=i.slice(0,3).map(r=>`\`${r.topic}\``).join(", ");e.push(`   \u{1F331} Your Brain grew by **${i.length} lesson${i.length!==1?"s":""}** while you were gone (git, CI & teammates kept it learning): ${u}${i.length>3?", \u2026":""}`)}else e.push(`   \u{1F9E0} ${s.length} lesson${s.length!==1?"s":""} held steady and ready \u2014 recall anything with \`smart_recall\`.`);e.push("   \u{1F4A1} Full breakdown: `npx @cachly-dev/mcp-server@latest digest`","")}}try{if(await p.get("cachly:mcp:version:last_seen")!==be){await p.set("cachly:mcp:version:last_seen",be,"EX",365*86400);const y=fs[be];if(y){e.push(...y,"");const i=ds();i&&e.push(`\u{1F4CA} ${i} MCP tools`,"")}}}catch{}const F=!v&&s.length===0&&M===0;if(F&&(e.push("\u{1F389} **Welcome! Your AI Brain is live.**",""),A?(e.push("\u{1F680} **Auto-bootstrapping from your git history...** (this takes a few seconds)"),e.push("   Your brain will learn from your recent commits \u2014 no setup needed.","")):(e.push("It learns from your work automatically. After your first session it will look like this:",""),e.push("  \u2705 `api:auth` \u2014 Bearer token in header, not cookie; 401 on missing scope"),e.push("  \u2705 `database:migrations` \u2014 always run migrations before deploy"),e.push("  \u26A0\uFE0F `docker:build` \u2014 ARG changes bust all subsequent cache layers"),e.push(""),e.push("**Tip:** Pass `workspace_path` to `session_start` to auto-learn from git history instantly."),e.push("")),e.push("**Your brain grows automatically:**"),e.push('  \u2022 End each session \u2192 `session_end(summary="What I did")` \u2014 auto-learns from git commits'),e.push('  \u2022 After fixing bugs \u2192 `learn_from_attempts(topic="...", outcome="success", what_worked="...")`'),e.push(""),e.push("\u{1F331} **Want answers right now?** Seed 16 universal engineering lessons so your first"),e.push("   `smart_recall` returns a hit instead of nothing:"),e.push(`   \`brain_seed_starter(instance_id="${b}")\``),e.push("   _(Docker cache, JWT skew, K8s OOM, N+1 queries, cache stampede\u2026 \u2014 never overrides your own lessons.)_"),e.push(""),e.push("\u{1F4A1} Run `brain_doctor` for a health-check and personalised tips."),e.push("")),o&&!F)try{const n=`cachly:team:first_briefing:${o}`;if(!await p.get(n)){const i=s.filter(u=>u.author&&u.author!==o);if(i.length>0){await p.set(n,"1","EX",365*86400);const u=new Map;for(const r of i){const C=r.author;u.has(C)||u.set(C,[]),u.get(C).push(r)}e.push(""),e.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"),e.push("\u{1F91D} **Your team's AI brain has been briefing you.**"),e.push(""),e.push("Your teammates have already solved problems you're about to hit:"),e.push("");for(const[r,C]of u){e.push(`  \u{1F464} **${r}** fixed ${C.length} thing${C.length>1?"s":""}:`);for(const L of C.slice(0,2)){const a=L.outcome==="success"?"\u2705":"\u26A0\uFE0F";e.push(`    ${a} \`${L.topic}\` \u2014 ${L.what_worked.slice(0,90)}`)}C.length>2&&e.push(`    \u2026 and ${C.length-2} more lessons`)}e.push(""),e.push("\u{1F4A1} Use `team_learn` after your next fix to pay it forward."),e.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"),e.push("")}}}catch{}const H=await p.get("cachly:session:handoff");if(H)try{const n=JSON.parse(H),y=Math.round((Date.now()-new Date(n.ts).getTime())/6e4),i=y<60?`${y}m ago`:y<1440?`${Math.round(y/60)}h ago`:`${Math.round(y/1440)}d ago`;if(e.push(`\u{1F91D} **Handoff from previous window** (${i}):`),n.context_summary&&e.push(`   ${n.context_summary}`),n.remaining_tasks.length>0){e.push("   \u23F3 **Remaining tasks:**");for(const r of n.remaining_tasks)e.push(`     - ${r}`)}n.completed_tasks.length>0&&e.push(`   \u2705 **Already done:** ${n.completed_tasks.join(", ")}`);const u=(n.files_changed??[]).filter(r=>r.status==="broken"||r.status==="partial");u.length>0&&e.push(`   \u26A0\uFE0F **Needs fix:** ${u.map(r=>`\`${r.path}\` (${r.status}${r.description?": "+r.description:""})`).join(", ")}`),n.blocked_on&&e.push(`   \u{1F6AB} **Blocked on:** ${n.blocked_on}`),n.instructions&&e.push(`   \u{1F4DD} **Instructions:** ${n.instructions}`),e.push("")}catch{}const W=await p.get("cachly:session:checkpoint");if(W)try{const n=JSON.parse(W),y=new Date(n.ts).getTime(),i=v?new Date(v.ts).getTime():0;if(y>i){const u=Math.round((Date.now()-y)/6e4),r=u<60?`${u}m ago`:u<1440?`${Math.round(u/60)}h ago`:`${Math.round(u/1440)}d ago`,C=n.provider?` [${n.provider}]`:"";e.push(`\u{1F4CC} **Last checkpoint**${C} (${r}): ${n.task}`),n.files_touched.length>0&&e.push(`   Files: ${n.files_touched.slice(0,5).map(L=>`\`${L}\``).join(", ")}`),n.next_step&&e.push(`   \u{1F4CD} Next step was: ${n.next_step}`),(!v||y-i>3e5)&&e.push("   \u26A0\uFE0F No `session_end` found \u2014 reconstructed from last checkpoint"),e.push("")}}catch{}if(A&&!v)try{const{execSync:n}=await import("node:child_process"),y=n(`git -C "${A}" log --oneline --format="%h %s" -15 2>/dev/null`,{encoding:"utf-8",timeout:5e3}).trim(),i=n(`git -C "${A}" diff --stat HEAD~3 2>/dev/null || git -C "${A}" diff --stat 2>/dev/null`,{encoding:"utf-8",timeout:5e3}).trim();if(y){e.push("\u{1F50D} **Git reconstruction** (no session_end found \u2014 reconstructed from git):");for(const u of y.split(`
+`).slice(0,8))e.push(`   ${u}`);if(i){const u=i.split(`
+`).filter(r=>r.includes("|")||r.includes("changed"));if(u.length>0){e.push("   **Recent changes:**");for(const r of u.slice(0,5))e.push(`   ${r.trim()}`)}}e.push("")}}catch{}if(v){const n=Math.round((Date.now()-new Date(v.ts).getTime())/6e4),y=n<60?`${n}m ago`:n<1440?`${Math.round(n/60)}h ago`:`${Math.round(n/1440)}d ago`;e.push(`\u{1F4C5} **Last session** (${y}): ${v.summary}`),v.duration_min&&e.push(`   Duration: ${v.duration_min} min`),(v.files_changed??[]).length>0&&e.push(`   Files: ${(v.files_changed??[]).slice(0,5).map(i=>`\`${i}\``).join(", ")}`),e.push("")}e.push(`\u{1F4CA} **Brain:** ${s.length} lessons \xB7 ${M} context entries`,"");{const y=s.filter(i=>!ye(i)).filter(i=>i.outcome==="success"&&(i.pinned===!0||(i.recall_count??0)>=5)).sort((i,u)=>(u.recall_count??0)-(i.recall_count??0)).slice(0,5);if(y.length>0){e.push("\u{1F4CC} **Proven Laws** (auto-crystallized \u2014 your most-trusted knowledge):");for(const i of y){const u=i.severity==="critical"?"\u{1F534}":i.severity==="major"?"\u{1F7E1}":"",r=i.recall_count??0,C=i.pinned===!0?"pinned":`recalled ${r}\xD7`,L=me(i);e.push(`  \u{1F3C6}${u} \`${i.topic}\` _(${C})_ \u2014 ${L[0]??""}`,...L.slice(1))}e.push("")}}if(s.length>=3){const n=new Map;for(const u of s){const r=u.topic.split(":")[0]??"other";n.has(r)||n.set(r,{total:0,success:0,critical:0});const C=n.get(r);C.total++,u.outcome==="success"&&C.success++,u.severity==="critical"&&C.critical++}const y=[...n.entries()].sort((u,r)=>r[1].total-u[1].total).slice(0,6),i=y.some(([,u])=>u.success<u.total*.4&&u.total>=2);if(y.length>0){e.push("\u{1F5FA}\uFE0F **Knowledge Coverage:**");for(const[u,r]of y){const C=Math.round(r.success/r.total*100),L=Math.round(C/10),a="\u2588".repeat(L)+"\u2591".repeat(10-L),d=r.critical>0?" \u{1F534}":C<40&&r.total>=2?" \u26A0\uFE0F":"";e.push(`  ${a} ${u.padEnd(18)} ${String(C).padStart(3)}% (${r.success}/${r.total} confirmed)${d}`)}i&&e.push("  \u26A0\uFE0F _Some domains have contested beliefs \u2014 use `ckg_inspect` to review_"),e.push("")}}try{const n=[],y=p.scanStream({match:"cachly:ckg:conflict:*",count:50});if(await new Promise((i,u)=>{y.on("data",r=>n.push(...r)),y.on("end",i),y.on("error",u)}),n.length>0){e.push(`\u26A1 **Active belief conflicts (${n.length}):**`);for(const i of n.slice(0,3)){const u=await p.get(i);if(!u)continue;const r=P(u,null);r&&e.push(`  \u26A0\uFE0F \`${r.topic}\` \u2014 previously confirmed fix (${(r.fix_confidence*100).toFixed(0)}%, n=${r.fix_trials}) now contradicted. Use \`ckg_inspect(concept="${Z(r.topic)}")\``)}e.push("")}}catch{}if(t&&t.length>3)try{const n=t.toLowerCase().replace(/[^a-z0-9\s:_-]/g," ").split(/\s+/).filter(i=>i.length>3),y=[];for(const i of n.slice(0,6))if(!await p.exists(`cachly:ckg:node:${i}`)){const r=[],C=p.scanStream({match:`cachly:ckg:node:${i}*`,count:10});await new Promise((L,a)=>{C.on("data",d=>r.push(...d)),C.on("end",L),C.on("error",a)}),r.length===0&&y.push(i)}if(y.length>0){e.push("\u{1F52D} **Blind spots detected for this focus:**");for(const i of y.slice(0,3))e.push(`  \u2B1C \`${i}\` \u2014 no CKG knowledge. Suggestions:`),e.push(`     \u2022 \`brain_from_git(instance_id="...", concept="${i}")\` \u2014 bootstrap from commits`),e.push(`     \u2022 \`fedbrain_search(query="${i}")\` \u2014 search global commons`);e.push("")}}catch{}if(c.length>0){e.push(`\u{1F3AF} **Relevant for "${t}":**`);for(const n of c.slice(0,4)){const y=n.outcome==="success"?"\u2705":n.outcome==="partial"?"\u26A0\uFE0F":"\u274C",i=n.severity==="critical"?"\u{1F534}":n.severity==="major"?"\u{1F7E1}":"",u=me(n);e.push(`  ${y}${i} \`${n.topic}\` \u2014 ${u[0]??""}`,...u.slice(1))}e.push("")}if(s.length>0){const y=[...s].filter(u=>!ye(u)).sort((u,r)=>(r.recall_count??0)-(u.recall_count??0)).filter(u=>(u.recall_count??0)>0).slice(0,3),i=(c.length>0?s.filter(u=>!c.includes(u)):s).filter(u=>!y.includes(u)).slice(0,c.length>0?3:4);if(y.length>0){e.push(`\u{1F3C6} **Most valuable** (recalled ${y[0].recall_count}\xD7 before):`);for(const u of y){const r=u.outcome==="success"?"\u2705":u.outcome==="partial"?"\u26A0\uFE0F":"\u274C",C=u.severity==="critical"?"\u{1F534}":u.severity==="major"?"\u{1F7E1}":"",L=u.recall_count??0,a=u.authors??(u.author?[u.author]:[]),d=new Set(a.filter(Boolean)).size,w=d>=2&&L>=5||L>=10?" \u{1F3C6}":d>=2||L>=5?" \u2705":"",z=L>1?` _(${L}\xD7 recalled)_`:"",T=me(u);e.push(`  ${r}${C}${w} \`${u.topic}\`${z} \u2014 ${T[0]??""}`,...T.slice(1))}e.push("")}if(i.length>0){const u=y.length>0?"\u{1F550} **Recent:**":"\u{1F550} **Recent lessons:**";e.push(u);for(const r of i){const C=r.outcome==="success"?"\u2705":r.outcome==="partial"?"\u26A0\uFE0F":"\u274C",L=r.severity==="critical"?"\u{1F534}":r.severity==="major"?"\u{1F7E1}":"",a=me(r);e.push(`  ${C}${L} \`${r.topic}\` \u2014 ${a[0]??""}`,...a.slice(1))}e.push("")}}else e.push("\u{1F4ED} No lessons yet. Use `learn_from_attempts` after solving tasks.","");s.length>=10&&(s.some(y=>y.author)||(e.push(`\u{1F91D} **Your Brain has ${s.length} lessons \u2014 your team could benefit instantly.**`),e.push("   Share: **cachly.dev/team** \xB7 or run `team_learn` after the next fix.","")));const J=s.filter(n=>n.outcome==="failure"||n.outcome==="partial");if(J.length>0){e.push(`\u26A0\uFE0F **Unresolved** (${J.length} topic${J.length>1?"s":""} with no success yet):`);for(const n of J.slice(0,3))e.push(`  \u274C \`${n.topic}\` \u2014 ${(n.what_failed??n.what_worked).slice(0,80)}`);e.push("")}const U=s.filter(n=>n.outcome!=="success"&&n.outcome!=="partial"?!1:ge(n)<Ae);if(U.length>0){e.push(`\u{1F534} **Stale lessons** (not recalled in >${Xe}d \u2014 verify before applying):`);for(const n of U.slice(0,4)){const y=ge(n),i=Math.round((Date.now()-new Date(n.verified_at??n.ts).getTime())/864e5),u=y<Ve?"\u{1F534}":"\u26A0\uFE0F";e.push(`  ${u} \`${n.topic}\` \u2014 ${i}d stale, ${(y*100).toFixed(0)}% confidence`)}e.push("  _Run `recall_best_solution` on these to reset their confidence clock._"),e.push("")}const Q=v;if(Q?.decision_log?.length){const n=Q.decision_log,y=n.filter(u=>u.outcome==="success"),i=n.filter(u=>u.outcome==="failure");e.push(`\u{1F3AC} **Last session decisions** (${n.length} lessons stored):`),y.length>0&&e.push(`  \u2705 Worked: ${y.slice(0,3).map(u=>`\`${u.topic}\``).join(", ")}`),i.length>0&&e.push(`  \u274C Failed: ${i.slice(0,3).map(u=>`\`${u.topic}\``).join(", ")}`),e.push("")}{const n=new Set(["src","lib","test","tests","dist","index","main","app","internal","pkg","cmd","node_modules","components","utils","ts","tsx","js","jsx","go","py","rs","java","json","yaml","yml"]),y=C=>{const L=new Set;for(const a of C)for(const d of a.toLowerCase().split(/[/\\._-]/))d.length>3&&!n.has(d)&&L.add(d);return[...L]};let i=f,u=t,r=!1;if(i.length===0&&v){const C=y(v.files_changed??[]),L=(v.summary??"").toLowerCase().replace(/[^a-z0-9\s:_-]/g," ").split(/\s+/).filter(a=>a.length>3&&!n.has(a));i=[...new Set([...C,...L])],u="where you left off last session",r=!0}if(i.length>0){const C=s.filter(L=>{if(L.outcome==="success")return!1;const a=L.topic.split(":")[0];return i.some(d=>L.topic.toLowerCase().includes(d)||a===d||(L.tags??[]).some(w=>w.toLowerCase()===d))});if(C.length>=1){const a=["\u{1F6A8} **PRE-WARNING** \u2014 Read this BEFORE starting:",r?`  You're likely to continue **${u}** \u2014 ${C.length} known pitfall${C.length>1?"s":""} there:`:`  Known pitfalls for **"${u}"** (${C.length} past failure${C.length>1?"s":""}):`,...C.slice(0,3).map(d=>`  \u274C \`${d.topic}\` \u2014 ${(d.what_failed??d.what_worked).slice(0,80)}`),""];e.splice(2,0,...a)}}}if(o){const n=Date.now()-6048e5,y=s.filter(i=>i.author&&i.author!==o&&new Date(i.ts).getTime()>n);if(y.length>0){const i=new Map;for(const u of y){const r=u.author;i.has(r)||i.set(r,[]),i.get(r).push(u)}e.push(`\u{1F465} **Team this week** (${y.length} lesson${y.length>1?"s":""} from teammates):`);for(const[u,r]of i){e.push(`  \u{1F464} **${u}**:`);for(const C of r.slice(0,3)){const L=C.outcome==="success"?"\u2705":C.outcome==="partial"?"\u26A0\uFE0F":"\u274C";e.push(`    ${L} \`${C.topic}\` \u2014 ${C.what_worked.slice(0,80)}`)}r.length>3&&e.push(`    \u2026 and ${r.length-3} more`)}e.push("")}}try{const n=await p.get("cachly:crystal:latest");if(n){const y=P(n,null);if(y&&Math.round((Date.now()-new Date(y.ts).getTime())/864e5)<=90){e.push(`\u{1F48E} **Memory Crystal** (${y.label} \xB7 ${y.session_count} sessions compressed):`);for(const u of y.top_patterns.slice(0,3))e.push(`  \u2022 **${u.category}** (${u.count}\xD7): ${u.insight.slice(0,90)}`);e.push("")}}}catch{}try{const n=await p.hgetall(`cachly:roadmap:${b}`);if(n&&Object.keys(n).length>0){const y={critical:0,high:1,medium:2,low:3},i={critical:"\u{1F534}",high:"\u{1F7E0}",medium:"\u{1F7E1}",low:"\u{1F535}"},u=new Set(["planned","in-progress","blocked"]),r=Object.values(n).flatMap(a=>{const d=P(a,null);return d?[d]:[]}),C=r.filter(a=>u.has(a.status)).sort((a,d)=>a.status==="in-progress"&&d.status!=="in-progress"?-1:d.status==="in-progress"&&a.status!=="in-progress"?1:(y[a.priority]??99)-(y[d.priority]??99)),L=r.filter(a=>a.status==="done").length;if(C.length>0){e.push(`\u{1F5FA}\uFE0F **Roadmap** (${C.length} open \xB7 ${L} done):`);for(const a of C.slice(0,5)){const d=a.status==="in-progress"?"\u26A1":a.status==="blocked"?"\u{1F6AB}":"\u{1F4CB}";e.push(`  ${d} ${i[a.priority]??"\u26AA"} \`${a.id}\` **${a.title}**`)}C.length>5&&e.push(`  \u2026 and ${C.length-5} more`),e.push("  _Use `roadmap_next` for the top priority item \xB7 `roadmap_list` for full view_"),e.push("")}}}catch{}if(t&&t.length>3)try{const n=t.toLowerCase().replace(/[^a-z0-9\s\-_:]/g," ").split(/\s+/).filter(r=>r.length>2).slice(0,5),y=[];for(const r of n){const C=[],L=p.scanStream({match:`cachly:ckg:node:*${r}*`,count:20});await new Promise((a,d)=>{L.on("data",w=>C.push(...w)),L.on("end",a),L.on("error",d)});for(const a of C.slice(0,3)){const d=await p.get(a);if(!d)continue;const w=P(d,null);if(!w)continue;const z=await p.smembers(`cachly:ckg:idx:from:${w.id}`);for(const T of z.slice(0,15)){const N=await p.get(T);if(!N)continue;const B=P(N,null);if(!B||B.edgeType!=="causes"&&B.edgeType!=="co-occurs"&&B.edgeType!=="fixes"||B.confidence<.35)continue;const R=B.edgeType==="fixes"?`cachly:lesson:best:${B.from}`:`cachly:lesson:best:${B.to}`,E=await p.get(R),j=P(E,null);y.push({concept:w.id,edgeType:B.edgeType,target:B.to,confidence:B.confidence,lesson:j??void 0})}}}const i=new Set,u=y.filter(r=>{const C=`${r.concept}:${r.target}`;return i.has(C)?!1:(i.add(C),!0)}).sort((r,C)=>C.confidence-r.confidence).slice(0,4);if(u.length>0){e.push(`\u{1F52E} **Predicted risks for "${t}"** (PPE pre-fetch):`);for(const r of u){const C=Math.round(r.confidence*100),L=r.edgeType==="causes"?"\u26A1":r.edgeType==="fixes"?"\u{1F527}":"\u{1F504}";e.push(`  ${L} **${C}%** \`${r.concept}\` ${r.edgeType} \`${r.target}\``),r.lesson?.what_worked&&e.push(`     \u2705 ${r.lesson.what_worked.slice(0,110)}`)}e.push(`  _Full analysis: \`brain_predict(context="${t}")\`_`),e.push("")}}catch{}try{const n=await p.get("cachly:mcm:calibration:last"),y=P(n,null)?.ts??0;if((Date.now()-y)/864e5>=30&&s.length>=5){const u=s.filter(C=>C.outcome==="success"&&(C.recall_count??0)>0),r=s.filter(C=>(C.recall_count??0)>0);if(r.length>=3){const C=r.length>0?u.length/r.length:1,L=[],a=new Map;for(const d of r){const w=d.topic.split(":")[0]??"other";a.has(w)||a.set(w,{success:0,total:0});const z=a.get(w);z.total++,d.outcome==="success"&&z.success++}for(const[d,w]of a)w.total>=2&&w.success/w.total<.6&&L.push(d);await p.set("cachly:mcm:calibration:last",JSON.stringify({ts:Date.now(),precision:C,recalled:r.length,low_precision_domains:L})),(L.length>0||C<.7)&&(e.push(`\u{1F4D0} **MCM Calibration** (30-day pass \u2014 ${r.length} recalled lessons):`),e.push(`  Overall precision: **${(C*100).toFixed(0)}%** recalled lessons actually worked`),L.length>0&&e.push(`  \u26A0\uFE0F Low-precision domains: ${L.map(d=>`\`${d}\``).join(", ")} \u2014 consider revisiting these lessons`),e.push("  \u{1F4A1} Use `learn_from_attempts` to update stale lessons and improve accuracy."),e.push(""))}await p.set("cachly:mcm:calibration:last",JSON.stringify({ts:Date.now(),precision:1,recalled:0}),"EX",35*86400)}}catch{}try{const n=await ae("/api/v1/syndication/stats");n.total_lessons>0&&(e.push(`\u{1F30D} **Commons:** ${n.total_lessons.toLocaleString()} lessons \xB7 ${n.total_confirms.toLocaleString()} confirms \xB7 +${n.added_last_7_days} this week`),e.push(""))}catch{}const V=s.filter(n=>n.outcome==="failure"||n.outcome==="partial").length>0,se=s.some(n=>n.outcome==="success"&&ge(n)<Ae);if(s.length===0||V||se){const n=[];s.length===0&&n.push("brain is empty"),V&&n.push("open failures"),se&&n.push("stale lessons"),e.push(`\u{1FA7A} _Run \`brain_doctor\` to fix: ${n.join(", ")}._`)}try{if(await p.get(`cachly:prefs:auto_changelog:${b}`).catch(()=>null)!=="false"&&v?.ts&&!F){const i=new Date(v.ts).getTime();if(!Number.isNaN(i)){const u=s.filter(r=>{const C=new Date(r.ts).getTime();return!Number.isNaN(C)&&C>i});if(u.length>0){const r=Math.round((Date.now()-i)/6e4),C=r<60?`${r}m`:r<1440?`${Math.round(r/60)}h`:`${Math.round(r/1440)}d`;e.push(""),e.push(`\u{1F4CB} **${u.length} new lesson${u.length!==1?"s":""} since your last session** (${C} ago):`);const L=new Map;for(const a of u.slice(0,20)){const d=a.topic.includes(":")?a.topic.split(":")[0]:"general",w=L.get(d)??[];w.push(a),L.set(d,w)}for(const[a,d]of L){e.push(`  **${a}**`);for(const w of d){const z=w.outcome==="failure"?"\u274C":w.severity==="critical"?"\u{1F6A8}":w.severity==="major"?"\u26A0\uFE0F":"\u2705",T=(w.outcome==="failure"?w.what_failed:w.what_worked)??"";e.push(`    ${z} \`${w.topic}\`${T?` \u2014 ${T.slice(0,80)}`:""}`)}}u.length>20&&e.push(`  \u2026 and ${u.length-20} more. Call \`brain_changelog\` for the full list.`),e.push(`  _Disable auto-changelog: \`brain_set_pref(instance_id="${b}", key="auto_changelog", value="false")\`_`)}}}}catch{}return e.join(`
+`)}case"session_start_summary":{const{instance_id:b,focus:t,top_n:o=10,author:S=""}=G;if(!t||!t.trim())throw new Error("focus is required for session_start_summary");const A=Math.min(Math.max(1,Math.floor(Number(o)||10)),25),p=await q(b),l=[],$=p.scanStream({match:"cachly:lesson:best:*",count:200});await new Promise((e,D)=>{$.on("data",O=>l.push(...O)),$.on("end",e),$.on("error",D)});const s=[];if(l.length>0){const e=await p.mget(...l);for(const D of e){const O=P(D??null,null);O&&s.push(O)}}if(s.length===0)return["\u{1F9E0} Brain Summary \u2014 no lessons yet","","Your brain is empty. Use `learn_from_attempts` after solving tasks to build it up.",`\u{1F4A1} Tip: \`brain_seed_starter(instance_id="${b}")\` to bootstrap with 16 universal lessons.`].join(`
+`);const M=s.length>A,g=t.toLowerCase().split(/\s+/).filter(Boolean),x=Date.now(),v=s.map(e=>{const D=g.filter(n=>e.topic.toLowerCase().includes(n)).length,O=g.filter(n=>(e.tags??[]).some(y=>y.toLowerCase().includes(n))).length,F=D*2+O,H=Math.max(0,e.recall_count??0),W=Math.min(1.5,Math.log1p(H)/10),J=e.severity==="critical"?1:e.severity==="major"?.5:0,U=(x-new Date(e.verified_at??e.ts).getTime())/864e5,Q=U<30?.5*(1-U/30):0,V=e.outcome==="success"?.5:e.outcome==="partial"?.2:0,se=F+W+J+Q+V;return{lesson:e,score:se}});v.sort((e,D)=>D.score!==e.score?D.score-e.score:new Date(D.lesson.ts).getTime()-new Date(e.lesson.ts).getTime());const f=(M?v.slice(0,A):v).map(e=>e.lesson),c=s.length,k=f.length,I=[M?`\u{1F9E0} Brain Summary \u2014 top ${k} of ${c} lessons for "${t}"`:`\u{1F9E0} Brain Summary \u2014 all ${k} lesson${k!==1?"s":""} for "${t}"`,"\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501",""];for(const e of f){const D=e.severity==="critical"?"\u{1F534}":e.severity==="major"?"\u26A0\uFE0F":"\u2705",O=e.severity?`[${e.severity}] `:"[minor] ",F=e.recall_count??0,H=F>0?` (\u2713 recalled ${F}\xD7)`:"",W=e.what_worked.slice(0,110),J=ls(e.author,S);I.push(`${D} ${O}\`${e.topic}\` \u2014 ${W}${H}${J}`)}I.push("");const h=us(f,S);return h>0&&I.push(`\u{1F465} ${h} of these ${h===1?"was":"were"} written by a teammate \u2014 the value only a shared brain delivers.`,""),M?I.push(`\u{1F4A1} Showing top ${k} of ${c} lessons \xB7 \`session_start\` for full briefing`):I.push(`\u{1F4A1} All ${k} lesson${k!==1?"s":""} shown \xB7 \`session_start\` for full briefing`),I.join(`
+`)}case"session_end":{const{instance_id:b,summary:t,files_changed:o=[],lessons_learned:S,workspace_path:A=""}=G,p=await q(b),l=new Date;let $;const s=await p.get("cachly:session:current");if(!s)return"\u26A0\uFE0F No active session found.\n\nRun `session_start` first to begin tracking a session, then call `session_end` when you're done.";const M=P(s,null);M?.started&&($=Math.round((l.getTime()-new Date(M.started).getTime())/6e4));let g=[];try{g=(await p.lrange("cachly:session:decision-log",0,-1)).flatMap(D=>{const O=P(D,null);return O?[O]:[]}),await p.del("cachly:session:decision-log")}catch{}const x={ts:l.toISOString(),summary:t,files_changed:o,...S!==void 0?{lessons_learned:S}:{},...$!==void 0?{duration_min:$}:{},...g.length>0?{decision_log:g}:{}};await p.set("cachly:session:last",JSON.stringify(x)),await p.lpush("cachly:session:history",JSON.stringify(x)),await p.ltrim("cachly:session:history",0,49),await p.expire("cachly:session:history",90*86400),await p.del("cachly:session:current");const v=[];try{const e=/\b(fixed|deployed|added|removed|refactored|migrated|updated|resolved|implemented|improved|optimized|configured|created|deleted|disabled|enabled|discovered|found|learned|debugged|patched|upgraded|installed|tested|built|rewrote|moved|renamed|split|merged|extracted)\b/i,D=t.split(/[.!\n]+/).map(O=>O.trim()).filter(O=>O.length>20&&e.test(O));for(const O of D.slice(0,6)){const H=O.toLowerCase().replace(/[^a-z0-9\s]/g," ").split(/\s+/).filter(V=>V.length>3&&!["that","this","with","from","have","been","were","they","then","when","also","into","will","would","could","should"].includes(V)).slice(0,4).join("-");if(!H)continue;const W=`auto:${H}`,J=`cachly:lesson:best:${W}`,U=await p.get(J);if(U)try{if(JSON.parse(U).outcome==="success")continue}catch{}const Q={topic:W,outcome:"success",what_worked:O,context:`Auto-learned from session summary. Full summary: ${t.slice(0,300)}`,severity:"minor",ts:l.toISOString(),recall_count:0,auto_learned:!0,session_ts:l.toISOString(),version:2};await p.set(J,JSON.stringify(Q)),await p.expire(J,90*86400),v.push(W)}}catch{}const f=[];if(A)try{const e=s?(()=>{try{return JSON.parse(s).started??""}catch{return""}})():"",D=e?`--since="${e}"`:'--since="1 hour ago"',O=Me(`git -C "${A}" log ${D} --oneline --format="%H|||%s|||%b|||%ai|||ENDE"`,{timeout:5e3,encoding:"utf8",stdio:["ignore","pipe","ignore"]}).trim();if(O){const F=/\b(fix|add|remove|refactor|migrate|update|resolve|implement|improve|optimize|configure|create|delete|disable|enable|debug|patch|upgrade|build|rewrite|deploy|feat|chore|docs|test|perf|ci)\b/i,H=O.split("|||ENDE").map(W=>W.trim()).filter(Boolean);for(const W of H.slice(0,10)){const[J,U,Q,V]=W.split("|||");if(J)try{const C=Me(`git -C "${A}" diff-tree --no-commit-id --name-only -r --root "${J}"`,{timeout:5e3,encoding:"utf8",stdio:["ignore","pipe","ignore"]}).trim(),a=C?C.split(`
+`).map(w=>w.trim()).filter(Boolean).slice(0,12):[],d=[];for(const w of a)d.push(await Ie(p,w));for(let w=0;w<d.length;w++)for(let z=w+1;z<d.length;z++)await ne(p,d[w],"co-occurs",d[z],!0),await ne(p,d[z],"co-occurs",d[w],!0)}catch{}if(!U||!F.test(U))continue;const se=(Q??"").trim();if(se.length<120)continue;const n=U.toLowerCase().replace(/^(fix|feat|chore|docs|test|ci|perf|refactor|build|revert)[:(\s]/i,"").replace(/[^a-z0-9]+/g,"-").replace(/^-+|-+$/g,"").slice(0,40);if(!n)continue;const y=`git:${n}`,i=`cachly:lesson:best:${y}`;if(await p.get(i))continue;const r={topic:y,outcome:"success",what_worked:`${U}
+
+${se.slice(0,1200)}`,context:`Auto-learned from git commit ${(J??"").slice(0,7)} at ${V??""} in ${A}`,severity:"minor",ts:l.toISOString(),recall_count:0,auto_learned:!0,source:"ambient-git",version:3};await p.set(i,JSON.stringify(r)),await p.expire(i,60*86400),f.push(y)}}}catch{}const c=$!==void 0?` \xB7 ${$} min`:"",k=v.length+f.length,m=[];$!==void 0&&$>0&&m.push(`\u23F1 ${$} min session`),k>0&&m.push(`\u{1F9E0} ${k} lessons saved to Brain`),o.length>0&&m.push(`\u{1F4C1} ${o.length} file${o.length>1?"s":""} changed`);const _=m.length>0?`${m.join(" \xB7 ")}
+
+My AI Brain remembers this so I never repeat it. @cachlydev
+cachly.dev`:`Session saved to my AI Brain. No more re-explaining this tomorrow. @cachlydev
+cachly.dev`,I=`https://twitter.com/intent/tweet?text=${encodeURIComponent(_)}`,h=["","\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510","\u2502  \u{1F9E0} Session Summary Card                    \u2502","\u2502  Share your progress \u2014 cached forever       \u2502","\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524",$!==void 0?`\u2502  \u23F1  Duration   : ${($+" min").padEnd(26)}\u2502`:"",k>0?`\u2502  \u{1F4DA} Learned    : ${(k+" lessons").padEnd(26)}\u2502`:"",o.length>0?`\u2502  \u{1F4C1} Changed    : ${(o.length+" file"+(o.length>1?"s":"")).padEnd(26)}\u2502`:"","\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524",`\u2502  \u{1F4E3} Share: ${I.slice(0,34).padEnd(34)}\u2502`,"\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518"].filter(e=>e!=="").join(`
+`);return[`\u2705 **Session saved**${c}`,"",`\u{1F4CB} **Summary:** ${t}`,o.length>0?`\u{1F4C1} **Files changed:** ${o.map(e=>`\`${e}\``).join(", ")}`:"",S!==void 0?`\u{1F9E0} **Lessons stored:** ${S}`:"",v.length>0?`\u{1F916} **Auto-learned:** ${v.length} lessons extracted from summary (${v.slice(0,3).map(e=>`\`${e}\``).join(", ")}${v.length>3?"\u2026":""})`:"",f.length>0?`\u{1F33F} **Ambient git learning:** ${f.length} commit${f.length>1?"s":""} auto-learned (${f.slice(0,3).map(e=>`\`${e}\``).join(", ")}${f.length>3?"\u2026":""})`:"",h,"",'\u{1F4A1} Next session: `session_start(focus="...")` to see this summary.'].filter(e=>e!=="").join(`
+`)}case"session_ping":{const{instance_id:b,task:t,files_touched:o=[],next_step:S="",provider:A=""}=G,p=await q(b),l={ts:new Date().toISOString(),task:t,files_touched:o,next_step:S,provider:A};await p.set("cachly:session:checkpoint",JSON.stringify(l),"EX",86400*3),await p.lpush("cachly:session:checkpoint:log",JSON.stringify(l)),await p.ltrim("cachly:session:checkpoint:log",0,19);const $=A?` [${A}]`:"",s=o.length>0?` \xB7 ${o.length} file${o.length>1?"s":""} touched`:"",M=S?`
+\u{1F4CD} **Next step:** ${S}`:"";return[`\u{1F4CC} **Checkpoint saved**${$} \u2014 ${new Date().toLocaleTimeString()}`,`\u{1F528} **Working on:** ${t}${s}`,M,"","\u{1F4A1} If you switch providers, `session_start` will show this checkpoint automatically."].filter(g=>g!=="").join(`
+`)}case"session_handoff":{const{instance_id:b,completed_tasks:t=[],remaining_tasks:o=[],files_changed:S=[],instructions:A="",context_summary:p="",blocked_on:l=""}=G,$=await q(b),M={ts:new Date().toISOString(),completed_tasks:t,remaining_tasks:o,files_changed:S,instructions:A,context_summary:p,blocked_on:l};await $.set("cachly:session:handoff",JSON.stringify(M)),await $.lpush("cachly:session:handoff:history",JSON.stringify(M)),await $.ltrim("cachly:session:handoff:history",0,19);const g=t.length+o.length,x=g>0?Math.round(t.length/g*100):0,v=S.filter(f=>f.status==="broken"||f.status==="partial");return[`\u{1F91D} **Handoff saved** \u2014 ${t.length}/${g} tasks done (${x}%)`,"",t.length>0?`\u2705 **Completed:**
+${t.map(f=>`  - ${f}`).join(`
+`)}`:"",o.length>0?`
+\u23F3 **Remaining for next window:**
+${o.map(f=>`  - ${f}`).join(`
+`)}`:"",v.length>0?`
+\u26A0\uFE0F **Needs attention:** ${v.map(f=>`\`${f.path}\` (${f.status})`).join(", ")}`:"",l?`
+\u{1F6AB} **Blocked on:** ${l}`:"",A?`
+\u{1F4DD} **Instructions:** ${A}`:"","","\u{1F4A1} The next `session_start` will include this handoff automatically."].filter(f=>f!=="").join(`
+`)}case"auto_learn_session":{const{instance_id:b,observations:t}=G,o=await q(b),S=[],A=[];for(const l of t){const $=l.topic??l.action.toLowerCase().replace(/[^a-z0-9:\-_\s]/g,"").trim().split(/\s+/).slice(0,4).join("-"),s=$.includes(":")?$:`auto:${$}`,M=`cachly:lesson:best:${s}`,g=await o.get(M);if(g&&JSON.parse(g).outcome==="success"&&l.outcome!=="success"){A.push(s);continue}const x={topic:s,outcome:l.outcome,what_worked:l.outcome==="success"?l.action:l.details??l.action,what_failed:l.outcome==="failure"?l.action:void 0,context:l.details,severity:l.severity??"minor",ts:new Date().toISOString(),confidence:1,recall_count:0,auto_learned:!0,version:2},v=JSON.stringify(x);await o.set(M,v);const f=`cachly:lessons:${s}`;await o.rpush(f,v),await o.ltrim(f,-100,-1),await o.expire(f,90*86400);try{const c=s.split(":")[0]??"auto",k=Z(s);if(await de(o,k,c,c),l.outcome==="success"||l.outcome==="partial"){const m=l.details?$e(l.details):null;if(m){const _=Z(`problem:${m}`);await de(o,_,"problem","problem"),await ne(o,k,"fixes",_,l.outcome==="success",l.outcome==="partial")}}}catch{}S.push(`${l.outcome==="success"?"\u2705":l.outcome==="partial"?"\u26A0\uFE0F":"\u274C"} \`${s}\``)}const p=[`\u{1F916} **Auto-learn complete**: ${S.length} stored, ${A.length} skipped`,""];return S.length>0&&p.push("**Stored:**",...S.map(l=>"  "+l),""),A.length>0&&p.push(`**Skipped** (better lesson already exists): ${A.map(l=>`\`${l}\``).join(", ")}`),p.join(`
+`)}case"brain_who_knows":{const{instance_id:b,topic:t,limit:o=10}=G;if(!t||typeof t!="string"||!t.trim())return'\u26A0\uFE0F `brain_who_knows` requires a non-empty `topic`. Example: `brain_who_knows(topic="kubernetes deployment")`.';const S=Math.max(1,Math.min(Number(o)||10,50)),A=await q(b),p=Z(t),l=Se(t).filter(f=>f.length>=3).slice(0,5),$=new Set([p]);for(const f of l.slice(0,3)){const c=A.scanStream({match:`cachly:ckg:node:*${f}*`,count:30});await new Promise((k,m)=>{c.on("data",_=>{for(const I of _.slice(0,10)){const h=I.replace("cachly:ckg:node:","");!h.startsWith("person:")&&!h.startsWith("file:")&&$.add(h)}}),c.on("end",k),c.on("error",m)})}const s=new Map;for(const f of[...$].slice(0,25)){const c=await A.smembers(`cachly:ckg:idx:to:${f}`);for(const k of c){const m=await A.get(k);if(!m)continue;const _=P(m,null);if(!_||_.edgeType!=="authored")continue;const I=await A.get(`cachly:ckg:node:${_.from}`);if(!I)continue;const h=P(I,null);if(!h||h.type!=="person")continue;const e=s.get(_.from);e?(e.lessonCount++,e.totalConfidence+=_.confidence,e.domains.add(h.domain),_.last_updated>e.lastActive&&(e.lastActive=_.last_updated)):s.set(_.from,{handle:h.handle,lessonCount:1,totalConfidence:_.confidence,domains:new Set([h.domain]),lastActive:h.last_active??_.last_updated})}}if(s.size===0)return[`## \u{1F465} Who Knows About \`${t}\`?`,"","No attributed lessons found yet.","",'Knowledge attribution builds automatically \u2014 add `author="name"` to `learn_from_attempts` calls:',`\`learn_from_attempts(topic="${t}", author="your-handle", ...)\``].join(`
+`);const M=[...s.entries()].map(([f,c])=>({id:f,handle:c.handle,lessonCount:c.lessonCount,avgConfidence:c.totalConfidence/c.lessonCount,domains:[...c.domains].slice(0,3).join(", "),lastActive:c.lastActive})).sort((f,c)=>c.lessonCount*c.avgConfidence-f.lessonCount*f.avgConfidence).slice(0,S),g=[],x=M[0];if(x)try{const f=await A.smembers(`cachly:ckg:idx:from:${x.id}`),c=[];for(const k of f){const m=await A.get(k);if(!m)continue;const _=P(m,null);if(!_||_.edgeType!=="collaborates")continue;const I=await A.get(`cachly:ckg:node:${_.to}`),h=I?P(I,null):null;h?.handle&&c.push({handle:h.handle,trials:_.trials})}c.sort((k,m)=>m.trials-k.trials);for(const k of c.slice(0,3))g.push(k.handle)}catch{}const v=[`## \u{1F465} Who Knows About \`${t}\`?`,"",`**${M.length}** contributor${M.length!==1?"s":""} with relevant lessons:`,""];for(const[f,c]of M.entries()){const k=f===0?"\u{1F947}":f===1?"\u{1F948}":f===2?"\u{1F949}":`${f+1}.`,m=(c.avgConfidence*100).toFixed(0),_=Math.floor((Date.now()-new Date(c.lastActive).getTime())/864e5),I=_<1?"today":_<7?`${_}d ago`:_<30?`${Math.floor(_/7)}w ago`:`${Math.floor(_/30)}mo ago`,h=await Be(A,b,c.handle).catch(()=>null),e=h?` ${ht[h]}`:"";v.push(`${k} **${c.handle}**${e} \u2014 ${c.lessonCount} lesson${c.lessonCount!==1?"s":""} \xB7 ${m}% confidence \xB7 last active ${I}`,`   _domains: ${c.domains}_`,"")}return g.length>0&&x&&v.push(`\u{1F91D} **${x.handle}** frequently works with: ${g.map(f=>`**${f}**`).join(", ")}`,"   _(ask them together \u2014 they've solved structurally similar things on shared files)_",""),v.push("---",'_Attribution grows with every `learn_from_attempts(author="...", ...)` call._'),v.join(`
+`)}case"brain_file_map":{const{instance_id:b,file_paths:t=[]}=G,o=(Array.isArray(t)?t:[]).filter(p=>typeof p=="string"&&p.trim().length>0).map(p=>p.trim());if(!o.length)return'\u26A0\uFE0F Pass at least one file path. Example: `brain_file_map(file_paths=["src/auth/jwt.ts"])`.';const S=await q(b),A=["## \u{1F4C1} File Knowledge Map","","_What cachly knows about the files you're about to touch:_",""];for(const p of o.slice(0,10)){A.push(`### \`${p}\``);const l=`file:${Z(p)}`,$=await S.smembers(`cachly:ckg:idx:to:${l}`),s=[];for(const v of $){const f=await S.get(v);if(!f)continue;const c=P(f,null);if(!c||c.edgeType!=="touched")continue;const k=await S.get(`cachly:ckg:node:${c.from}`);if(!k)continue;const m=P(k,null);!m||m.type!=="person"||s.push({handle:m.handle,touches:c.trials,lastSeen:c.last_updated})}if(s.sort((v,f)=>f.touches-v.touches),s.length>0){const v=s.slice(0,5).map((f,c)=>{const k=c===0?"\u{1F947}":c===1?"\u{1F948}":c===2?"\u{1F949}":`${c+1}.`,m=Math.floor((Date.now()-new Date(f.lastSeen).getTime())/864e5),_=m<1?"today":m<7?`${m}d ago`:`${Math.floor(m/7)}w ago`;return`${k} **${f.handle}** (${f.touches}\xD7 \xB7 ${_})`}).join(" \xB7 ");A.push(`**Experts:** ${v}`)}else A.push("**Experts:** _None yet \u2014 add `author` to `learn_from_attempts` calls_");const g=p.replace(/[^a-z0-9]/gi," ").split(/\s+/).filter(v=>v.length>=4).slice(0,3).join(" "),x=[];if(g)try{const v=await Pe(S,["cachly:lesson:best:*"],g,4);for(const f of v){const c=P(f.content,{});if(c.visibility==="private")continue;const k=c.outcome==="success"?"\u2705":c.outcome==="partial"?"\u26A0\uFE0F":"\u274C",m=c.severity==="critical"?" \u{1F534}":c.severity==="major"?" \u{1F7E1}":"",_=c.author?` \xB7 \u{1F464} ${c.author}`:"",I=f.key.replace("cachly:lesson:best:","");x.push(`  - ${k} \`${I}\`${m}${_} \u2014 ${(c.what_worked??"").slice(0,100)}`)}}catch{}if(x.length<2){const v=await ce(S,"cachly:lesson:best:*",{max:1500});for(const f of v.slice(0,300)){const c=await S.get(f);if(!c)continue;const k=P(c,{});if(k.visibility==="private"||!(k.file_paths??[]).includes(p))continue;const m=f.replace("cachly:lesson:best:","");if(x.some(e=>e.includes(`\`${m}\``)))continue;const _=k.outcome==="success"?"\u2705":k.outcome==="partial"?"\u26A0\uFE0F":"\u274C",I=k.severity==="critical"?" \u{1F534}":k.severity==="major"?" \u{1F7E1}":"",h=k.author?` \xB7 \u{1F464} ${k.author}`:"";x.push(`  - ${_} \`${m}\`${I}${h} \u2014 ${(k.what_worked??"").slice(0,100)}`)}}x.length>0?(A.push("**Related lessons:**"),A.push(...x.slice(0,5))):A.push("**Related lessons:** _None yet_"),A.push("")}return A.push("---",'_Attribution builds with `learn_from_attempts(file_paths=[...], author="...")`. Run this before committing to track what changed and why._'),A.join(`
+`)}case"team_expertise_map":{const{instance_id:b,top_n:t=20}=G,o=await q(b),S=await ce(o,"cachly:ckg:node:person:*",{max:2e3});if(S.length===0)return["## \u{1F5FA}\uFE0F Team Expertise Map","","No contributors yet.","",'Add `author="handle"` to any `learn_from_attempts` call to start building the map.'].join(`
+`);const A=[];for(const $ of S){const s=await o.get($);if(!s)continue;const M=P(s,null);if(!M||M.type!=="person")continue;const g=await o.smembers(`cachly:ckg:idx:from:${M.id}`),x=new Map;let v=0;for(const f of g){const c=await o.get(f);if(!c)continue;const k=P(c,null);if(!k||k.edgeType!=="authored")continue;v++;const m=k.to.split(":")[0]??"unknown";x.set(m,(x.get(m)??0)+1)}A.push({handle:M.handle,lessonCount:v,domains:x,lastActive:M.last_active})}A.sort(($,s)=>s.lessonCount-$.lessonCount);const p=A.slice(0,t),l=["## \u{1F5FA}\uFE0F Team Expertise Map","",`**${p.length}** contributor${p.length!==1?"s":""} tracked:`,"","| # | Handle | Lessons | Top domains | Last active |","|---|--------|---------|-------------|-------------|"];for(const[$,s]of p.entries()){const M=$===0?"\u{1F947}":$===1?"\u{1F948}":$===2?"\u{1F949}":`${$+1}`,g=Math.floor((Date.now()-new Date(s.lastActive).getTime())/864e5),x=g<1?"today":g<7?`${g}d ago`:g<30?`${Math.floor(g/7)}w ago`:`${Math.floor(g/30)}mo ago`,v=[...s.domains.entries()].sort((f,c)=>c[1]-f[1]).slice(0,3).map(([f,c])=>`${f}(${c})`).join(", ")||"\u2014";l.push(`| ${M} | **${s.handle}** | ${s.lessonCount} | ${v} | ${x} |`)}return l.push("","---",'_Use `brain_who_knows(topic="...")` to find the expert for a specific problem._'),l.join(`
+`)}case"skill_gaps":{const{instance_id:b,min_failures:t=1}=G,o=await q(b),S=await ce(o,"cachly:lesson:best:*",{max:3e3}),A=new Map;let p=0,l=0;for(const M of S){const g=await o.get(M);if(!g)continue;const x=P(g,{}),v=(x.topic??"").split(":")[0]??"unknown",f=A.get(v)??{successes:0,failures:0,attributed:0,topics:[]};x.outcome==="success"||x.outcome==="partial"?f.successes++:f.failures++,x.author&&(f.attributed++,p++),x.visibility==="private"&&l++,f.topics.push(x.topic??""),A.set(v,f)}const $=[];for(const[M,g]of A)g.failures>=t&&g.successes===0&&$.push({domain:M,type:"unresolved failures",severity:g.failures>=3?"\u{1F534} critical":"\u{1F7E1} warn",detail:`${g.failures} failure${g.failures!==1?"s":""}, 0 solutions \u2014 use \`learn_from_attempts\` to store what fixed it`}),g.successes+g.failures>=3&&g.attributed===0&&$.push({domain:M,type:"no attribution",severity:"\u{1F535} info",detail:`${g.successes+g.failures} lessons with no \`author\` field \u2014 attribution lost, \`brain_who_knows\` can't help here`});const s=["## \u{1F50D} Skill Gaps \u2014 Knowledge Blind Spots","",`**${S.length}** lessons scanned \xB7 **${p}** attributed \xB7 **${$.length}** gap${$.length!==1?"s":""} found`,l>0?`_(${l} private lessons excluded from gap analysis)_`:"",""].filter(Boolean);if($.length===0)s.push("\u2705 No significant knowledge gaps detected. All domains with failures have at least one success lesson.");else{const M=[...$.filter(g=>g.severity.includes("critical")),...$.filter(g=>g.severity.includes("warn")),...$.filter(g=>g.severity.includes("info"))];for(const g of M.slice(0,15))s.push(`${g.severity} **\`${g.domain}\`** \u2014 ${g.type}`),s.push(`  ${g.detail}`),s.push("");$.length>15&&s.push(`_\u2026and ${$.length-15} more gaps. Fix critical ones first._`)}return s.push("---",`_Fix gaps with \`learn_from_attempts(topic="${$[0]?.domain??"your:topic"}", outcome="success", what_worked="...")\`_`,'_Add `author="name"` to every call to enable `brain_who_knows` + `team_expertise_map`._'),s.join(`
+`)}case"brain_coverage":{const{instance_id:b,repo_path:t="."}=G,o=await q(b),[S,A,p]=await Promise.all([ce(o,"cachly:lesson:best:*",{max:5e3}),ce(o,"cachly:ckg:node:person:*",{max:2e3}),ce(o,"cachly:ckg:node:file:*",{max:5e3})]);let l=0,$="n/a";try{const{execSync:m}=await import("node:child_process"),{resolve:_}=await import("node:path"),I=_(t);l=m("git ls-files",{cwd:I,encoding:"utf-8",stdio:"pipe"}).trim().split(`
+`).filter(Boolean).length,$=String(l)}catch{}let s=0,M=0,g=0;const x=new Set;for(const m of S){const _=await o.get(m);if(!_)continue;const I=P(_,{});I.outcome==="success"||I.outcome==="partial"?s++:M++,I.author&&g++,x.add((I.topic??"").split(":")[0]??"unknown")}const v=l>0?`${Math.round(p.length/l*100)}% (${p.length}/${l} files)`:`${p.length} files tracked`,f=S.length>0?Math.round(g/S.length*100):0,c=Math.round(Math.min(1,S.length/50)*25+Math.min(1,s/Math.max(1,S.length))*25+Math.min(1,f/100)*25+Math.min(1,A.length/5)*25);return["## \u{1F4CA} Brain Coverage Report","",`${c>=80?"\u{1F7E2}":c>=50?"\u{1F7E1}":"\u{1F534}"} **Overall score: ${c}/100**`,"","| Metric | Value |","|--------|-------|",`| Total lessons | **${S.length}** (${s} success \xB7 ${M} failure) |`,`| Problem domains | **${x.size}** |`,`| Attribution | **${g}/${S.length}** (${f}%) |`,`| Contributors | **${A.length}** tracked in knowledge graph |`,`| File coverage | **${v}** |`,"","**Score breakdown (each 0\u201325):**",`- Lesson volume: **${Math.round(Math.min(1,S.length/50)*25)}/25** _(target: 50+ lessons)_`,`- Success ratio: **${Math.round(Math.min(1,s/Math.max(1,S.length))*25)}/25** _(target: all lessons resolved)_`,`- Attribution: **${Math.round(Math.min(1,f/100)*25)}/25** _(target: 100% attributed)_`,`- Team engagement: **${Math.round(Math.min(1,A.length/5)*25)}/25** _(target: 5+ contributors)_`,"","---","_Boost score: run `brain_from_git` \xB7 add `author` to `learn_from_attempts` \xB7 fix gaps with `skill_gaps`_"].join(`
+`)}case"brain_metrics":{const{instance_id:b}=G,t=await q(b),[o,S,A,p,l,$]=await Promise.all([t.get(`cachly:stats:born_at:${b}`).catch(()=>null),t.get(`cachly:stats:first_recall_at:${b}`).catch(()=>null),t.get(`cachly:stats:recalls_total:${b}`).catch(()=>null),t.get(`cachly:stats:cross_author_recalls:${b}`).catch(()=>null),t.get(`cachly:stats:time_saved_mins:${b}`).catch(()=>null),t.smembers(`cachly:stats:reuse_pairs:${b}`).catch(()=>[])]);let s={};try{s=await t.hgetall(Ut(b))??{}}catch{s={}}const M=Vt(s,10);let g={token:0,abrufe:0,treffer:0};try{const D=await t.get(Qt(b)),O=await t.hgetall(es(b))??{};g={token:D??0,abrufe:O.abrufe??0,treffer:O.treffer??0}}catch{}const x=Zt(g);let v;if(o&&S){const D=new Date(S).getTime()-new Date(o).getTime(),O=Math.max(0,Math.round(D/6e4)),F=O<1?"<1 min":O<60?`${O} min`:`${(O/60).toFixed(1)} h`,H=D<=2*6e4?"\u{1F7E2} under 2 min target":D<=60*6e4?"\u{1F7E1} over 2 min":"\u{1F534} over 1 h";v=`**${F}** from first lesson \u2192 first proven recall \xB7 ${H}`}else o&&!S?v="\u{1F7E1} Brain has knowledge but no proven recall yet \u2014 try `smart_recall`":v="\u26AA Not enough data yet \u2014 store a lesson, then recall it";const f=["\u26AA **Nicht gemessen** \u2014 diese Zahl erhebt der Server nicht selbst.","  Selbst messen: `npm run bench` in `sdk/mcp`.","  Achtung, der Pruefstand hat 17 Lektionen und 13 Fragen \u2014 ein Beispielsatz, kein Bestand.","  Auf 498 ECHTEN Lektionen gemessen am 19.08.2026: Precision@1 **30 %** (vorher 15 %)."].join(`
+`),c=Number(A??0),k=Number(p??0),m=c>0?Math.round(k/c*100):0,_=m>=30?"\u{1F7E2} above 30 % target":c===0?"\u26AA no recalls yet":"\u{1F7E1} below 30 % target",I=Math.round(Number(l??0)),h=I<60?`${I} min`:`${(I/60).toFixed(1)} h`;return["## \u{1F4C8} Brain Metrics \u2014 the three that decide everything","","### 1. Time-to-first-recall _(onboarding friction)_",v,"","### 2. Recall-lift _(the moat proof)_",f,"_Reproduce: `npm run bench` \xB7 CI-defended in `rerank.test.ts` \xB7 details in BENCH.md_","","### 3. Team-knowledge-reuse _(the value only a shared brain delivers)_",`**${m}%** of proven recalls used a teammate's lesson (${k}/${c}) \xB7 ${_}`,$.length>0?`**${$.length}** distinct reuse relationship${$.length!==1?"s":""} across the team`:"","","---","### \u{1F4E6} Aus dem Brain geliefert _(gemessen, nicht gerechnet)_",Xt(x),"",x.abrufe>0?`_Daneben eine **Sch\xE4tzung**: ${h} nicht neu recherchiert \u2014 gerechnet mit 30\u2013240 Min. je Lektion nach Schwere, nicht gemessen. Die Zahl dar\xFCber braucht diese Annahme nicht._`:`_Eine **Sch\xE4tzung** von ${h} \u201Enicht neu recherchiert" w\xE4re hier gerechnet, nicht gemessen \u2014 sie erscheint erst, wenn daneben eine gemessene Zahl steht._`,c===0?'_Tip: pass `author="your-handle"` to `smart_recall` so cross-author reuse can be tracked._':"_These numbers compound: every learned lesson and every teammate raises all three._","","### \u{1F527} Werkzeug-Nutzung _(erst messen, dann zusammenlegen)_",Yt(M,rs.length),...M.spitze.length>0?M.spitze.map((D,O)=>`  ${String(O+1).padStart(2)}. \`${D.name}\` \u2014 ${D.aufrufe}\xD7 (${Math.round(D.anteil*100)} %)`):[]].filter(Boolean).join(`
+`)}case"brain_service_map":{const{instance_id:b,service:t}=G;if(!t||typeof t!="string"||!t.trim())return'\u26A0\uFE0F `brain_service_map` requires a non-empty `service`. Example: `brain_service_map(service="prometheus")`.';const o=await q(b),S=`service:${Z(t.trim())}`,A=await o.get(`cachly:ckg:node:${S}`).catch(()=>null),p=A?P(A,null):null,l=await o.smembers(`cachly:ckg:idx:to:${S}`).catch(()=>[]),$=[],s=[],M=[];for(const _ of l){const I=await o.get(_).catch(()=>null);if(!I)continue;const h=P(I,null);if(h)if(h.edgeType==="operates"){const e=await o.get(`cachly:ckg:node:${h.from}`).catch(()=>null),D=e?P(e,null):null;D?.handle&&$.push({handle:D.handle,trials:h.trials})}else if(h.edgeType==="runs_in"){const e=await o.get(`cachly:ckg:node:${h.from}`).catch(()=>null),D=e?P(e,null):null;D?.path&&s.push({path:D.path,trials:h.trials})}else h.edgeType==="affects"&&M.push({id:h.from,confidence:h.confidence})}$.sort((_,I)=>I.trials-_.trials),s.sort((_,I)=>I.trials-_.trials),M.sort((_,I)=>I.confidence-_.confidence);const g=[],x=await ce(o,"cachly:lesson:best:*",{max:1500}),v=t.trim().toLowerCase();for(const _ of x.slice(0,400)){const I=await o.get(_).catch(()=>null);if(!I)continue;const h=P(I,{});h.visibility!=="private"&&(h.service??"").toLowerCase()===v&&g.push({...h,topic:_.replace("cachly:lesson:best:","")})}if(!p&&g.length===0&&$.length===0)return[`## \u{1F6F0}\uFE0F Service Map \u2014 \`${t}\``,"","Nothing known about this service yet.","","Tag lessons with the service they concern so the brain can build this map:",`\`learn_from_attempts(topic="...", service="${t}", author="you", file_paths=[...])\``].join(`
+`);const f=p?.kind==="system"?"\u{1F5A5}\uFE0F system":"\u{1F6F0}\uFE0F service",c=[`## ${p?.kind==="system"?"\u{1F5A5}\uFE0F":"\u{1F6F0}\uFE0F"} Service Map \u2014 \`${t}\``,"",p?`_${f} \xB7 ${p.count} lesson${p.count!==1?"s":""} referenced \xB7 domain: ${p.domain}_`:"_No graph node yet \u2014 built from tagged lessons below._",""];if($.length>0){const _=$.slice(0,5).map((I,h)=>`${h===0?"\u{1F947}":h===1?"\u{1F948}":h===2?"\u{1F949}":`${h+1}.`} **${I.handle}** (${I.trials}\xD7)`).join(" \xB7 ");c.push(`**Operators:** ${_}`,"")}else c.push("**Operators:** _None attributed \u2014 add `author` when learning about this service_","");const k=g.filter(_=>_.outcome==="failure"),m=g.filter(_=>_.outcome!=="failure");if(k.length>0){c.push(`**\u26A0\uFE0F Known failures (${k.length}):**`);for(const _ of k.slice(0,6)){const I=_.severity==="critical"?" \u{1F534}":_.severity==="major"?" \u{1F7E1}":"",h=_.author?` \xB7 \u{1F464} ${_.author}`:"";c.push(`  - \u274C \`${_.topic}\`${I}${h} \u2014 ${(_.what_worked??"").slice(0,100)}`)}c.push("")}if(m.length>0){c.push(`**\u2705 Proven fixes (${m.length}):**`);for(const _ of m.slice(0,6)){const I=_.outcome==="partial"?"\u26A0\uFE0F":"\u2705",h=_.author?` \xB7 \u{1F464} ${_.author}`:"";c.push(`  - ${I} \`${_.topic}\`${h} \u2014 ${(_.what_worked??"").slice(0,100)}`)}c.push("")}return s.length>0&&c.push(`**Files in this service:** ${s.slice(0,8).map(_=>`\`${_.path}\``).join(", ")}`,""),c.push("---",`_Tag lessons with \`service="${t}"\` to keep this map current. For infra, pass \`service_kind="system"\`._`),c.join(`
+`)}case"brain_collab_pairs":{const{instance_id:b,min_weight:t=1}=G,o=await q(b),S=typeof t=="number"&&t>=1?Math.floor(t):1,A=await ce(o,"cachly:ckg:node:person:*",{max:500}),p=new Map;for(const x of A){const v=await o.get(x);if(!v)continue;const f=P(v,null);!f||f.type!=="person"||p.set(f.id,{id:f.id,handle:f.handle,domain:f.domain,count:f.count})}if(p.size===0)return["## \u{1F91D} Team Collaboration Graph","","No contributors found yet.","",'The graph builds automatically as teammates store lessons with `author="name"`:','`learn_from_attempts(topic="...", author="alice", file_paths=["src/auth.ts"], ...)`'].join(`
+`);const l=new Map;for(const[x,v]of p){const f=await o.smembers(`cachly:ckg:idx:from:${x}`);for(const c of f){const k=await o.get(c);if(!k)continue;const m=P(k,null);if(!m||m.edgeType!=="collaborates")continue;const _=p.get(m.to);if(!_)continue;const[I,h]=x<m.to?[x,m.to]:[m.to,x],e=`${I}||${h}`,D=l.get(e);if(D)D.trials+=m.trials;else{const[O,F]=x<m.to?[v,_]:[_,v];l.set(e,{a:O,b:F,trials:m.trials,confidence:m.confidence})}}}const $=[...l.values()].filter(x=>x.trials>=S).sort((x,v)=>v.trials-x.trials),s=new Set;for(const x of $)s.add(x.a.id),s.add(x.b.id);const M=[...p.values()].filter(x=>!s.has(x.id)),g=["## \u{1F91D} Team Collaboration Graph",""];if($.length===0)g.push(`No collaboration pairs yet (min weight: ${S}).`,"","Pairs appear when two contributors touch the same file in `learn_from_attempts`",'or when someone recalls a teammate\'s lesson via `smart_recall(requester="...")`.');else{g.push(`**${$.length} collaboration pair${$.length!==1?"s":""}** across ${s.size} contributor${s.size!==1?"s":""}:`,"");for(const x of $.slice(0,20)){const v=(x.confidence*100).toFixed(0),f=[x.a.domain,x.b.domain].filter((c,k,m)=>c&&m.indexOf(c)===k).map(c=>`\`${c}\``).join(", ");g.push(`### @${x.a.handle} \u2194 @${x.b.handle}`,`- **${x.trials} collaboration event${x.trials!==1?"s":""}** \xB7 ${v}% confidence`,`- Domains: ${f||"_unknown_"}`,`> \u{1F4AC} _"Frag **@${x.a.handle}** und **@${x.b.handle}** \u2014 they've solved problems together in these areas."_`,"")}$.length>20&&g.push(`_...and ${$.length-20} more pairs. Use \`min_weight\` to filter._`,"")}return M.length>0&&g.push("---","### \u26A0\uFE0F Bus Factor Alert \u2014 No Collaborators Yet","",`${M.length} contributor${M.length!==1?"s have":" has"} knowledge that no teammate has recalled or co-touched:`,"",...M.slice(0,10).map(x=>`- **@${x.handle}** \u2014 ${x.count} lesson${x.count!==1?"s":""} \xB7 domain: \`${x.domain}\``),"","_Tip: pair these contributors with teammates on shared files to reduce bus factor._"),g.push("","---","_Collaboration edges build from `learn_from_attempts(author=..., file_paths=[...])` and `smart_recall(requester=...)` cross-author reuse._"),g.join(`
+`)}case"brain_portability":{const{instance_id:b}=G,t=[{name:"Claude Code",slug:"claude-code",icon:"\u{1F916}",configPath:"~/.claude/settings.json",configBlock:JSON.stringify({mcpServers:{cachly:{command:"npx",args:["@cachly-dev/mcp-server@latest"],env:{CACHLY_JWT:"<cky_live_...>",CACHLY_BRAIN_INSTANCE_ID:b}}}},null,2)},{name:"Cursor",slug:"cursor",icon:"\u{1F5B1}\uFE0F",configPath:"~/.cursor/mcp.json",configBlock:JSON.stringify({mcpServers:{cachly:{command:"npx",args:["@cachly-dev/mcp-server@latest"],env:{CACHLY_JWT:"<cky_live_...>",CACHLY_BRAIN_INSTANCE_ID:b}}}},null,2)},{name:"Windsurf",slug:"windsurf",icon:"\u{1F3C4}",configPath:"~/.windsurf/mcp.json",configBlock:JSON.stringify({mcpServers:{cachly:{command:"npx",args:["@cachly-dev/mcp-server@latest"],env:{CACHLY_JWT:"<cky_live_...>",CACHLY_BRAIN_INSTANCE_ID:b}}}},null,2)},{name:"GitHub Copilot (VS Code)",slug:"copilot",icon:"\u{1F419}",configPath:".vscode/mcp.json (workspace)",configBlock:JSON.stringify({servers:{cachly:{type:"stdio",command:"npx",args:["@cachly-dev/mcp-server@latest"],env:{CACHLY_JWT:"<cky_live_...>",CACHLY_BRAIN_INSTANCE_ID:b}}}},null,2)},{name:"Cline",slug:"cline",icon:"\u26A1",configPath:"~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json",configBlock:JSON.stringify({mcpServers:{cachly:{command:"npx",args:["@cachly-dev/mcp-server@latest"],env:{CACHLY_JWT:"<cky_live_...>",CACHLY_BRAIN_INSTANCE_ID:b}}}},null,2)},{name:"Zed",slug:"zed",icon:"\u26A1",configPath:"~/.config/zed/settings.json",configBlock:JSON.stringify({context_servers:{cachly:{command:{path:"npx",args:["@cachly-dev/mcp-server@latest"]},env:{CACHLY_JWT:"<cky_live_...>",CACHLY_BRAIN_INSTANCE_ID:b}}}},null,2)},{name:"Continue",slug:"continue",icon:"\u25B6\uFE0F",configPath:"~/.continue/config.json",configBlock:JSON.stringify({mcpServers:[{name:"cachly",command:"npx @cachly-dev/mcp-server@latest",env:{CACHLY_JWT:"<cky_live_...>",CACHLY_BRAIN_INSTANCE_ID:b}}]},null,2)}],o=["## \u{1F310} Brain Portability \u2014 Same Brain, Any Model","",'> _"Bring your own model, keep your brain."_',"",`**Your Brain ID:** \`${b}\``,"","Replace `<cky_live_...>` below with your own API key (get one at https://cachly.dev/setup-ai) \u2014 the Brain ID alone does not authenticate you.","","This Brain ID is model-agnostic. Every lesson you've learned, every Memory Crystal you've distilled,","and every prediction from your Causal Knowledge Graph is accessible from **any MCP-compatible AI client**.","","---","",`### Compatible Clients (${t.length} supported)`,""];for(const S of t)o.push(`#### ${S.icon} ${S.name}`,`Config: \`${S.configPath}\``,"","```json",S.configBlock,"```","");return o.push("---","","### What travels with you","","| Data | Model-neutral? |","|------|---------------|","| Lessons (learn_from_attempts) | \u2705 Full access in all clients |","| Memory Crystals (memory_crystalize) | \u2705 Included in every session_start |","| Causal Knowledge Graph (brain_predict) | \u2705 Same graph, same predictions |","| Team lessons (team_learn, team_confirm) | \u2705 Team is per-Brain, not per-model |","| Domain Brain Marketplace installs | \u2705 Installed once, available everywhere |","| Session handoffs (session_handoff) | \u2705 Cross-client continuity |","","---","","### One-command setup for any new client","","```bash","npx @cachly-dev/mcp-server@latest autopilot","```","",`Autopilot detects all installed editors and writes the config for each \u2014 with your \`${b}\` Brain ID pre-filled.`,"","---","_Docs: cachly.dev/docs/model-neutral \u2022 Your Brain, Any Model_"),o.join(`
+`)}case"brain_changelog":{const{instance_id:b,days:t=7,max_lessons:o=30,include_failures:S=!0}=G,A=await q(b),p=Date.now()-Number(t)*864e5,l=await ce(A,"cachly:lesson:best:*",{max:4e3,timeoutMs:4e3}),$=[];for(const c of l){const k=await A.get(c).catch(()=>null);if(!k)continue;const m=P(k,{});if((m.ts?new Date(m.ts).getTime():0)<p||!S&&m.outcome==="failure")continue;const I=c.replace("cachly:lesson:best:","");$.push({...m,topic:I})}$.sort((c,k)=>{const m=c.ts?new Date(c.ts).getTime():0;return(k.ts?new Date(k.ts).getTime():0)-m});const s=$.slice(0,Number(o));if(s.length===0)return[`## \u{1F4CB} Brain Changelog \u2014 last ${t} day${Number(t)!==1?"s":""}`,"","_No new lessons learned in this window. Your Brain already knows everything it knows \u2014 add new lessons with `learn_from_attempts`._"].join(`
+`);const M=new Map;for(const c of s){const k=c.topic.includes(":")?c.topic.split(":")[0]:"general",m=M.get(k)??[];m.push(c),M.set(k,m)}const g=c=>c==="critical"?"\u{1F6A8}":c==="major"?"\u26A0\uFE0F":c==="minor"?"\u{1F4A1}":"\u2728",x=c=>c==="failure"?"\u274C":c==="partial"?"\u{1F536}":"\u2705",f=[`## \u{1F4CB} Brain Changelog \u2014 ${new Date().toISOString().slice(0,10)} (last ${t} day${Number(t)!==1?"s":""})`,"",`_${s.length} lesson${s.length!==1?"s":""} learned across ${M.size} topic area${M.size!==1?"s":""}_`,""];for(const[c,k]of Array.from(M.entries()).sort((m,_)=>_[1].length-m[1].length)){f.push(`### ${c}`),f.push("");for(const m of k){const _=m.outcome==="failure"?x(m.outcome):g(m.severity),I=m.outcome==="failure"?m.what_failed:m.what_worked,h=[];m.author&&h.push(`by **${m.author}**`),m.recall_count&&h.push(`${m.recall_count} recall${m.recall_count!==1?"s":""}`),m.confidence!==void 0&&h.push(`${Math.round(m.confidence*100)}% confidence`),f.push(`- ${_} **${m.topic}**${I?` \u2014 ${I}`:""}`),h.length&&f.push(`  _${h.join(" \xB7 ")}_`)}f.push("")}return f.push("---",`_Generated from Brain \`${b}\` \xB7 Share this in your standup or Slack_`),f.join(`
+`)}case"brain_set_pref":{const{instance_id:b,key:t,value:o}=G;if(!t||!t.trim())throw new Error("key is required");const S=await q(b),A=`cachly:prefs:${t.trim()}:${b}`;return await S.set(A,String(o)),`\u2705 Preference \`${t}\` set to \`${o}\` for this Brain instance.`}case"brain_get_pref":{const{instance_id:b,key:t}=G,o=await q(b);if(t&&t.trim()){const l=await o.get(`cachly:prefs:${t.trim()}:${b}`).catch(()=>null);return l===null?`\u2139\uFE0F Preference \`${t}\` is not set (using default).`:`\u{1F527} Preference \`${t}\` = \`${l}\``}const S=await ce(o,`cachly:prefs:*:${b}`,{max:200,timeoutMs:2e3});if(S.length===0)return"\u2139\uFE0F No preferences set for this Brain instance.";const A=await o.mget(...S),p=["\u{1F527} **Brain preferences:**",""];for(let l=0;l<S.length;l++){const $=S[l].replace("cachly:prefs:","").replace(`:${b}`,"");p.push(`- \`${$}\` = \`${A[l]??"(null)"}\``)}return p.join(`
+`)}default:return null}}export{Js as BRAIN_TOOL_NAMES,Ys as handleBrainTool,Le as recallVorschau};