@cachly-dev/mcp-server 0.10.129 → 0.10.130

package/dist/src/handlers/team.js

@@ -1,1493 +1,57 @@
-import { readFileSync } from 'node:fs';
-import { bauabdruck, formatiereBauabdruck } from '../bauabdruck.js';
-import { beurteileSpeicher, zahlAusInfo } from '../speicherlage.js';
-import { beurteileDeckung } from '../eingaenge.js';
-import { join } from 'node:path';
-import { calculateConfidence, CONFIDENCE_STALE_VALUE, CONFIDENCE_WARN_VALUE, CONFIDENCE_WARN_DAYS, CONFIDENCE_STALE_DAYS } from '../confidence.js';
-import { safeJsonParse } from '../utils.js';
-import { ersparteMinuten, istStarterLektion, fmtStunden } from '../wertbeitrag.js';
-import { cachlyUrl } from '../cachly-url.js';
-export const TEAM_TOOL_NAMES = new Set([
-    'sync_file_changes', 'team_learn', 'team_confirm', 'team_recall', 'team_synthesize', 'memory_crystalize', 'team_crystallize',
-    'brain_doctor', 'brain_hygiene', 'recall_at', 'trace_dependency', 'global_learn', 'global_recall',
-    'publish_lesson', 'import_public_brain', 'setup_ai_memory',
-    'team_assign_role', 'team_whoami', 'team_roster',
-    'team_grant_scope', 'team_scopes', 'team_audit',
-]);
-const ROLE_RANK = {
-    admin: 4, reviewer: 3, contributor: 2, viewer: 1,
-};
-export const ROLE_BADGE = {
-    admin: '👑', reviewer: '🛡️', contributor: '✏️', viewer: '👁️',
-};
-const ROLE_CAPABILITIES = {
-    admin: 'assign roles · delete lessons · all reviewer + contributor actions',
-    reviewer: 'senior-review lessons (🛡️) · all contributor actions',
-    contributor: 'store lessons · peer-review lessons (✔️) · recall',
-    viewer: 'recall only — cannot store or review lessons',
-};
-export const ROLES_KEY = (instanceId) => `cachly:team:roles:${instanceId}`;
-export async function getRole(redis, instanceId, handle) {
-    const raw = await redis.hget(ROLES_KEY(instanceId), handle.toLowerCase()).catch(() => null);
-    return raw;
-}
-/** True when `actorRole` is at least as powerful as `requiredRole`. */
-export function hasPermission(actorRole, required) {
-    if (!actorRole)
-        return false;
-    return (ROLE_RANK[actorRole] ?? 0) >= (ROLE_RANK[required] ?? 0);
-}
-/** The review level a role warrants in team_confirm. */
-export function roleToReviewLevel(role) {
-    return role === 'admin' || role === 'reviewer' ? 'senior' : 'peer';
-}
-// ── RBAC enforcement (W6) ──────────────────────────────────────────────────────
-// Governance "activates" once an admin is bootstrapped on a brain (the same
-// signal team_assign_role uses). Before that, the team is open and every tool
-// behaves exactly as before — so existing single-user and small-team flows are
-// untouched. Once an admin exists, write/review tools enforce role minimums.
-/** True once at least one admin exists — i.e. governance has been turned on. */
-export async function rbacActive(redis, instanceId) {
-    const allRoles = await redis.hgetall(ROLES_KEY(instanceId)).catch(() => ({}));
-    return Object.values(allRoles).includes('admin');
-}
-/**
- * Enforce that `handle` holds at least `required` — but only when governance is
- * active. Returns null when the action is permitted, or a clear refusal message
- * (never throws — a denied write must not break the agent call). `action` is a
- * short human phrase, e.g. "store team lessons".
- */
-export async function requireRole(redis, instanceId, handle, required, action) {
-    if (!(await rbacActive(redis, instanceId)))
-        return null; // open team — allow
-    const role = handle ? await getRole(redis, instanceId, handle) : null;
-    if (hasPermission(role, required))
-        return null;
-    const have = role ? `${ROLE_BADGE[role]} ${role}` : 'no role';
-    return [
-        `🔒 **Permission denied** — to ${action} you need at least \`${required}\` ${ROLE_BADGE[required]} (you have: ${have}).`,
-        ``,
-        `Ask an admin to grant it:`,
-        `\`team_assign_role(instance_id="${instanceId}", handle="${handle || '<your-handle>'}", role="${required}", assigned_by="<admin>")\``,
-        `_Governance is active on this brain. Run \`team_whoami\` to check your role._`,
-    ].join('\n');
-}
-/** Append an immutable governance-audit entry (role changes, gated actions). */
-export async function auditLog(redis, instanceId, entry) {
-    const key = `cachly:team:audit:${instanceId}`;
-    const rec = JSON.stringify({ ...entry, ts: new Date().toISOString() });
-    await redis.rpush(key, rec).catch(() => { });
-    await redis.ltrim(key, -500, -1).catch(() => { });
-    await redis.expire(key, 365 * 2 * 86400).catch(() => { }); // 2-year retention
-}
-// ── Lessons-Review workflow (P1-1) ────────────────────────────────────────────
-// When an org enables pending-mode (PUT /orgs/:id/lesson-review), the API
-// mirrors the setting onto each org instance's Valkey as REVIEW_MODE_KEY = "1".
-// Team-shared lesson writes then land under PROPOSED_LESSON_PREFIX instead of
-// cachly:lesson:best:*, so every recall path (which reads best:*) automatically
-// ignores them until an org owner/admin approves the proposal in the dashboard
-// (Team → Review). Key absent = direct writes, exactly as before.
-export const REVIEW_MODE_KEY = 'cachly:team:review_mode';
-export const PROPOSED_LESSON_PREFIX = 'cachly:lesson:proposed:';
-// Proposals expire after 90 days (same window as the lesson history lists) so
-// an abandoned review queue cleans itself up.
-const PROPOSAL_TTL_SECONDS = 90 * 86400;
-/** True when the org has turned on review-required mode for this brain. */
-export async function reviewModeEnabled(redis, instanceId) {
-    void instanceId; // per-instance flag; id only kept for future API fallback
-    const raw = await redis.get(REVIEW_MODE_KEY).catch(() => null);
-    return raw === '1' || raw === 'true' || raw === 'on';
-}
-/**
- * Store a lesson as a pending proposal (one per topic, latest wins — mirroring
- * the upsert semantics of cachly:lesson:best:<topic>) and tell the caller what
- * happens next. Never throws — a queued lesson must not break the agent call.
- */
-export async function storeLessonProposal(redis, topic, record) {
-    const proposal = { ...record, proposed_at: new Date().toISOString(), status: 'pending' };
-    await redis
-        .set(`${PROPOSED_LESSON_PREFIX}${topic}`, JSON.stringify(proposal), 'EX', PROPOSAL_TTL_SECONDS)
-        .catch(() => { });
-    const author = typeof record.author === 'string' && record.author ? ` by **${record.author}**` : '';
-    return [
-        `📝 **Lesson submitted for review** — \`${topic}\`${author} is now a pending proposal.`,
-        ``,
-        `This team requires review before knowledge enters the Team Brain (org setting).`,
-        `An org owner/admin can approve or reject it in the dashboard under **Team → Review**.`,
-        `Until approved it will NOT surface in \`smart_recall\` / \`team_recall\`.`,
-    ].join('\n');
-}
-// ── Team-level visibility scopes (groups) ─────────────────────────────────────
-// A named sub-team (e.g. "backend", "security"). Lessons can be scoped to a group
-// via `group` on learn_from_attempts; they then only surface in recall for members
-// of that group (admins see everything). Orthogonal to lesson-level `private`.
-//   cachly:team:groups:{instance}            → set of group names
-//   cachly:team:group:{instance}:{group}     → set of member handles
-export const GROUPS_INDEX_KEY = (instanceId) => `cachly:team:groups:${instanceId}`;
-export const GROUP_KEY = (instanceId, group) => `cachly:team:group:${instanceId}:${group.toLowerCase()}`;
-/** Return the set of group names `handle` belongs to (lower-cased). */
-export async function getScopes(redis, instanceId, handle) {
-    const groups = await redis.smembers(GROUPS_INDEX_KEY(instanceId)).catch(() => []);
-    const out = new Set();
-    for (const g of groups) {
-        const isMember = await redis.sismember(GROUP_KEY(instanceId, g), handle.toLowerCase()).catch(() => 0);
-        if (isMember)
-            out.add(g.toLowerCase());
-    }
-    return out;
-}
-/**
- * Can a requester (with `requesterScopes`, possibly admin) see a lesson scoped to
- * `lessonGroup`? Team-wide lessons (no group) are always visible; group-scoped
- * lessons require membership. Admins see everything. Pure + testable.
- */
-export function lessonVisibleToScope(lessonGroup, requesterScopes, isAdmin) {
-    if (!lessonGroup)
-        return true;
-    if (isAdmin)
-        return true;
-    return requesterScopes.has(lessonGroup.toLowerCase());
-}
-export async function handleTeamTool(name, args, getConnection, apiFetch) {
-    switch (name) {
-        case 'sync_file_changes': {
-            const { instance_id, changed_files, git_diff_stat, commit_msg } = args;
-            const redis = await getConnection(instance_id);
-            // Store file change event in session history
-            const changeRecord = {
-                ts: new Date().toISOString(),
-                files: changed_files,
-                commit_msg,
-                diff_stat: git_diff_stat?.slice(0, 500),
-            };
-            await redis.lpush('cachly:session:file_changes', JSON.stringify(changeRecord));
-            await redis.ltrim('cachly:session:file_changes', 0, 99);
-            await redis.expire('cachly:session:file_changes', 30 * 86400);
-            // Find lessons relevant to the changed files
-            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 relevant = [];
-            const sfRaws = lessonKeys.length > 0 ? await redis.mget(...lessonKeys) : [];
-            for (const raw of sfRaws) {
-                if (!raw)
-                    continue;
-                const lesson = safeJsonParse(raw, null);
-                if (!lesson)
-                    continue;
-                // Match by file_paths stored in lesson OR by topic keywords matching file name
-                const topicWords = lesson.topic.toLowerCase().split(/[:\-_]/);
-                const fileMatches = changed_files.some(f => {
-                    const fname = f.split('/').pop()?.replace(/\.[^.]+$/, '').toLowerCase() ?? '';
-                    return topicWords.some(w => w.length > 3 && fname.includes(w))
-                        || (lesson.file_paths ?? []).some(lf => f.includes(lf) || lf.includes(f));
-                });
-                if (fileMatches) {
-                    const emoji = lesson.outcome === 'success' ? '✅' : '⚠️';
-                    relevant.push(`  ${emoji} \`${lesson.topic}\` — ${lesson.what_worked.slice(0, 80)}`);
-                }
-            }
-            const lines = [
-                `📁 **File sync recorded**: ${changed_files.length} files`,
-                commit_msg ? `📝 Commit: "${commit_msg}"` : '',
-                '',
-                `**Changed:** ${changed_files.slice(0, 8).map(f => `\`${f}\``).join(', ')}${changed_files.length > 8 ? ` +${changed_files.length - 8} more` : ''}`,
-                '',
-            ];
-            if (relevant.length > 0) {
-                lines.push(`🧠 **Relevant brain lessons (${relevant.length}):**`, ...relevant);
-            }
-            else {
-                lines.push(`💡 No existing lessons match these files yet. Add them with \`learn_from_attempts\`.`);
-            }
-            return lines.filter(Boolean).join('\n');
-        }
-        // ── team_learn ────────────────────────────────────────────────────────────
-        case 'team_learn': {
-            const { instance_id, author, topic, outcome, what_worked, what_failed, severity, file_paths, commands, tags } = args;
-            if (!author || !topic || !outcome || !what_worked) {
-                return '❌ Required: author, topic, outcome, what_worked';
-            }
-            const iid = instance_id;
-            if (!iid)
-                return '❌ instance_id required';
-            // W6 enforcement: once governance is active, a viewer (recall-only) cannot
-            // store team lessons — contributor+ required. Open teams are unaffected.
-            const redisTL = await getConnection(iid);
-            const learnDenied = await requireRole(redisTL, iid, author, 'contributor', 'store team lessons');
-            if (learnDenied)
-                return learnDenied;
-            // Store with author attribution via the same learn_from_attempts Redis structure
-            const lesson = {
-                topic, outcome, what_worked,
-                what_failed: what_failed ?? '',
-                severity: severity ?? 'minor',
-                author,
-                file_paths: file_paths ?? [],
-                commands: commands ?? [],
-                tags: [...(tags ?? []), 'team'],
-                timestamp: new Date().toISOString(),
-                recall_count: 0,
-                version: 2,
-            };
-            // P1-1 Lessons-Review: when the org enabled pending-mode, the lesson
-            // becomes a proposal (cachly:lesson:proposed:<topic>) instead of landing
-            // in the recall keyspace. Default (flag absent) = direct write, as before.
-            if (await reviewModeEnabled(redisTL, iid)) {
-                return storeLessonProposal(redisTL, topic, lesson);
-            }
-            const key = `cachly:lessons:${topic}`;
-            await redisTL.rpush(key, JSON.stringify(lesson));
-            if (outcome === 'success') {
-                await redisTL.set(`cachly:lesson:best:${topic}`, JSON.stringify(lesson));
-            }
-            return `✅ Team lesson stored by **${author}**: \`${topic}\` (${outcome})\n💡 ${what_worked.slice(0, 120)}`;
-        }
-        // ── team_confirm — knowledge governance (Phase 3) ─────────────────────────
-        // A human reviewer endorses a stored lesson. The endorsement raises the
-        // lesson's recall ranking (see src/rerank.ts), so trusted, reviewed knowledge
-        // surfaces above unreviewed auto-learned entries.
-        case 'team_confirm': {
-            const { instance_id, topic, reviewer, level, note = '' } = args;
-            if (!instance_id)
-                return '❌ instance_id required';
-            if (!topic || !reviewer)
-                return '❌ Required: topic, reviewer';
-            const redis = await getConnection(instance_id);
-            // W6 enforcement: once governance is active, only reviewer+ may confirm
-            // lessons (vision: "nur reviewer dürfen team_confirm"). Open teams are
-            // unaffected. A denied confirm returns guidance, never throws.
-            const confirmDenied = await requireRole(redis, instance_id, reviewer, 'reviewer', 'confirm team lessons');
-            if (confirmDenied)
-                return confirmDenied;
-            // Role-aware review level: if the reviewer has an assigned role, that determines
-            // weight (admin/reviewer → senior, contributor → peer). The caller can still
-            // pass `level` explicitly to override (e.g. a guest reviewer without a role).
-            // This prevents self-promotion — you can't claim senior by just passing level="senior".
-            const assignedRole = await getRole(redis, instance_id, reviewer);
-            const autoLevel = roleToReviewLevel(assignedRole);
-            // If the caller explicitly asked for 'peer' on a senior-role reviewer,
-            // honour that (downgrade is allowed; upgrade is not — unless they have the role).
-            const reviewLevel = level === 'peer' ? 'peer'
-                : level === 'senior' && hasPermission(assignedRole, 'reviewer') ? 'senior'
-                    : autoLevel;
-            const roleNote = assignedRole
-                ? ` (role: ${ROLE_BADGE[assignedRole]} ${assignedRole})`
-                : ` (no role assigned — peer weight applied)`;
-            const key = `cachly:lesson:best:${topic}`;
-            const raw = await redis.get(key);
-            const lesson = safeJsonParse(raw, null);
-            if (!lesson) {
-                return `📭 No best-solution lesson found for \`${topic}\`.\n\nA lesson must exist (store one with \`team_learn\` / \`learn_from_attempts\`) before it can be confirmed.`;
-            }
-            // Track distinct reviewers so endorsements can't be inflated by one person.
-            const endorsersKey = `cachly:lesson:endorsers:${topic}`;
-            const isNewEndorser = (await redis.sadd(endorsersKey, reviewer)) === 1;
-            await redis.expire(endorsersKey, 365 * 86400);
-            const endorsements = await redis.scard(endorsersKey);
-            // Senior beats peer; never downgrade an existing senior review to peer.
-            const prevLevel = lesson.review_level ?? '';
-            const effectiveLevel = prevLevel === 'senior' ? 'senior' : reviewLevel;
-            const updated = {
-                ...lesson,
-                reviewed_by: reviewer,
-                review_level: effectiveLevel,
-                endorsements,
-                reviewed_at: new Date().toISOString(),
-            };
-            await redis.set(key, JSON.stringify(updated));
-            // Append an immutable review record for the audit trail.
-            const reviewLog = {
-                reviewer, level: reviewLevel, note: note.slice(0, 280), ts: new Date().toISOString(),
-            };
-            const logKey = `cachly:lesson:reviews:${topic}`;
-            await redis.rpush(logKey, JSON.stringify(reviewLog));
-            await redis.ltrim(logKey, -50, -1);
-            await redis.expire(logKey, 365 * 86400);
-            // Governance audit trail (W6): every confirm is recorded brain-wide so an
-            // admin can answer "who endorsed what, and when" for compliance.
-            await auditLog(redis, instance_id, {
-                action: 'team_confirm', actor: reviewer, topic, level: effectiveLevel,
-            });
-            const badge = effectiveLevel === 'senior' ? '🛡️ senior-reviewed' : '✔️ peer-reviewed';
-            const alreadyNote = isNewEndorser ? '' : ` (already endorsed by ${reviewer} — no change to rank)`;
-            return `${badge} — \`${topic}\` confirmed by **${reviewer}**${roleNote} (${endorsements} distinct endorsement${endorsements === 1 ? '' : 's'})${alreadyNote}.\n📈 This lesson now ranks higher in \`smart_recall\` / \`team_recall\`.${note ? `\n📝 ${note.slice(0, 200)}` : ''}`;
-        }
-        // ── team_recall ───────────────────────────────────────────────────────────
-        case 'team_recall': {
-            const { instance_id, topic, author, limit = 10 } = args;
-            const redis = await getConnection(instance_id);
-            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);
-            });
-            let 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);
-                }
-            }
-            // Filter
-            if (topic) {
-                const t = topic.toLowerCase();
-                lessons = lessons.filter(l => l.topic.toLowerCase().includes(t) ||
-                    (l.tags ?? []).some((tag) => tag.toLowerCase().includes(t)));
-            }
-            if (author) {
-                const a = author.toLowerCase();
-                lessons = lessons.filter(l => l.author?.toLowerCase().includes(a));
-            }
-            // Sort: reviewed lessons first (senior > peer), then by recall_count desc.
-            const reviewRank = (l) => l.reviewed_by ? (l.review_level === 'senior' ? 2 : 1) : 0;
-            lessons.sort((a, b) => (reviewRank(b) - reviewRank(a)) || ((b.recall_count ?? 0) - (a.recall_count ?? 0)));
-            lessons = lessons.slice(0, limit);
-            if (lessons.length === 0) {
-                return topic
-                    ? `📭 No team lessons found for \`${topic}\`.\n\nShared instance: add lessons with \`learn_from_attempts\` and include an \`author\` field.`
-                    : `📭 No lessons in this brain yet.\n\nAll team members sharing this instance will see lessons here.`;
-            }
-            const lines = [`👥 **Team Brain** — ${lessons.length} lesson${lessons.length > 1 ? 's' : ''}`, ''];
-            for (const l of lessons) {
-                const emoji = l.outcome === 'success' ? '✅' : l.outcome === 'partial' ? '⚠️' : '❌';
-                const sev = l.severity === 'critical' ? '🔴 ' : l.severity === 'major' ? '🟡 ' : '';
-                const reviewBadge = l.reviewed_by
-                    ? (l.review_level === 'senior' ? ' 🛡️' : ' ✔️')
-                    : '';
-                const authorStr = l.author ? ` · _by ${l.author}_` : '';
-                const reviewStr = l.reviewed_by
-                    ? ` · reviewed by ${l.reviewed_by}${(l.endorsements ?? 0) > 1 ? ` +${(l.endorsements ?? 0) - 1}` : ''}`
-                    : '';
-                const recallStr = (l.recall_count ?? 0) > 0 ? ` · recalled ${l.recall_count}×` : '';
-                const ago = Math.round((Date.now() - new Date(l.ts).getTime()) / 86400000);
-                const agoStr = ago === 0 ? 'today' : ago === 1 ? 'yesterday' : `${ago}d ago`;
-                lines.push(`${emoji} ${sev}**\`${l.topic}\`**${reviewBadge}${authorStr}${reviewStr}${recallStr} · ${agoStr}`);
-                lines.push(`   ${l.what_worked.slice(0, 120)}`);
-                lines.push('');
-            }
-            return lines.join('\n');
-        }
-        // ── team_synthesize — Team Brain Synthesis ────────────────────────────────
-        case 'team_synthesize': {
-            const { instance_id, topic } = args;
-            const redis = await getConnection(instance_id);
-            // Load history list for this topic (all authors' contributions)
-            const listKey = `cachly:lessons:${topic}`;
-            const all = await redis.lrange(listKey, 0, -1);
-            if (all.length < 2) {
-                return `📭 Need at least 2 entries for topic \`${topic}\` to synthesize.\n\nCurrently: ${all.length} entr${all.length === 1 ? 'y' : 'ies'}.\n\nHave team members store lessons via \`learn_from_attempts(topic="${topic}", ...)\`.`;
-            }
-            const entries = all.map(r => { try {
-                return JSON.parse(r);
-            }
-            catch {
-                return null;
-            } }).filter((e) => e !== null);
-            // Group by outcome
-            const successes = entries.filter(e => e.outcome === 'success');
-            const failures = entries.filter(e => e.outcome === 'failure');
-            const partials = entries.filter(e => e.outcome === 'partial');
-            const authors = [...new Set(entries.map(e => e.author).filter(Boolean))];
-            const hasMultiAuthor = authors.length > 1;
-            // Build canonical merged version
-            // what_worked: pick the most recent success, or longest for most detail
-            const bestSuccess = successes.sort((a, b) => new Date(b.ts).getTime() - new Date(a.ts).getTime())[0];
-            const whatWorkedCandidates = successes.map(e => e.what_worked).filter(w => w && w.length > 10);
-            const canonicalWorked = whatWorkedCandidates.sort((a, b) => b.length - a.length)[0] ?? bestSuccess?.what_worked ?? '';
-            // what_failed: union of all unique failure reasons
-            const allFailed = [...new Set([...failures, ...partials].map(e => e.what_failed).filter((w) => !!w && w.length > 5))];
-            const severities = entries.map(e => e.severity).filter(Boolean);
-            const canonicalSeverity = severities.includes('critical') ? 'critical' : severities.includes('major') ? 'major' : 'minor';
-            const lines = [
-                `🧬 **Team Brain Synthesis: \`${topic}\`**`,
-                `_${entries.length} entries from ${authors.length} author${authors.length === 1 ? '' : 's'}${hasMultiAuthor ? ` (${authors.join(', ')})` : ''} · ${successes.length} success · ${failures.length} failure · ${partials.length} partial_`,
-                '',
-                `**Canonical "what worked":**`,
-                `> ${canonicalWorked}`,
-                '',
-                allFailed.length > 0 ? `**Avoid (combined failures):**` : '',
-                ...allFailed.map(f => `> ❌ ${f}`),
-                allFailed.length > 0 ? '' : '',
-                `**Suggested canonical lesson:**`,
-                '```',
-                `learn_from_attempts(`,
-                `  topic       = "${topic}",`,
-                `  outcome     = "success",`,
-                `  what_worked = "${canonicalWorked.replace(/"/g, "'")}",`,
-                allFailed.length > 0 ? `  what_failed = "${allFailed[0].replace(/"/g, "'")}",` : '',
-                `  severity    = "${canonicalSeverity}",`,
-                `)`,
-                '```',
-                '',
-                hasMultiAuthor
-                    ? `💡 _${authors.length} team members contributed to this synthesis. Store the canonical version to replace individual entries._`
-                    : `💡 _Single author — more value when multiple team members contribute to the same topic._`,
-            ].filter(l => l !== undefined).join('\n');
-            return lines;
-        }
-        // ── brain_doctor ──────────────────────────────────────────────────────────
-        // ── memory_crystalize ─────────────────────────────────────────────────────
-        case 'memory_crystalize': {
-            const { instance_id, label: crystalLabel = '' } = args;
-            const redis = await getConnection(instance_id);
-            const now = new Date();
-            const week = `${now.getFullYear()}-W${String(Math.ceil((now.getDate() - now.getDay() + 10) / 7)).padStart(2, '0')}`;
-            const effectiveLabel = crystalLabel || `${now.toISOString().slice(0, 7)} Crystal`;
-            // Read session history
-            const sessionHistory = await redis.lrange('cachly:session:history', 0, 49);
-            // Read all auto-learned lessons
-            const allLessonKeys = [];
-            const ls = redis.scanStream({ match: 'cachly:lesson:best:*', count: 200 });
-            await new Promise((res, rej) => {
-                ls.on('data', (b) => allLessonKeys.push(...b));
-                ls.on('end', res);
-                ls.on('error', rej);
-            });
-            const allLessons = [];
-            if (allLessonKeys.length > 0) {
-                const raws = await redis.mget(...allLessonKeys);
-                for (const raw of raws) {
-                    const l = safeJsonParse(raw ?? null, null);
-                    if (l)
-                        allLessons.push(l);
-                }
-            }
-            // Group lessons by top-level category
-            const categoryMap = new Map();
-            for (const l of allLessons) {
-                const cat = l.topic.split(':')[0] || 'misc';
-                if (!categoryMap.has(cat))
-                    categoryMap.set(cat, []);
-                categoryMap.get(cat).push(l);
-            }
-            // Build top patterns (most frequent categories with a representative insight)
-            const topPatterns = [];
-            for (const [cat, catLessons] of [...categoryMap.entries()].sort((a, b) => b[1].length - a[1].length).slice(0, 8)) {
-                const successLessons = catLessons.filter(l => l.outcome === 'success');
-                const best = successLessons[0] ?? catLessons[0];
-                if (!best)
-                    continue;
-                topPatterns.push({
-                    category: cat,
-                    insight: best.what_worked.slice(0, 120),
-                    count: catLessons.length,
-                });
-            }
-            const crystal = {
-                label: effectiveLabel,
-                ts: now.toISOString(),
-                session_count: sessionHistory.length,
-                lesson_count: allLessons.length,
-                top_patterns: topPatterns,
-                categories: [...categoryMap.keys()],
-                created_from: `${sessionHistory.length} sessions, ${allLessons.length} lessons`,
-            };
-            const crystalJson = JSON.stringify(crystal);
-            await redis.set('cachly:crystal:latest', crystalJson);
-            await redis.expire('cachly:crystal:latest', 90 * 86400);
-            await redis.set(`cachly:crystal:${week}`, crystalJson);
-            await redis.expire(`cachly:crystal:${week}`, 365 * 86400);
-            const lines = [
-                `💎 **Memory Crystal created: ${effectiveLabel}**`,
-                ``,
-                `📊 Compressed: **${sessionHistory.length} sessions** + **${allLessons.length} lessons** → ${topPatterns.length} top patterns`,
-                ``,
-                `**Top patterns by category:**`,
-                ...topPatterns.slice(0, 6).map(p => `  • **${p.category}** (${p.count}×): ${p.insight.slice(0, 90)}`),
-                ``,
-                `💡 This crystal will appear in every future \`session_start\` briefing.`,
-                `💡 Re-run \`memory_crystalize\` monthly to keep it fresh.`,
-            ];
-            return lines.join('\n');
-        }
-        // ── team_crystallize (W8) ───────────────────────────────────────────────────
-        // The team-wide, causal counter to per-user "Dreaming". Where memory_crystalize
-        // compresses ONE brain by category, team_crystallize surfaces what a single-user
-        // background process structurally cannot: which fixes solved structurally
-        // SIMILAR problems across MULTIPLE people. A pattern only crystallizes when ≥2
-        // distinct authors converged on it — that cross-person signal is the moat.
-        case 'team_crystallize': {
-            const { instance_id, min_authors = 2, label: tcLabel = '' } = args;
-            const redis = await getConnection(instance_id);
-            const now = new Date();
-            const minAuthors = Math.max(2, Number(min_authors) || 2);
-            // Load every best-lesson with its author + tags (the cross-person signal).
-            const keys = [];
-            const stream = redis.scanStream({ match: 'cachly:lesson:best:*', count: 200 });
-            await new Promise((res, rej) => {
-                stream.on('data', (b) => keys.push(...b));
-                stream.on('end', res);
-                stream.on('error', rej);
-            });
-            const lessons = [];
-            if (keys.length > 0) {
-                const raws = await redis.mget(...keys);
-                for (const raw of raws) {
-                    const l = safeJsonParse(raw ?? null, null);
-                    if (l && l.outcome === 'success' && l.author)
-                        lessons.push(l);
-                }
-            }
-            // Derive a structural "concept key" for each lesson: the topic namespace plus
-            // its most significant problem token, so "db:pool-exhaustion" and
-            // "payments:connection-pool" can converge via the shared "pool" concept.
-            const STOP = new Set(['the', 'and', 'for', 'with', 'from', 'that', 'this', 'fix', 'bug', 'error', 'issue', 'use', 'via', 'add', 'set', 'team']);
-            const conceptOf = (l) => {
-                const [ns, ...rest] = l.topic.split(':');
-                // Tags are deliberate concept markers — two people who both tag a lesson
-                // "pool" intend the same concept even when their topics differ. Prefer a
-                // shared, intentional tag over a topic-derived token. Alphabetically-first
-                // significant tag keeps the choice deterministic across authors.
-                const sigTags = (l.tags ?? [])
-                    .map(t => t.toLowerCase().trim())
-                    .filter(t => t.length > 3 && !STOP.has(t))
-                    .sort();
-                if (sigTags.length > 0)
-                    return sigTags[0];
-                // No usable tag — fall back to the longest topic-tail token.
-                const tail = rest.join('-').toLowerCase();
-                const tokens = tail.replace(/[^a-z0-9\s-]/g, ' ').split(/[\s-]+/)
-                    .filter(t => t.length > 3 && !STOP.has(t));
-                return tokens.sort((a, b) => b.length - a.length || a.localeCompare(b))[0] ?? ns;
-            };
-            const clusters = new Map();
-            for (const l of lessons) {
-                const concept = conceptOf(l);
-                let c = clusters.get(concept);
-                if (!c) {
-                    c = { concept, authors: new Set(), lessons: [], namespaces: new Set(), bestFix: l };
-                    clusters.set(concept, c);
-                }
-                c.authors.add(l.author.toLowerCase());
-                c.lessons.push(l);
-                c.namespaces.add(l.topic.split(':')[0] || 'misc');
-                // Best fix = highest community trust (endorsements > confirm_count), senior-reviewed wins ties.
-                const score = (x) => (x.endorsements ?? 0) * 10 + (x.confirm_count ?? 0) + (x.review_level === 'senior' ? 5 : 0);
-                if (score(l) > score(c.bestFix))
-                    c.bestFix = l;
-            }
-            // A pattern crystallizes only when enough DISTINCT people converged on it.
-            const crossPerson = [...clusters.values()]
-                .filter(c => c.authors.size >= minAuthors)
-                .sort((a, b) => (b.authors.size - a.authors.size) || (b.lessons.length - a.lessons.length));
-            const patterns = crossPerson.slice(0, 10).map(c => ({
-                concept: c.concept,
-                author_count: c.authors.size,
-                authors: [...c.authors],
-                lesson_count: c.lessons.length,
-                spans: [...c.namespaces],
-                convergent_fix: c.bestFix.what_worked.slice(0, 200),
-                fix_topic: c.bestFix.topic,
-            }));
-            // Persist the team crystal alongside (not overwriting) the per-brain crystal.
-            const effectiveLabel = tcLabel || `${now.toISOString().slice(0, 7)} Team Crystal`;
-            const crystal = {
-                label: effectiveLabel, ts: now.toISOString(), kind: 'team',
-                contributors: new Set(lessons.map(l => l.author.toLowerCase())).size,
-                analysed: lessons.length, patterns,
-            };
-            await redis.set('cachly:crystal:team:latest', JSON.stringify(crystal));
-            await redis.expire('cachly:crystal:team:latest', 180 * 86400);
-            if (patterns.length === 0) {
-                return [
-                    `💠 **Team Crystal — not enough cross-person convergence yet**`,
-                    ``,
-                    `Analysed **${lessons.length}** attributed success lessons from **${crystal.contributors}** contributor${crystal.contributors !== 1 ? 's' : ''}, but no concept had **${minAuthors}+ distinct authors** converge on it yet.`,
-                    ``,
-                    `This is the one thing a per-user memory can't build — it needs your team to accumulate shared, attributed lessons.`,
-                    `Keep using \`learn_from_attempts(author="...")\` / \`team_learn\`; re-run as the team grows.`,
-                ].join('\n');
-            }
-            const lines = [
-                `💠 **Team Crystal created: ${effectiveLabel}**`,
-                ``,
-                `🧬 **${patterns.length} cross-person pattern${patterns.length !== 1 ? 's' : ''}** — fixes that ${minAuthors}+ teammates independently converged on.`,
-                `_Compressed from ${lessons.length} attributed lessons across ${crystal.contributors} contributors. This is the team-wide, causal layer a per-user "Dreaming" process structurally cannot produce._`,
-                ``,
-            ];
-            for (const p of patterns.slice(0, 6)) {
-                const spanNote = p.spans.length > 1 ? ` · spans ${p.spans.map(s => `\`${s}\``).join(', ')}` : '';
-                lines.push(`### 🧩 \`${p.concept}\` — ${p.author_count} people converged${spanNote}`, `**Convergent fix** (from \`${p.fix_topic}\`): ${p.convergent_fix}`, `**Who solved it together:** ${p.authors.map(a => `@${a}`).join(', ')} _(ask them — they've each hit this)_`, ``);
-            }
-            lines.push(`---`, `💡 Surfaces in \`crystal_view\` and onboarding. Re-run \`team_crystallize\` monthly.`);
-            return lines.join('\n');
-        }
-        case 'brain_doctor': {
-            const { instance_id, workspace_path: drWorkspacePath = '' } = args;
-            const redis = await getConnection(instance_id);
-            const issues = [];
-            const checks = [];
-            // Count 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);
-            });
-            // Count context
-            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);
-            });
-            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);
-                }
-            }
-            // Last session
-            const lastSessionRaw = await redis.get('cachly:session:last');
-            const lastSession = safeJsonParse(lastSessionRaw, null);
-            // Open failures
-            const openFailures = lessons.filter(l => l.outcome === 'failure' || l.outcome === 'partial');
-            // Unused lessons (never recalled)
-            const unusedLessons = lessons.filter(l => (l.recall_count ?? 0) === 0);
-            // Critical lessons
-            const criticalLessons = lessons.filter(l => l.severity === 'critical');
-            // Confidence decay analysis
-            const staleLessons = lessons.filter(l => l.outcome === 'success' && calculateConfidence(l) < CONFIDENCE_STALE_VALUE);
-            const warnLessons = lessons.filter(l => l.outcome === 'success' && calculateConfidence(l) >= CONFIDENCE_STALE_VALUE && calculateConfidence(l) < CONFIDENCE_WARN_VALUE);
-            const withAudit = lessons.filter(l => (l.audit_trail ?? []).length > 1);
-            const teamLessons = lessons.filter(l => l.author);
-            const uniqueAuthors = new Set(lessons.map(l => l.author).filter(Boolean));
-            // Effective IQ boost: total recalls / lessons (how much the brain actually helped)
-            const totalRecalls = lessons.reduce((sum, l) => sum + (l.recall_count ?? 0), 0);
-            const iqBoostPct = lessons.length > 0 ? Math.min(100, Math.round((totalRecalls / lessons.length) * 10)) : 0;
-            // ── Deckung des Bedeutungsabgleichs ─────────────────────────────────
-            //
-            // Gemessen am 20.08.2026 gegen die Produktion: `cachly:lesson:vec:*` war
-            // LEER — 0 Vektoren bei 506 Lektionen. Damit lief der Bedeutungsabgleich
-            // dort nie: `brain.ts` steigt bei `vektorbestand.groesse === 0` aus und
-            // faellt auf den reinen Wortabgleich zurueck.
-            //
-            // Von aussen war dieser Zustand von "alles in Ordnung" nicht zu
-            // unterscheiden — die Suche lieferte weiter Ergebnisse, nur schlechtere.
-            // Genau das ist die Fehlerklasse "Stille wird als gruen gebucht": es gab
-            // eine Zahl fuer alles Moegliche, aber keine fuer DAS.
-            const zaehleSchluessel = async (muster) => {
-                let n = 0;
-                const st = redis.scanStream({ match: muster, count: 200 });
-                await new Promise((resolve, reject) => {
-                    st.on('data', (batch) => { n += batch.length; });
-                    st.on('end', resolve);
-                    st.on('error', reject);
-                });
-                return n;
-            };
-            const vektorZahl = await zaehleSchluessel('cachly:lesson:vec:*');
-            const namensZahl = await zaehleSchluessel('cachly:lesson:vecname:*');
-            const eingangZahl = await zaehleSchluessel('cachly:lesson:eing:*');
-            const pfadZahl = await zaehleSchluessel('cachly:lesson:pfad:*');
-            const deckung = lessonKeys.length > 0
-                ? Math.round((vektorZahl / lessonKeys.length) * 100)
-                : 100;
-            const urteil = beurteileDeckung(lessonKeys.length, vektorZahl);
-            if (lessonKeys.length > 0) {
-                if (urteil === 'aus') {
-                    issues.push('semantic search is OFF: not a single lesson has an embedding '
-                        + `(0 of ${lessonKeys.length}). Recall falls back to keyword matching only. `
-                        + 'Fix: run the backfill (sdk/mcp/src/eingaenge-nachruesten.ts).');
-                    checks.push(`🔴 **Semantic search: OFF** — 0 of ${lessonKeys.length} lessons have an embedding`);
-                }
-                else if (urteil === 'luecke') {
-                    issues.push(`only ${deckung}% of lessons have an embedding (${vektorZahl} of ${lessonKeys.length}) — `
-                        + 'the rest can never be found by meaning.');
-                    checks.push(`🟡 **Semantic coverage: ${deckung}%** — ${lessonKeys.length - vektorZahl} lessons without an embedding`);
-                }
-                else {
-                    checks.push(`✅ **Semantic coverage: ${deckung}%** — ${vektorZahl} full-text, `
-                        + `${namensZahl} topic-name, ${eingangZahl} with error-text entries`
-                        + (pfadZahl > 0 ? `, ${pfadZahl} with learned question paths` : ''));
-                    // Die Trampelpfade sind das einzige, was MIT DER NUTZUNG waechst.
-                    // Steht die Zahl auf null, obwohl schon lange gesucht wird, lernt
-                    // das Gedaechtnis nichts dazu — das ist eine eigene Auskunft.
-                    if (pfadZahl === 0 && lessonKeys.length >= 20) {
-                        checks.push('💤 **No learned question paths yet** — a question that finds the same '
-                            + 'lesson twice becomes its own entry. Needs repeated real use.');
-                    }
-                }
-            }
-            // Quality score (0-100)
-            let score = 50;
-            if (lessonKeys.length >= 5)
-                score += 10;
-            if (lessonKeys.length >= 20)
-                score += 10;
-            if (ctxCount >= 3)
-                score += 10;
-            if (ctxCount >= 10)
-                score += 5;
-            if (lastSession)
-                score += 10;
-            if (openFailures.length === 0)
-                score += 5;
-            const unusedRatio = lessons.length > 0 ? unusedLessons.length / lessons.length : 0;
-            if (unusedRatio < 0.5)
-                score += 10;
-            if (staleLessons.length === 0)
-                score += 5;
-            if (uniqueAuthors.size >= 2)
-                score += 5; // team collaboration bonus
-            // Ohne Einbettungen laeuft die halbe Suche nicht — das darf keine
-            // Randnotiz sein, sondern muss die Zahl druecken, die oben steht.
-            if (urteil !== 'gut')
-                score -= 20;
-            score = Math.max(0, Math.min(100, score));
-            const scoreEmoji = score >= 80 ? '🟢' : score >= 50 ? '🟡' : '🔴';
-            const iqEmoji = iqBoostPct >= 50 ? '🚀' : iqBoostPct >= 20 ? '📈' : '💤';
-            checks.push(`${scoreEmoji} **Brain Quality Score: ${score}/100**`);
-            checks.push(`${iqEmoji} **Effective IQ Boost: ${iqBoostPct}%** (${totalRecalls} recalls across ${lessons.length} lessons)`);
-            checks.push(`📚 **Lessons:** ${lessonKeys.length} (${criticalLessons.length} critical · ${withAudit.length} with audit trail · ${teamLessons.length} from team)`);
-            checks.push(`💾 **Context entries:** ${ctxCount}`);
-            checks.push(`🎯 **Confidence:** ${lessons.length - staleLessons.length - warnLessons.length} fresh · ${warnLessons.length} warn · ${staleLessons.length} stale`);
-            checks.push(`⏱️ **Decay config:** warn after ${CONFIDENCE_WARN_DAYS}d · stale after ${CONFIDENCE_STALE_DAYS}d`);
-            checks.push(formatiereBauabdruck(bauabdruck));
-            // ── Was tut der Speicher WIRKLICH ────────────────────────────────────
-            //
-            // Neu am 20.08.2026. Bis dahin meldete brain_doctor, wie viele Lektionen
-            // da sind — aber nicht, ob der Speicher sie behaelt. Eine Instanz lief
-            // monatelang auf `allkeys-lru` und haette bei Platzmangel die aeltesten
-            // Lektionen still geloescht. Der Code war seit April richtig; ein
-            // Container behaelt aber den Startbefehl, mit dem er erzeugt wurde.
-            //
-            // Ein Test beweist die Absicht. Diese Zeilen messen den Zustand.
-            try {
-                const info = await redis.info('memory');
-                let richtlinie = null;
-                try {
-                    const cfg = await redis.config('GET', 'maxmemory-policy');
-                    richtlinie = Array.isArray(cfg) && cfg.length > 1 ? String(cfg[1]) : null;
-                }
-                catch {
-                    // CONFIG GET ist auf manchen verwalteten Speichern gesperrt. Dann
-                    // bleibt richtlinie null — und beurteileSpeicher sagt "nicht
-                    // gemessen" statt "in Ordnung".
-                    richtlinie = null;
-                }
-                const lage = {
-                    benutzt: zahlAusInfo(info, 'used_memory'),
-                    grenze: zahlAusInfo(info, 'maxmemory'),
-                    richtlinie,
-                };
-                for (const u of beurteileSpeicher(lage)) {
-                    const zeichen = u.art === 'fehler' ? '🔴' : u.art === 'hinweis' ? '🟡' : u.art === 'ungemessen' ? '⚪' : '🟢';
-                    const zeile = `${zeichen} **Speicher:** ${u.text}`;
-                    if (u.art === 'fehler' || u.art === 'ungemessen')
-                        issues.push(zeile);
-                    else
-                        checks.push(zeile);
-                }
-            }
-            catch {
-                // Auch das Scheitern der Messung ist eine Nachricht, keine Stille.
-                issues.push('⚪ **Speicher:** Lage nicht abfragbar — unbekannt, ob dieser Speicher bei Platzmangel still loescht.');
-            }
-            if (uniqueAuthors.size >= 2) {
-                checks.push(`👥 **Team:** ${uniqueAuthors.size} contributors (${[...uniqueAuthors].join(', ')})`);
-            }
-            // Stale index detection
-            try {
-                const lastIndexRaw = await redis.get('cachly:index:last_run');
-                if (lastIndexRaw) {
-                    const lastIndexAge = Math.round((Date.now() - new Date(lastIndexRaw).getTime()) / 86_400_000);
-                    if (lastIndexAge > 7) {
-                        issues.push(`🔄 Index is ${lastIndexAge}d stale — run \`index_project\` to re-sync semantic search`);
-                    }
-                    else {
-                        checks.push(`🗂️ **Semantic index:** ${lastIndexAge}d old (fresh)`);
-                    }
-                }
-                else {
-                    issues.push(`💡 No semantic index — run \`index_project(dir="<your-src>")\` to enable semantic search`);
-                }
-            }
-            catch { /* non-critical */ }
-            // Memory crystal status
-            try {
-                const crystalRaw = await redis.get('cachly:crystal:latest');
-                if (crystalRaw) {
-                    const crystal = JSON.parse(crystalRaw);
-                    const crystalAge = Math.round((Date.now() - new Date(crystal.ts).getTime()) / 86_400_000);
-                    checks.push(`💎 **Memory Crystal:** ${crystal.label} (${crystalAge}d ago)`);
-                    if (crystalAge > 30)
-                        issues.push(`💡 Memory Crystal is ${crystalAge}d old — re-run \`memory_crystalize\` to compress new sessions`);
-                }
-                else if (lessonKeys.length >= 10) {
-                    issues.push(`💡 ${lessonKeys.length} lessons but no Memory Crystal — run \`memory_crystalize\` to compress wisdom`);
-                }
-            }
-            catch { /* non-critical */ }
-            // openclaw cross-promo (check package.json in workspace)
-            if (drWorkspacePath) {
-                try {
-                    const pkgPath = drWorkspacePath.replace(/\/$/, '') + '/package.json';
-                    const pkgRaw = readFileSync(pkgPath, 'utf-8');
-                    const pkg = JSON.parse(pkgRaw);
-                    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-                    const hasLLMDep = ['openai', '@anthropic-ai/sdk', '@google/generative-ai', 'mistralai', 'cohere-ai'].some(d => d in allDeps);
-                    const hasOpenclaw = '@cachly-dev/openclaw' in allDeps;
-                    if (hasLLMDep && !hasOpenclaw) {
-                        issues.push(`💡 **openclaw missing:** you use LLM APIs (${Object.keys(allDeps).filter(d => ['openai', '@anthropic-ai/sdk'].includes(d)).join(', ')}) but not \`@cachly-dev/openclaw\``);
-                        issues.push(`   → \`npm install @cachly-dev/openclaw\` cuts LLM costs 60–90% with 3 lines of code`);
-                    }
-                    else if (hasOpenclaw) {
-                        checks.push(`✅ **@cachly-dev/openclaw installed** (LLM cost caching active)`);
-                    }
-                }
-                catch { /* no package.json or unreadable */ }
-            }
-            if (lastSession) {
-                const ageMin = Math.round((Date.now() - new Date(lastSession.ts).getTime()) / 60000);
-                const ageStr = ageMin < 60 ? `${ageMin}m` : ageMin < 1440 ? `${Math.round(ageMin / 60)}h` : `${Math.round(ageMin / 1440)}d`;
-                checks.push(`🕐 **Last session:** ${ageStr} ago`);
-            }
-            else {
-                issues.push('❌ No session history — call `session_start` + `session_end` to start tracking');
-            }
-            if (lessonKeys.length === 0) {
-                issues.push('❌ No lessons — call `learn_from_attempts` after solving bugs');
-            }
-            else if (lessonKeys.length < 5) {
-                issues.push(`💡 Only ${lessonKeys.length} lessons — add more after each problem solved`);
-            }
-            if (iqBoostPct === 0 && lessons.length >= 5) {
-                issues.push(`💤 **IQ Boost is 0%** — lessons exist but are never recalled. Use \`recall_best_solution\` BEFORE tasks.`);
-            }
-            if (ctxCount === 0) {
-                issues.push('💡 No context — use `remember_context` to cache architecture docs, ADRs, etc.');
-            }
-            if (openFailures.length > 0) {
-                issues.push(`⚠️ ${openFailures.length} unresolved failure${openFailures.length > 1 ? 's' : ''}: ${openFailures.slice(0, 3).map(l => `\`${l.topic}\``).join(', ')}`);
-            }
-            if (staleLessons.length > 0) {
-                issues.push(`🔴 ${staleLessons.length} STALE lesson${staleLessons.length > 1 ? 's' : ''} (>${CONFIDENCE_STALE_DAYS}d, confidence <${CONFIDENCE_STALE_VALUE * 100}%): ${staleLessons.slice(0, 3).map(l => `\`${l.topic}\``).join(', ')}`);
-                issues.push(`   → Re-verify with \`recall_best_solution\` to reset confidence clock`);
-            }
-            if (warnLessons.length > 0) {
-                issues.push(`⚠️ ${warnLessons.length} lesson${warnLessons.length > 1 ? 's' : ''} aging (>${CONFIDENCE_WARN_DAYS}d): ${warnLessons.slice(0, 3).map(l => `\`${l.topic}\``).join(', ')}`);
-            }
-            if (unusedRatio > 0.7 && lessons.length > 5) {
-                issues.push(`💡 ${unusedLessons.length} lessons never recalled — verify topics match your workflow`);
-            }
-            const divider = '─'.repeat(48);
-            const lines = [
-                `🩺 **Brain Doctor**`,
-                `\`${divider}\``,
-                '',
-                '**📊 Health Checks**',
-                ...checks.map(c => '  ' + c),
-                '',
-            ];
-            if (issues.length > 0) {
-                lines.push(`**🔧 Action Items** (${issues.length} issue${issues.length > 1 ? 's' : ''})`);
-                issues.forEach((item, idx) => lines.push(`  ${idx + 1}. ${item}`));
-                lines.push('');
-                lines.push(`_Fix the action items above, then re-run \`brain_doctor\` to verify._`);
-            }
-            else {
-                lines.push('**✅ All checks passed** — Brain is healthy!');
-                lines.push('');
-                lines.push('_Keep the brain sharp: `session_start` → work → `learn_from_attempts` → `session_end`_');
-            }
-            return lines.join('\n');
-        }
-        // ── brain_hygiene — autonomous Brain maintenance sweep ────────────────────
-        //
-        // Runs a full lesson sweep and applies three automated hygiene rules:
-        //
-        //  1. Decay flagging: lessons where confidence < PROVISIONAL_THRESHOLD
-        //     (default 0.5) are marked state="provisional". They still appear in
-        //     smart_recall with a ⚠️ badge but callers know to re-verify.
-        //
-        //  2. Archival: lessons that are provisional AND have recall_count < 2 AND
-        //     are older than ARCHIVE_DAYS (default 30) are moved to state="archived".
-        //     Archived lessons are excluded from smart_recall results but kept for
-        //     audit_trail inspection.
-        //
-        //  3. Contradiction auto-resolution: when the same topic has both a failure
-        //     and a success lesson, and the success has recall_count ≥ 3× the
-        //     failure's recall_count, the failure lesson is archived automatically.
-        //     The resolution is recorded in both lessons' audit_trail.
-        //
-        // dry_run=true (default false) reports what would change without writing.
-        case 'brain_hygiene': {
-            const { instance_id, dry_run = false, provisional_threshold = 0.5, archive_days = 30, } = args;
-            const redis = await getConnection(instance_id);
-            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);
-            });
-            if (lessonKeys.length === 0) {
-                return '🧹 **Brain Hygiene** — no lessons found. Nothing to sweep.';
-            }
-            const rawValues = await redis.mget(...lessonKeys);
-            const lessons = [];
-            for (let i = 0; i < lessonKeys.length; i++) {
-                const raw = rawValues[i];
-                const l = safeJsonParse(raw ?? null, null);
-                if (l)
-                    lessons.push({ ...l, _key: lessonKeys[i] });
-            }
-            const nowMs = Date.now();
-            const provisionalKeys = [];
-            const archivedKeys = [];
-            const conflictResolutions = [];
-            const updates = new Map(); // key → updated lesson
-            // ── Rule 1 + 2: decay flagging + archival ─────────────────────────────
-            for (const lesson of lessons) {
-                const currentState = lesson.state ?? 'active';
-                if (currentState === 'archived')
-                    continue; // already done
-                const conf = calculateConfidence(lesson);
-                const refMs = new Date(lesson.verified_at ?? lesson.ts).getTime();
-                const ageDays = (nowMs - refMs) / 86400000;
-                if (conf <= provisional_threshold) {
-                    const recallCount = lesson.recall_count ?? 0;
-                    const shouldArchive = currentState === 'provisional' &&
-                        recallCount < 2 &&
-                        ageDays > archive_days;
-                    if (shouldArchive) {
-                        archivedKeys.push(lesson.topic);
-                        if (!dry_run) {
-                            const updated = {
-                                ...lesson,
-                                state: 'archived',
-                                audit_trail: [
-                                    ...(lesson.audit_trail ?? []),
-                                    { ts: new Date().toISOString(), action: 'archived', prev_state: 'provisional' },
-                                ],
-                            };
-                            updates.set(lesson._key, updated);
-                        }
-                    }
-                    else if (currentState === 'active') {
-                        provisionalKeys.push(lesson.topic);
-                        if (!dry_run) {
-                            const updated = {
-                                ...lesson,
-                                state: 'provisional',
-                                audit_trail: [
-                                    ...(lesson.audit_trail ?? []),
-                                    { ts: new Date().toISOString(), action: 'flagged_provisional', prev_state: 'active' },
-                                ],
-                            };
-                            updates.set(lesson._key, updated);
-                        }
-                    }
-                }
-            }
-            // ── Rule 3: orphan-failure cleanup ────────────────────────────────────
-            // Each topic has exactly one `best` lesson (upsert-on-write model).
-            // A failure lesson that was never recalled (recall_count === 0) and is
-            // older than archive_days days represents an unresolved one-off error
-            // that no one ever found useful. Archive it to keep the recall surface clean.
-            for (const lesson of lessons) {
-                const currentState = lesson.state ?? 'active';
-                if (currentState === 'archived')
-                    continue;
-                // Skip if Rule 1/2 already scheduled archival for this key.
-                if (updates.has(lesson._key) && updates.get(lesson._key).state === 'archived')
-                    continue;
-                if (lesson.outcome !== 'failure')
-                    continue;
-                const recallCount = lesson.recall_count ?? 0;
-                if (recallCount > 0)
-                    continue; // still useful
-                const refMs = new Date(lesson.verified_at ?? lesson.ts).getTime();
-                const ageDays = (nowMs - refMs) / 86400000;
-                if (ageDays <= archive_days)
-                    continue;
-                // Remove from provisionalKeys if Rule 1 already staged it — Rule 3 wins with archived.
-                const provIdx = provisionalKeys.indexOf(lesson.topic);
-                if (provIdx !== -1)
-                    provisionalKeys.splice(provIdx, 1);
-                conflictResolutions.push(`${lesson.topic} (failure, never recalled, ${Math.round(ageDays)}d old)`);
-                if (!dry_run) {
-                    const base = updates.get(lesson._key) ?? lesson;
-                    const updated = {
-                        ...base,
-                        state: 'archived',
-                        audit_trail: [
-                            ...(base.audit_trail ?? []),
-                            { ts: new Date().toISOString(), action: 'orphan_failure_archived', prev_state: currentState },
-                        ],
-                    };
-                    updates.set(lesson._key, updated);
-                }
-            }
-            // ── Regel 4: Startvorrat entwerten und Zeitersparnis neu rechnen ──────
-            //
-            // ANLASS (17.08.2026): Ein Brain mit 475 Lektionen zeigte 54 Tage
-            // eingesparte Entwicklerzeit und 97.237,50 € Gegenwert. Nachgerechnet kam
-            // praktisch alles aus dem mitgelieferten Startvorrat — `docker:layer-cache`
-            // bei 973 Abrufen, `cache:stampede` bei 971, dahinter neun weitere bei je
-            // rund 208. Die echten Lektionen standen bei zwei bis fünf.
-            //
-            // Ab jetzt zählen Starter-Abrufe nicht mehr mit (wertbeitrag.ts). Das
-            // stoppt aber nur das Weiterwachsen; die aufgelaufenen Zähler bleiben und
-            // tragen die Zahl weiter. Deshalb hier zweierlei:
-            //
-            //  1. Starter-Zähler auf 0. Sie sind keine Leistung dieses Teams.
-            //  2. time_saved_mins NEU BERECHNEN statt zu korrigieren. Die alte Summe
-            //     ist nicht rekonstruierbar (sie wurde im Juli schon einmal
-            //     zurückgesetzt und geht nicht mit der Summe der Einzelzähler auf).
-            //     Etwas davon abzuziehen ergäbe eine Zahl, die genauso erfunden wäre
-            //     wie die alte — nur unauffälliger. Neu gerechnet ist sie prüfbar.
-            //
-            // NACHTRAG 22.08.2026: Der Filter oben erwischte den größten Posten
-            // nicht — `import_public_brain` schreibt `source: 'public_brain'`, und
-            // verglichen wurde mit `=== 'starter'`. Und die Zeile darunter rechnete
-            // ABRUFZAHL MAL STAFFEL. Beides zusammen machte das Aufräumen zu einer
-            // Verschlimmerung: 1664 h → 6445 h.
-            //
-            // Die Rechnung lautet jetzt: Summe über alle NICHT fremden Lektionen,
-            // die mindestens einmal geholfen haben — JEDE GENAU EINMAL. Recherchiert
-            // wird einmal; der neunhundertste Blick auf dieselbe Lektion spart keine
-            // neunhundertste Recherche. Damit ist die Zahl nach oben durch den
-            // Wissensstand begrenzt statt durch die Nutzung.
-            let starterZurueckgesetzt = 0;
-            let minutenNeu = 0;
-            const minutenAlt = parseFloat((await redis.get(`cachly:stats:time_saved_mins:${instance_id}`)) ?? '0') || 0;
-            for (const lesson of lessons) {
-                if (istStarterLektion(lesson)) {
-                    if ((lesson.recall_count ?? 0) > 0) {
-                        starterZurueckgesetzt++;
-                        const bisher = updates.get(lesson._key) ?? lesson;
-                        updates.set(lesson._key, { ...bisher, recall_count: 0 });
-                    }
-                    continue;
-                }
-                // NICHT mal Abrufzahl. Recherchiert wird einmal; der neunhundertste
-                // Blick auf dieselbe Lektion spart keine neunhundertste Recherche.
-                // Zaehlt also jede Lektion einmal, sobald sie ueberhaupt geholfen hat.
-                if ((lesson.recall_count ?? 0) > 0)
-                    minutenNeu += ersparteMinuten(lesson);
-            }
-            if (!dry_run) {
-                await redis.set(`cachly:stats:time_saved_mins:${instance_id}`, String(minutenNeu)).catch(() => { });
-            }
-            // ── Flush updates ─────────────────────────────────────────────────────
-            if (!dry_run && updates.size > 0) {
-                const pipeline = redis.pipeline();
-                for (const [key, updated] of updates) {
-                    const { _key: _unused, ...lessonData } = updated;
-                    void _unused;
-                    pipeline.set(key, JSON.stringify(lessonData));
-                }
-                await pipeline.exec();
-            }
-            // ── Report ────────────────────────────────────────────────────────────
-            const prefix = dry_run ? '🔍 **Brain Hygiene (dry run)**' : '🧹 **Brain Hygiene**';
-            const lines = [
-                `${prefix} — scanned **${lessons.length}** lessons`,
-                '',
-                `| Action | Count |`,
-                `|---|---|`,
-                `| Flagged provisional (confidence < ${provisional_threshold}) | ${provisionalKeys.length} |`,
-                `| Archived (stale + low-recall + age > ${archive_days}d) | ${archivedKeys.length} |`,
-                `| Contradictions auto-resolved | ${conflictResolutions.length} |`,
-                `| Startvorrat entwertet (Zähler auf 0) | ${starterZurueckgesetzt} |`,
-                '',
-            ];
-            if (Math.round(minutenAlt) !== Math.round(minutenNeu)) {
-                // Die Zahl beim Namen nennen, nicht nur still korrigieren. Wer morgen
-                // eine kleinere Ersparnis im Panel sieht, soll hier lesen koennen warum.
-                lines.push(`**⏱️ Zeitersparnis neu gerechnet:** ${fmtStunden(minutenAlt)} → **${fmtStunden(minutenNeu)}**`, `_Nur eigene Lektionen, und jede genau einmal. Der mitgelieferte Startvorrat ist Allgemeinwissen, kein gelerntes; und wer dieselbe Lektion zum zweiten Mal liest, spart keine zweite Recherche._`, '');
-            }
-            if (provisionalKeys.length > 0) {
-                lines.push(`**⚠️ Provisional (verify or re-learn):**`);
-                provisionalKeys.slice(0, 10).forEach(t => lines.push(`  - \`${t}\``));
-                if (provisionalKeys.length > 10)
-                    lines.push(`  - _…and ${provisionalKeys.length - 10} more_`);
-                lines.push('');
-            }
-            if (archivedKeys.length > 0) {
-                lines.push(`**📦 Archived (excluded from recall):**`);
-                archivedKeys.slice(0, 5).forEach(t => lines.push(`  - \`${t}\``));
-                if (archivedKeys.length > 5)
-                    lines.push(`  - _…and ${archivedKeys.length - 5} more_`);
-                lines.push('');
-            }
-            if (conflictResolutions.length > 0) {
-                lines.push(`**⚔️ Contradictions resolved (failure archived, success kept):**`);
-                conflictResolutions.slice(0, 5).forEach(r => lines.push(`  - ${r}`));
-                lines.push('');
-            }
-            if (dry_run) {
-                lines.push(`_Run \`brain_hygiene(dry_run=false)\` to apply these changes._`);
-            }
-            else if (provisionalKeys.length + archivedKeys.length + conflictResolutions.length === 0) {
-                lines.push(`✅ Brain is clean — no hygiene actions needed.`);
-            }
-            else {
-                lines.push(`_Changes applied. Run \`brain_doctor\` to verify the updated health score._`);
-            }
-            return lines.join('\n');
-        }
-        // ── recall_at — Brain Archaeology ────────────────────────────────────────
-        case 'recall_at': {
-            const { instance_id, topic, date } = args;
-            const redis = await getConnection(instance_id);
-            const cutoff = new Date(date).getTime();
-            if (isNaN(cutoff))
-                return `❌ Invalid date "${date}". Use ISO format: "2026-01-15"`;
-            const listKey = `cachly:lessons:${topic}`;
-            const all = await redis.lrange(listKey, 0, -1);
-            if (all.length === 0)
-                return `📭 No history found for \`${topic}\`. Lessons are stored via \`learn_from_attempts\`.`;
-            const before = all
-                .map(raw => { try {
-                return JSON.parse(raw);
-            }
-            catch {
-                return null;
-            } })
-                .filter((l) => l !== null && new Date(l.ts).getTime() <= cutoff)
-                .sort((a, b) => new Date(a.ts).getTime() - new Date(b.ts).getTime());
-            if (before.length === 0) {
-                const first = safeJsonParse(all[0] ?? null, null);
-                const earliest = first?.ts ? new Date(first.ts).toLocaleDateString('de-DE') : 'unknown';
-                return `📭 No entries for \`${topic}\` found before **${date}**. Earliest entry: ${earliest}.`;
-            }
-            const lines = [
-                `🏺 **Brain Archaeology: \`${topic}\` before ${date}**`,
-                `_${before.length} of ${all.length} total entries shown_`,
-                '',
-            ];
-            for (const l of before.slice(-10)) {
-                const emoji = l.outcome === 'success' ? '✅' : l.outcome === 'partial' ? '⚠️' : '❌';
-                const d = new Date(l.ts).toLocaleDateString('de-DE');
-                lines.push(`**${d}** ${emoji} ${l.outcome}`);
-                if (l.what_worked)
-                    lines.push(`  → ${l.what_worked.slice(0, 100)}`);
-                lines.push('');
-            }
-            lines.push(`_Full evolution: ${all.map(r => { try {
-                const l = JSON.parse(r);
-                return l.outcome === 'success' ? '✅' : l.outcome === 'partial' ? '⚠️' : '❌';
-            }
-            catch {
-                return '?';
-            } }).join(' → ')}_`);
-            return lines.join('\n');
-        }
-        // ── trace_dependency — Causal Chain ──────────────────────────────────────
-        case 'trace_dependency': {
-            const { instance_id, dependency, mark_review = false } = args;
-            const redis = await getConnection(instance_id);
-            const depKey = `cachly:dep:${dependency}`;
-            const raw = await redis.get(depKey);
-            if (!raw)
-                return `📭 No lessons found that depend on \`${dependency}\`.\n\nAdd dependencies via: \`learn_from_attempts(..., depends_on=["${dependency}"])\``;
-            const topics = safeJsonParse(raw, []);
-            const lines = [
-                `🔗 **Causal Chain: \`${dependency}\`** — ${topics.length} dependent lesson${topics.length === 1 ? '' : 's'}`,
-                '',
-            ];
-            for (const t of topics) {
-                const lessonRaw = await redis.get(`cachly:lesson:best:${t}`);
-                if (!lessonRaw) {
-                    lines.push(`  • \`${t}\` _(lesson deleted)_`);
-                    continue;
-                }
-                const lesson = safeJsonParse(lessonRaw, null);
-                if (!lesson) {
-                    lines.push(`  • \`${t}\` _(lesson corrupted)_`);
-                    continue;
-                }
-                const emoji = lesson.outcome === 'success' ? '✅' : lesson.outcome === 'partial' ? '⚠️' : '❌';
-                const reviewBadge = lesson.needs_review ? ' 🔍 **needs_review**' : '';
-                lines.push(`  ${emoji} \`${t}\` (${lesson.severity ?? 'major'})${reviewBadge}`);
-                if (mark_review) {
-                    const updated = { ...lesson, needs_review: true };
-                    await redis.set(`cachly:lesson:best:${t}`, JSON.stringify(updated));
-                }
-            }
-            if (mark_review) {
-                lines.push('', `🔍 All ${topics.length} lessons marked as **needs_review** — verify they still work with the changed dependency.`);
-            }
-            else {
-                lines.push('', `_Run with \`mark_review: true\` to flag all dependent lessons for re-verification._`);
-            }
-            return lines.join('\n');
-        }
-        // ── global_learn ──────────────────────────────────────────────────────────
-        case 'global_learn': {
-            const { instance_id, topic, lesson, severity = 'minor', tags = [] } = args;
-            const redis = await getConnection(instance_id);
-            const key = `cachly:global:lesson:${topic}`;
-            const record = {
-                topic,
-                lesson,
-                severity,
-                tags,
-                ts: new Date().toISOString(),
-                scope: 'global',
-                recall_count: 0,
-            };
-            // Preserve recall_count on update
-            const existing = await redis.get(key);
-            if (existing) {
-                const prev = safeJsonParse(existing, null);
-                record.recall_count = prev?.recall_count ?? 0;
-            }
-            await redis.set(key, JSON.stringify(record));
-            return `🌐 **Global lesson stored**: \`${topic}\`\n\n${lesson}\n\nRecallable from any project via \`global_recall(topic="${topic}")\`.`;
-        }
-        // ── global_recall ─────────────────────────────────────────────────────────
-        case 'global_recall': {
-            const { instance_id, topic } = args;
-            const redis = await getConnection(instance_id);
-            const keys = [];
-            const gStream = redis.scanStream({ match: 'cachly:global:lesson:*', count: 200 });
-            await new Promise((resolve, reject) => {
-                gStream.on('data', (batch) => keys.push(...batch));
-                gStream.on('end', resolve);
-                gStream.on('error', reject);
-            });
-            let lessons = [];
-            if (keys.length > 0) {
-                const raws = await redis.mget(...keys);
-                for (const raw of raws) {
-                    const l = safeJsonParse(raw ?? null, null);
-                    if (l)
-                        lessons.push(l);
-                }
-            }
-            if (topic) {
-                const t = topic.toLowerCase();
-                lessons = lessons.filter(l => l.topic.toLowerCase().includes(t));
-            }
-            if (lessons.length === 0) {
-                return `📭 No global lessons${topic ? ` for \`${topic}\`` : ''}.\n\nAdd cross-project knowledge with \`global_learn(topic="...", lesson="...")\`.`;
-            }
-            // Increment recall_count + stamp last_recalled_at (recall-recency signal)
-            for (const l of lessons) {
-                const k = `cachly:global:lesson:${l.topic}`;
-                const raw = await redis.get(k);
-                if (raw) {
-                    const rec = safeJsonParse(raw, null);
-                    if (!rec)
-                        continue;
-                    rec.recall_count = (rec.recall_count ?? 0) + 1;
-                    rec.last_recalled_at = new Date().toISOString();
-                    await redis.set(k, JSON.stringify(rec));
-                }
-            }
-            const lines = [`🌐 **Global Brain** — ${lessons.length} lesson${lessons.length > 1 ? 's' : ''}`, ''];
-            for (const l of lessons) {
-                const sev = l.severity === 'critical' ? '🔴 ' : l.severity === 'major' ? '🟡 ' : '';
-                lines.push(`${sev}**\`${l.topic}\`**`);
-                lines.push(l.lesson.slice(0, 200));
-                lines.push('');
-            }
-            return lines.join('\n');
-        }
-        // ── publish_lesson ────────────────────────────────────────────────────────
-        case 'publish_lesson': {
-            const { instance_id, topic, lesson, framework = 'general', severity = 'minor' } = args;
-            const redis = await getConnection(instance_id);
-            // Strip potential PII patterns (emails, tokens, paths)
-            const sanitized = lesson
-                .replace(/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g, '[email]')
-                .replace(/\b(sk-|cky_live_|Bearer\s)[A-Za-z0-9_-]{8,}/g, '[token]')
-                .replace(/\/Users\/[^\s/]+/g, '/Users/[user]')
-                .replace(/\/home\/[^\s/]+/g, '/home/[user]');
-            const publicLesson = {
-                topic,
-                lesson: sanitized,
-                framework,
-                severity,
-                ts: new Date().toISOString(),
-                published: true,
-                votes: 0,
-            };
-            // Store locally with public flag (future: sync to Cachly public API)
-            const key = `cachly:public:lesson:${framework}:${topic}`;
-            await redis.set(key, JSON.stringify(publicLesson), 'EX', 365 * 86400);
-            return [
-                `📢 **Lesson published!**`,
-                ``,
-                `**Topic:** \`${topic}\``,
-                `**Framework:** ${framework}`,
-                `**Content:** ${sanitized.slice(0, 200)}${sanitized.length > 200 ? '…' : ''}`,
-                ``,
-                `This lesson is now available in the Public Brain for other developers.`,
-                `Import it anywhere: \`import_public_brain(framework="${framework}")\``,
-            ].join('\n');
-        }
-        // ── import_public_brain ───────────────────────────────────────────────────
-        case 'import_public_brain': {
-            const { instance_id, framework, limit = 20 } = args;
-            const redis = await getConnection(instance_id);
-            // Community-curated lessons per framework
-            const COMMUNITY_LESSONS = {
-                nextjs: [
-                    { topic: 'nextjs:image-layout', lesson: 'Use fill + relative parent instead of layout="fill" (deprecated since Next.js 13)', severity: 'major' },
-                    { topic: 'nextjs:app-router-fetch', lesson: 'fetch() in Server Components is cached by default — add {cache:"no-store"} for dynamic data', severity: 'major' },
-                    { topic: 'nextjs:metadata-export', lesson: 'Export metadata const or generateMetadata() — never both in same file', severity: 'minor' },
-                    { topic: 'nextjs:client-boundary', lesson: '"use client" propagates down — keep it at the lowest component, not at page level', severity: 'major' },
-                    { topic: 'nextjs:env-prefix', lesson: 'Only NEXT_PUBLIC_* env vars are exposed to client — others are server-only', severity: 'critical' },
-                    { topic: 'nextjs:revalidate', lesson: 'export const revalidate = 0 disables caching for entire route; use revalidatePath() for on-demand', severity: 'minor' },
-                ],
-                fastapi: [
-                    { topic: 'fastapi:async-db', lesson: 'Use async session with asyncpg — sync SQLAlchemy blocks the event loop', severity: 'critical' },
-                    { topic: 'fastapi:pydantic-v2', lesson: 'Pydantic v2: use model_validate() instead of parse_obj(), .dict() → .model_dump()', severity: 'major' },
-                    { topic: 'fastapi:lifespan', lesson: 'Use lifespan context manager instead of deprecated on_event startup/shutdown', severity: 'minor' },
-                    { topic: 'fastapi:background-tasks', lesson: 'BackgroundTasks run after response is sent — not in a separate thread pool', severity: 'major' },
-                    { topic: 'fastapi:cors-order', lesson: 'CORSMiddleware must be added before other middleware to work correctly', severity: 'critical' },
-                ],
-                go: [
-                    { topic: 'go:context-cancel', lesson: 'Always call cancel() from context.WithCancel — leak goroutines if not cancelled', severity: 'critical' },
-                    { topic: 'go:defer-in-loop', lesson: 'defer in a loop runs at function return, not loop iteration — use IIFE or explicit close', severity: 'major' },
-                    { topic: 'go:nil-interface', lesson: 'nil interface != interface containing nil pointer — use explicit nil checks', severity: 'major' },
-                    { topic: 'go:goroutine-leak', lesson: 'Goroutines with channel sends block forever if receiver is gone — use select with done chan', severity: 'critical' },
-                    { topic: 'go:embed-path', lesson: '//go:embed path must be relative and known at compile time — no os.Getenv', severity: 'minor' },
-                ],
-                docker: [
-                    { topic: 'docker:layer-cache', lesson: 'Copy package.json before source code — Docker caches layers, npm install only reruns on dep changes', severity: 'major' },
-                    { topic: 'docker:non-root', lesson: 'Run as non-root user (USER 1001) — some k8s clusters reject root containers by policy', severity: 'critical' },
-                    { topic: 'docker:build-arg-secret', lesson: 'Never use ARG for secrets — visible in image history. Use --secret mount instead', severity: 'critical' },
-                    { topic: 'docker:entrypoint-exec', lesson: 'Use exec form ["cmd","arg"] not shell form "cmd arg" — shell form ignores SIGTERM', severity: 'major' },
-                    { topic: 'docker:multi-stage', lesson: 'Multi-stage builds: copy only built artifacts to final stage — keep image small', severity: 'minor' },
-                ],
-                kubernetes: [
-                    { topic: 'k8s:resource-limits', lesson: 'Always set resource limits — unbounded pods cause node evictions and OOMKill', severity: 'critical' },
-                    { topic: 'k8s:liveness-vs-readiness', lesson: 'Liveness failures restart pod; Readiness failures remove from LB. Use different endpoints', severity: 'major' },
-                    { topic: 'k8s:imagepullpolicy', lesson: 'imagePullPolicy: Always in production — IfNotPresent can serve stale images', severity: 'major' },
-                    { topic: 'k8s:configmap-env', lesson: 'ConfigMap changes don\'t restart pods — use rollout restart or mount as volume', severity: 'critical' },
-                    { topic: 'k8s:pdb', lesson: 'Set PodDisruptionBudget for stateful apps — node drains kill all pods without it', severity: 'major' },
-                ],
-                react: [
-                    { topic: 'react:useeffect-deps', lesson: 'Omitting dependencies from useEffect deps array causes stale closure bugs — use exhaustive-deps ESLint rule', severity: 'critical' },
-                    { topic: 'react:key-index', lesson: 'Never use array index as key in lists — causes subtle re-render bugs on reorder/delete', severity: 'major' },
-                    { topic: 'react:setState-in-render', lesson: 'setState() during render causes infinite loop — move to useEffect or event handler', severity: 'critical' },
-                    { topic: 'react:memo-reference', lesson: 'Object/array literals in JSX recreate on every render — useMemo for expensive derived values', severity: 'minor' },
-                ],
-                typescript: [
-                    { topic: 'ts:type-guard', lesson: 'Use "x is Type" return type for type guard functions — not "boolean"', severity: 'minor' },
-                    { topic: 'ts:strict-null', lesson: 'Enable strictNullChecks in tsconfig — catches 90% of runtime null errors at compile time', severity: 'critical' },
-                    { topic: 'ts:enum-avoid', lesson: 'Prefer union types ("a"|"b") over enum — enums have surprising runtime behavior', severity: 'minor' },
-                    { topic: 'ts:satisfies', lesson: 'Use "satisfies" operator to validate type without widening — more precise than explicit annotation', severity: 'minor' },
-                ],
-                python: [
-                    { topic: 'python:mutable-default', lesson: 'Never use mutable default arguments (def f(x=[])) — shared across all calls. Use None + guard', severity: 'critical' },
-                    { topic: 'python:walrus-operator', lesson: ':= (walrus) assigns and returns — useful in while/comprehensions but hard to read in complex expr', severity: 'minor' },
-                    { topic: 'python:asyncio-run', lesson: 'asyncio.run() creates new event loop — calling it inside an existing loop raises RuntimeError', severity: 'major' },
-                    { topic: 'python:typing-optional', lesson: 'Optional[X] == Union[X, None] — in Python 3.10+ use X | None syntax', severity: 'minor' },
-                ],
-            };
-            const fw = framework.toLowerCase();
-            const lessons = COMMUNITY_LESSONS[fw];
-            if (!lessons) {
-                const available = Object.keys(COMMUNITY_LESSONS).join(', ');
-                return `❌ No public brain available for \`${framework}\`.\n\nAvailable: ${available}\n\nOr publish your own: \`publish_lesson(framework="${framework}", ...)\``;
-            }
-            const toImport = lessons.slice(0, limit);
-            let importedCount = 0;
-            for (const l of toImport) {
-                const key = `cachly:lesson:best:${l.topic}`;
-                const existing = await redis.get(key);
-                if (!existing) {
-                    await redis.set(key, JSON.stringify({
-                        ...l,
-                        what_worked: l.lesson,
-                        outcome: 'success',
-                        ts: new Date().toISOString(),
-                        recall_count: 0,
-                        source: 'public_brain',
-                        version: 2,
-                    }));
-                    importedCount++;
-                }
-            }
-            const lines = [
-                `📥 **Public Brain imported: ${framework}**`,
-                ``,
-                `${importedCount} new lessons added (${toImport.length - importedCount} already existed)`,
-                ``,
-                `**Imported topics:**`,
-                ...toImport.map(l => {
-                    const sev = l.severity === 'critical' ? '🔴' : l.severity === 'major' ? '🟡' : '💡';
-                    return `  ${sev} \`${l.topic}\``;
-                }),
-                ``,
-                `These lessons will now appear in \`session_start\` when relevant.`,
-                `Recall any time: \`recall_best_solution(topic="${fw}:...")\``,
-            ];
-            return lines.join('\n');
-        }
-        // ── setup_ai_memory ───────────────────────────────────────────────────────
-        case 'setup_ai_memory': {
-            const { instance_id, project_dir, embed_provider: providerArg = 'openai', project_description = 'a software project', } = args;
-            const inst = await apiFetch(`/api/v1/instances/${instance_id}`);
-            // Provider-specific env var instructions
-            const providerEnvMap = {
-                openai: { key: 'OPENAI_API_KEY', hint: 'Get at: https://platform.openai.com/api-keys' },
-                mistral: { key: 'MISTRAL_API_KEY', hint: 'Get at: https://console.mistral.ai/api-keys' },
-                cohere: { key: 'COHERE_API_KEY', hint: 'Get at: https://dashboard.cohere.com/api-keys' },
-                ollama: { key: 'OLLAMA_BASE_URL', hint: 'Run: brew install ollama && ollama serve  (free, local, no key needed)' },
-                gemini: { key: 'GEMINI_API_KEY', hint: 'Get at: https://aistudio.google.com/app/apikey' },
-            };
-            const provInfo = providerEnvMap[providerArg] ?? providerEnvMap['openai'];
-            const hasVector = !!inst.vector_token;
-            // Generate .mcp.json snippet
-            const mcpJsonSnippet = JSON.stringify({
-                mcpServers: {
-                    cachly: {
-                        command: 'npx',
-                        args: ['-y', '@cachly-dev/mcp-server@latest'],
-                        env: {
-                            CACHLY_JWT: 'your-api-token-from-cachly.dev/settings',
-                            [provInfo.key]: providerArg === 'ollama' ? 'http://localhost:11434' : 'your-key-here',
-                            ...(providerArg !== 'openai' ? { CACHLY_EMBED_PROVIDER: providerArg } : {}),
-                        },
-                    },
-                },
-            }, null, 2);
-            // Generate copilot-instructions.md content
-            const tier = inst.tier.toUpperCase();
-            const smartRecallNote = hasVector
-                ? '- `smart_recall("natural language query")` — semantic search (finds by meaning)'
-                : '- `recall_context("arch:*")` — exact/glob key lookup (upgrade to Speed/Business for smart_recall)';
-            const layerNote = hasVector
-                ? `Layer 3 (Semantic): smart_recall uses pgvector HNSW on your ${tier} instance`
-                : `Layer 3 (Autopilot): this file — upgrade to Speed/Business tier to unlock smart_recall`;
-            const copilotInstructions = `# cachly AI Brain — ${project_description}
+import{readFileSync as le}from"node:fs";import{bauabdruck as ue,formatiereBauabdruck as de}from"../bauabdruck.js";import{beurteileSpeicher as he,zahlAusInfo as se}from"../speicherlage.js";import{beurteileDeckung as pe}from"../eingaenge.js";import{join as E}from"node:path";import{calculateConfidence as Y,CONFIDENCE_STALE_VALUE as X,CONFIDENCE_WARN_VALUE as me,CONFIDENCE_WARN_DAYS as ne,CONFIDENCE_STALE_DAYS as oe}from"../confidence.js";import{safeJsonParse as T}from"../utils.js";import{ersparteMinuten as fe,istStarterLektion as ge,fmtStunden as ae}from"../wertbeitrag.js";import{cachlyUrl as ye}from"../cachly-url.js";const Ie=new Set(["sync_file_changes","team_learn","team_confirm","team_recall","team_synthesize","memory_crystalize","team_crystallize","brain_doctor","brain_hygiene","recall_at","trace_dependency","global_learn","global_recall","publish_lesson","import_public_brain","setup_ai_memory","team_assign_role","team_whoami","team_roster","team_grant_scope","team_scopes","team_audit"]),G={admin:4,reviewer:3,contributor:2,viewer:1},F={admin:"\u{1F451}",reviewer:"\u{1F6E1}\uFE0F",contributor:"\u270F\uFE0F",viewer:"\u{1F441}\uFE0F"},Q={admin:"assign roles \xB7 delete lessons \xB7 all reviewer + contributor actions",reviewer:"senior-review lessons (\u{1F6E1}\uFE0F) \xB7 all contributor actions",contributor:"store lessons \xB7 peer-review lessons (\u2714\uFE0F) \xB7 recall",viewer:"recall only \u2014 cannot store or review lessons"},B=b=>`cachly:team:roles:${b}`;async function J(b,y,_){return await b.hget(B(y),_.toLowerCase()).catch(()=>null)}function H(b,y){return b?(G[b]??0)>=(G[y]??0):!1}function we(b){return b==="admin"||b==="reviewer"?"senior":"peer"}async function _e(b,y){const _=await b.hgetall(B(y)).catch(()=>({}));return Object.values(_).includes("admin")}async function ee(b,y,_,R,r){if(!await _e(b,y))return null;const e=_?await J(b,y,_):null;if(H(e,R))return null;const a=e?`${F[e]} ${e}`:"no role";return[`\u{1F512} **Permission denied** \u2014 to ${r} you need at least \`${R}\` ${F[R]} (you have: ${a}).`,"","Ask an admin to grant it:",`\`team_assign_role(instance_id="${y}", handle="${_||"<your-handle>"}", role="${R}", assigned_by="<admin>")\``,"_Governance is active on this brain. Run `team_whoami` to check your role._"].join(`
+`)}async function ie(b,y,_){const R=`cachly:team:audit:${y}`,r=JSON.stringify({..._,ts:new Date().toISOString()});await b.rpush(R,r).catch(()=>{}),await b.ltrim(R,-500,-1).catch(()=>{}),await b.expire(R,365*2*86400).catch(()=>{})}const ve="cachly:team:review_mode",$e="cachly:lesson:proposed:",be=90*86400;async function ke(b,y){const _=await b.get(ve).catch(()=>null);return _==="1"||_==="true"||_==="on"}async function Se(b,y,_){const R={..._,proposed_at:new Date().toISOString(),status:"pending"};await b.set(`${$e}${y}`,JSON.stringify(R),"EX",be).catch(()=>{});const r=typeof _.author=="string"&&_.author?` by **${_.author}**`:"";return[`\u{1F4DD} **Lesson submitted for review** \u2014 \`${y}\`${r} is now a pending proposal.`,"","This team requires review before knowledge enters the Team Brain (org setting).","An org owner/admin can approve or reject it in the dashboard under **Team \u2192 Review**.","Until approved it will NOT surface in `smart_recall` / `team_recall`."].join(`
+`)}const q=b=>`cachly:team:groups:${b}`,K=(b,y)=>`cachly:team:group:${b}:${y.toLowerCase()}`;async function xe(b,y,_){const R=await b.smembers(q(y)).catch(()=>[]),r=new Set;for(const e of R)await b.sismember(K(y,e),_.toLowerCase()).catch(()=>0)&&r.add(e.toLowerCase());return r}function Me(b,y,_){return!b||_?!0:y.has(b.toLowerCase())}async function Pe(b,y,_,R){switch(b){case"sync_file_changes":{const{instance_id:r,changed_files:e,git_diff_stat:a,commit_msg:o}=y,i=await _(r),t={ts:new Date().toISOString(),files:e,commit_msg:o,diff_stat:a?.slice(0,500)};await i.lpush("cachly:session:file_changes",JSON.stringify(t)),await i.ltrim("cachly:session:file_changes",0,99),await i.expire("cachly:session:file_changes",30*86400);const c=[],l=i.scanStream({match:"cachly:lesson:best:*",count:200});await new Promise((p,g)=>{l.on("data",v=>c.push(...v)),l.on("end",p),l.on("error",g)});const h=[],s=c.length>0?await i.mget(...c):[];for(const p of s){if(!p)continue;const g=T(p,null);if(!g)continue;const v=g.topic.toLowerCase().split(/[:\-_]/);if(e.some(w=>{const $=w.split("/").pop()?.replace(/\.[^.]+$/,"").toLowerCase()??"";return v.some(m=>m.length>3&&$.includes(m))||(g.file_paths??[]).some(m=>w.includes(m)||m.includes(w))})){const w=g.outcome==="success"?"\u2705":"\u26A0\uFE0F";h.push(`  ${w} \`${g.topic}\` \u2014 ${g.what_worked.slice(0,80)}`)}}const n=[`\u{1F4C1} **File sync recorded**: ${e.length} files`,o?`\u{1F4DD} Commit: "${o}"`:"","",`**Changed:** ${e.slice(0,8).map(p=>`\`${p}\``).join(", ")}${e.length>8?` +${e.length-8} more`:""}`,""];return h.length>0?n.push(`\u{1F9E0} **Relevant brain lessons (${h.length}):**`,...h):n.push("\u{1F4A1} No existing lessons match these files yet. Add them with `learn_from_attempts`."),n.filter(Boolean).join(`
+`)}case"team_learn":{const{instance_id:r,author:e,topic:a,outcome:o,what_worked:i,what_failed:t,severity:c,file_paths:l,commands:h,tags:s}=y;if(!e||!a||!o||!i)return"\u274C Required: author, topic, outcome, what_worked";const n=r;if(!n)return"\u274C instance_id required";const p=await _(n),g=await ee(p,n,e,"contributor","store team lessons");if(g)return g;const v={topic:a,outcome:o,what_worked:i,what_failed:t??"",severity:c??"minor",author:e,file_paths:l??[],commands:h??[],tags:[...s??[],"team"],timestamp:new Date().toISOString(),recall_count:0,version:2};if(await ke(p,n))return Se(p,a,v);const A=`cachly:lessons:${a}`;return await p.rpush(A,JSON.stringify(v)),o==="success"&&await p.set(`cachly:lesson:best:${a}`,JSON.stringify(v)),`\u2705 Team lesson stored by **${e}**: \`${a}\` (${o})
+\u{1F4A1} ${i.slice(0,120)}`}case"team_confirm":{const{instance_id:r,topic:e,reviewer:a,level:o,note:i=""}=y;if(!r)return"\u274C instance_id required";if(!e||!a)return"\u274C Required: topic, reviewer";const t=await _(r),c=await ee(t,r,a,"reviewer","confirm team lessons");if(c)return c;const l=await J(t,r,a),h=we(l),s=o==="peer"?"peer":o==="senior"&&H(l,"reviewer")?"senior":h,n=l?` (role: ${F[l]} ${l})`:" (no role assigned \u2014 peer weight applied)",p=`cachly:lesson:best:${e}`,g=await t.get(p),v=T(g,null);if(!v)return`\u{1F4ED} No best-solution lesson found for \`${e}\`.
 
-> AI memory system powered by [cachly.dev](${cachlyUrl('/', 'team-readme')}). Works with GitHub Copilot, Claude Code, Cursor, Windsurf, Continue.dev, and any MCP-compatible editor.
+A lesson must exist (store one with \`team_learn\` / \`learn_from_attempts\`) before it can be confirmed.`;const A=`cachly:lesson:endorsers:${e}`,w=await t.sadd(A,a)===1;await t.expire(A,365*86400);const $=await t.scard(A),d=(v.review_level??"")==="senior"?"senior":s,u={...v,reviewed_by:a,review_level:d,endorsements:$,reviewed_at:new Date().toISOString()};await t.set(p,JSON.stringify(u));const S={reviewer:a,level:s,note:i.slice(0,280),ts:new Date().toISOString()},L=`cachly:lesson:reviews:${e}`;await t.rpush(L,JSON.stringify(S)),await t.ltrim(L,-50,-1),await t.expire(L,365*86400),await ie(t,r,{action:"team_confirm",actor:a,topic:e,level:d});const x=d==="senior"?"\u{1F6E1}\uFE0F senior-reviewed":"\u2714\uFE0F peer-reviewed",k=w?"":` (already endorsed by ${a} \u2014 no change to rank)`;return`${x} \u2014 \`${e}\` confirmed by **${a}**${n} (${$} distinct endorsement${$===1?"":"s"})${k}.
+\u{1F4C8} This lesson now ranks higher in \`smart_recall\` / \`team_recall\`.${i?`
+\u{1F4DD} ${i.slice(0,200)}`:""}`}case"team_recall":{const{instance_id:r,topic:e,author:a,limit:o=10}=y,i=await _(r),t=[],c=i.scanStream({match:"cachly:lesson:best:*",count:200});await new Promise((n,p)=>{c.on("data",g=>t.push(...g)),c.on("end",n),c.on("error",p)});let l=[];if(t.length>0){const n=await i.mget(...t);for(const p of n){const g=T(p??null,null);g&&l.push(g)}}if(e){const n=e.toLowerCase();l=l.filter(p=>p.topic.toLowerCase().includes(n)||(p.tags??[]).some(g=>g.toLowerCase().includes(n)))}if(a){const n=a.toLowerCase();l=l.filter(p=>p.author?.toLowerCase().includes(n))}const h=n=>n.reviewed_by?n.review_level==="senior"?2:1:0;if(l.sort((n,p)=>h(p)-h(n)||(p.recall_count??0)-(n.recall_count??0)),l=l.slice(0,o),l.length===0)return e?`\u{1F4ED} No team lessons found for \`${e}\`.
+
+Shared instance: add lessons with \`learn_from_attempts\` and include an \`author\` field.`:`\u{1F4ED} No lessons in this brain yet.
+
+All team members sharing this instance will see lessons here.`;const s=[`\u{1F465} **Team Brain** \u2014 ${l.length} lesson${l.length>1?"s":""}`,""];for(const n of l){const p=n.outcome==="success"?"\u2705":n.outcome==="partial"?"\u26A0\uFE0F":"\u274C",g=n.severity==="critical"?"\u{1F534} ":n.severity==="major"?"\u{1F7E1} ":"",v=n.reviewed_by?n.review_level==="senior"?" \u{1F6E1}\uFE0F":" \u2714\uFE0F":"",A=n.author?` \xB7 _by ${n.author}_`:"",w=n.reviewed_by?` \xB7 reviewed by ${n.reviewed_by}${(n.endorsements??0)>1?` +${(n.endorsements??0)-1}`:""}`:"",$=(n.recall_count??0)>0?` \xB7 recalled ${n.recall_count}\xD7`:"",m=Math.round((Date.now()-new Date(n.ts).getTime())/864e5),d=m===0?"today":m===1?"yesterday":`${m}d ago`;s.push(`${p} ${g}**\`${n.topic}\`**${v}${A}${w}${$} \xB7 ${d}`),s.push(`   ${n.what_worked.slice(0,120)}`),s.push("")}return s.join(`
+`)}case"team_synthesize":{const{instance_id:r,topic:e}=y,a=await _(r),o=`cachly:lessons:${e}`,i=await a.lrange(o,0,-1);if(i.length<2)return`\u{1F4ED} Need at least 2 entries for topic \`${e}\` to synthesize.
+
+Currently: ${i.length} entr${i.length===1?"y":"ies"}.
+
+Have team members store lessons via \`learn_from_attempts(topic="${e}", ...)\`.`;const t=i.map(d=>{try{return JSON.parse(d)}catch{return null}}).filter(d=>d!==null),c=t.filter(d=>d.outcome==="success"),l=t.filter(d=>d.outcome==="failure"),h=t.filter(d=>d.outcome==="partial"),s=[...new Set(t.map(d=>d.author).filter(Boolean))],n=s.length>1,p=c.sort((d,u)=>new Date(u.ts).getTime()-new Date(d.ts).getTime())[0],v=c.map(d=>d.what_worked).filter(d=>d&&d.length>10).sort((d,u)=>u.length-d.length)[0]??p?.what_worked??"",A=[...new Set([...l,...h].map(d=>d.what_failed).filter(d=>!!d&&d.length>5))],w=t.map(d=>d.severity).filter(Boolean),$=w.includes("critical")?"critical":w.includes("major")?"major":"minor";return[`\u{1F9EC} **Team Brain Synthesis: \`${e}\`**`,`_${t.length} entries from ${s.length} author${s.length===1?"":"s"}${n?` (${s.join(", ")})`:""} \xB7 ${c.length} success \xB7 ${l.length} failure \xB7 ${h.length} partial_`,"",'**Canonical "what worked":**',`> ${v}`,"",A.length>0?"**Avoid (combined failures):**":"",...A.map(d=>`> \u274C ${d}`),(A.length>0,""),"**Suggested canonical lesson:**","```","learn_from_attempts(",`  topic       = "${e}",`,'  outcome     = "success",',`  what_worked = "${v.replace(/"/g,"'")}",`,A.length>0?`  what_failed = "${A[0].replace(/"/g,"'")}",`:"",`  severity    = "${$}",`,")","```","",n?`\u{1F4A1} _${s.length} team members contributed to this synthesis. Store the canonical version to replace individual entries._`:"\u{1F4A1} _Single author \u2014 more value when multiple team members contribute to the same topic._"].filter(d=>d!==void 0).join(`
+`)}case"memory_crystalize":{const{instance_id:r,label:e=""}=y,a=await _(r),o=new Date,i=`${o.getFullYear()}-W${String(Math.ceil((o.getDate()-o.getDay()+10)/7)).padStart(2,"0")}`,t=e||`${o.toISOString().slice(0,7)} Crystal`,c=await a.lrange("cachly:session:history",0,49),l=[],h=a.scanStream({match:"cachly:lesson:best:*",count:200});await new Promise((w,$)=>{h.on("data",m=>l.push(...m)),h.on("end",w),h.on("error",$)});const s=[];if(l.length>0){const w=await a.mget(...l);for(const $ of w){const m=T($??null,null);m&&s.push(m)}}const n=new Map;for(const w of s){const $=w.topic.split(":")[0]||"misc";n.has($)||n.set($,[]),n.get($).push(w)}const p=[];for(const[w,$]of[...n.entries()].sort((m,d)=>d[1].length-m[1].length).slice(0,8)){const d=$.filter(u=>u.outcome==="success")[0]??$[0];d&&p.push({category:w,insight:d.what_worked.slice(0,120),count:$.length})}const g={label:t,ts:o.toISOString(),session_count:c.length,lesson_count:s.length,top_patterns:p,categories:[...n.keys()],created_from:`${c.length} sessions, ${s.length} lessons`},v=JSON.stringify(g);return await a.set("cachly:crystal:latest",v),await a.expire("cachly:crystal:latest",90*86400),await a.set(`cachly:crystal:${i}`,v),await a.expire(`cachly:crystal:${i}`,365*86400),[`\u{1F48E} **Memory Crystal created: ${t}**`,"",`\u{1F4CA} Compressed: **${c.length} sessions** + **${s.length} lessons** \u2192 ${p.length} top patterns`,"","**Top patterns by category:**",...p.slice(0,6).map(w=>`  \u2022 **${w.category}** (${w.count}\xD7): ${w.insight.slice(0,90)}`),"","\u{1F4A1} This crystal will appear in every future `session_start` briefing.","\u{1F4A1} Re-run `memory_crystalize` monthly to keep it fresh."].join(`
+`)}case"team_crystallize":{const{instance_id:r,min_authors:e=2,label:a=""}=y,o=await _(r),i=new Date,t=Math.max(2,Number(e)||2),c=[],l=o.scanStream({match:"cachly:lesson:best:*",count:200});await new Promise((m,d)=>{l.on("data",u=>c.push(...u)),l.on("end",m),l.on("error",d)});const h=[];if(c.length>0){const m=await o.mget(...c);for(const d of m){const u=T(d??null,null);u&&u.outcome==="success"&&u.author&&h.push(u)}}const s=new Set(["the","and","for","with","from","that","this","fix","bug","error","issue","use","via","add","set","team"]),n=m=>{const[d,...u]=m.topic.split(":"),S=(m.tags??[]).map(k=>k.toLowerCase().trim()).filter(k=>k.length>3&&!s.has(k)).sort();return S.length>0?S[0]:u.join("-").toLowerCase().replace(/[^a-z0-9\s-]/g," ").split(/[\s-]+/).filter(k=>k.length>3&&!s.has(k)).sort((k,D)=>D.length-k.length||k.localeCompare(D))[0]??d},p=new Map;for(const m of h){const d=n(m);let u=p.get(d);u||(u={concept:d,authors:new Set,lessons:[],namespaces:new Set,bestFix:m},p.set(d,u)),u.authors.add(m.author.toLowerCase()),u.lessons.push(m),u.namespaces.add(m.topic.split(":")[0]||"misc");const S=L=>(L.endorsements??0)*10+(L.confirm_count??0)+(L.review_level==="senior"?5:0);S(m)>S(u.bestFix)&&(u.bestFix=m)}const v=[...p.values()].filter(m=>m.authors.size>=t).sort((m,d)=>d.authors.size-m.authors.size||d.lessons.length-m.lessons.length).slice(0,10).map(m=>({concept:m.concept,author_count:m.authors.size,authors:[...m.authors],lesson_count:m.lessons.length,spans:[...m.namespaces],convergent_fix:m.bestFix.what_worked.slice(0,200),fix_topic:m.bestFix.topic})),A=a||`${i.toISOString().slice(0,7)} Team Crystal`,w={label:A,ts:i.toISOString(),kind:"team",contributors:new Set(h.map(m=>m.author.toLowerCase())).size,analysed:h.length,patterns:v};if(await o.set("cachly:crystal:team:latest",JSON.stringify(w)),await o.expire("cachly:crystal:team:latest",180*86400),v.length===0)return["\u{1F4A0} **Team Crystal \u2014 not enough cross-person convergence yet**","",`Analysed **${h.length}** attributed success lessons from **${w.contributors}** contributor${w.contributors!==1?"s":""}, but no concept had **${t}+ distinct authors** converge on it yet.`,"","This is the one thing a per-user memory can't build \u2014 it needs your team to accumulate shared, attributed lessons.",'Keep using `learn_from_attempts(author="...")` / `team_learn`; re-run as the team grows.'].join(`
+`);const $=[`\u{1F4A0} **Team Crystal created: ${A}**`,"",`\u{1F9EC} **${v.length} cross-person pattern${v.length!==1?"s":""}** \u2014 fixes that ${t}+ teammates independently converged on.`,`_Compressed from ${h.length} attributed lessons across ${w.contributors} contributors. This is the team-wide, causal layer a per-user "Dreaming" process structurally cannot produce._`,""];for(const m of v.slice(0,6)){const d=m.spans.length>1?` \xB7 spans ${m.spans.map(u=>`\`${u}\``).join(", ")}`:"";$.push(`### \u{1F9E9} \`${m.concept}\` \u2014 ${m.author_count} people converged${d}`,`**Convergent fix** (from \`${m.fix_topic}\`): ${m.convergent_fix}`,`**Who solved it together:** ${m.authors.map(u=>`@${u}`).join(", ")} _(ask them \u2014 they've each hit this)_`,"")}return $.push("---","\u{1F4A1} Surfaces in `crystal_view` and onboarding. Re-run `team_crystallize` monthly."),$.join(`
+`)}case"brain_doctor":{const{instance_id:r,workspace_path:e=""}=y,a=await _(r),o=[],i=[],t=[],c=a.scanStream({match:"cachly:lesson:best:*",count:200});await new Promise((f,j)=>{c.on("data",O=>t.push(...O)),c.on("end",f),c.on("error",j)});let l=0;const h=a.scanStream({match:"cachly:ctx:*",count:200});await new Promise((f,j)=>{h.on("data",O=>{l+=O.filter(C=>!C.endsWith(":meta")).length}),h.on("end",f),h.on("error",j)});const s=[];if(t.length>0){const f=await a.mget(...t);for(const j of f){const O=T(j??null,null);O&&s.push(O)}}const n=await a.get("cachly:session:last"),p=T(n,null),g=s.filter(f=>f.outcome==="failure"||f.outcome==="partial"),v=s.filter(f=>(f.recall_count??0)===0),A=s.filter(f=>f.severity==="critical"),w=s.filter(f=>f.outcome==="success"&&Y(f)<X),$=s.filter(f=>f.outcome==="success"&&Y(f)>=X&&Y(f)<me),m=s.filter(f=>(f.audit_trail??[]).length>1),d=s.filter(f=>f.author),u=new Set(s.map(f=>f.author).filter(Boolean)),S=s.reduce((f,j)=>f+(j.recall_count??0),0),L=s.length>0?Math.min(100,Math.round(S/s.length*10)):0,x=async f=>{let j=0;const O=a.scanStream({match:f,count:200});return await new Promise((C,W)=>{O.on("data",z=>{j+=z.length}),O.on("end",C),O.on("error",W)}),j},k=await x("cachly:lesson:vec:*"),D=await x("cachly:lesson:vecname:*"),M=await x("cachly:lesson:eing:*"),I=await x("cachly:lesson:pfad:*"),U=t.length>0?Math.round(k/t.length*100):100,Z=pe(t.length,k);t.length>0&&(Z==="aus"?(o.push(`semantic search is OFF: not a single lesson has an embedding (0 of ${t.length}). Recall falls back to keyword matching only. Fix: run the backfill (sdk/mcp/src/eingaenge-nachruesten.ts).`),i.push(`\u{1F534} **Semantic search: OFF** \u2014 0 of ${t.length} lessons have an embedding`)):Z==="luecke"?(o.push(`only ${U}% of lessons have an embedding (${k} of ${t.length}) \u2014 the rest can never be found by meaning.`),i.push(`\u{1F7E1} **Semantic coverage: ${U}%** \u2014 ${t.length-k} lessons without an embedding`)):(i.push(`\u2705 **Semantic coverage: ${U}%** \u2014 ${k} full-text, ${D} topic-name, ${M} with error-text entries`+(I>0?`, ${I} with learned question paths`:"")),I===0&&t.length>=20&&i.push("\u{1F4A4} **No learned question paths yet** \u2014 a question that finds the same lesson twice becomes its own entry. Needs repeated real use.")));let N=50;t.length>=5&&(N+=10),t.length>=20&&(N+=10),l>=3&&(N+=10),l>=10&&(N+=5),p&&(N+=10),g.length===0&&(N+=5);const te=s.length>0?v.length/s.length:0;te<.5&&(N+=10),w.length===0&&(N+=5),u.size>=2&&(N+=5),Z!=="gut"&&(N-=20),N=Math.max(0,Math.min(100,N));const re=N>=80?"\u{1F7E2}":N>=50?"\u{1F7E1}":"\u{1F534}",ce=L>=50?"\u{1F680}":L>=20?"\u{1F4C8}":"\u{1F4A4}";i.push(`${re} **Brain Quality Score: ${N}/100**`),i.push(`${ce} **Effective IQ Boost: ${L}%** (${S} recalls across ${s.length} lessons)`),i.push(`\u{1F4DA} **Lessons:** ${t.length} (${A.length} critical \xB7 ${m.length} with audit trail \xB7 ${d.length} from team)`),i.push(`\u{1F4BE} **Context entries:** ${l}`),i.push(`\u{1F3AF} **Confidence:** ${s.length-w.length-$.length} fresh \xB7 ${$.length} warn \xB7 ${w.length} stale`),i.push(`\u23F1\uFE0F **Decay config:** warn after ${ne}d \xB7 stale after ${oe}d`),i.push(de(ue));try{const f=await a.info("memory");let j=null;try{const C=await a.config("GET","maxmemory-policy");j=Array.isArray(C)&&C.length>1?String(C[1]):null}catch{j=null}const O={benutzt:se(f,"used_memory"),grenze:se(f,"maxmemory"),richtlinie:j};for(const C of he(O)){const z=`${C.art==="fehler"?"\u{1F534}":C.art==="hinweis"?"\u{1F7E1}":C.art==="ungemessen"?"\u26AA":"\u{1F7E2}"} **Speicher:** ${C.text}`;C.art==="fehler"||C.art==="ungemessen"?o.push(z):i.push(z)}}catch{o.push("\u26AA **Speicher:** Lage nicht abfragbar \u2014 unbekannt, ob dieser Speicher bei Platzmangel still loescht.")}u.size>=2&&i.push(`\u{1F465} **Team:** ${u.size} contributors (${[...u].join(", ")})`);try{const f=await a.get("cachly:index:last_run");if(f){const j=Math.round((Date.now()-new Date(f).getTime())/864e5);j>7?o.push(`\u{1F504} Index is ${j}d stale \u2014 run \`index_project\` to re-sync semantic search`):i.push(`\u{1F5C2}\uFE0F **Semantic index:** ${j}d old (fresh)`)}else o.push('\u{1F4A1} No semantic index \u2014 run `index_project(dir="<your-src>")` to enable semantic search')}catch{}try{const f=await a.get("cachly:crystal:latest");if(f){const j=JSON.parse(f),O=Math.round((Date.now()-new Date(j.ts).getTime())/864e5);i.push(`\u{1F48E} **Memory Crystal:** ${j.label} (${O}d ago)`),O>30&&o.push(`\u{1F4A1} Memory Crystal is ${O}d old \u2014 re-run \`memory_crystalize\` to compress new sessions`)}else t.length>=10&&o.push(`\u{1F4A1} ${t.length} lessons but no Memory Crystal \u2014 run \`memory_crystalize\` to compress wisdom`)}catch{}if(e)try{const f=e.replace(/\/$/,"")+"/package.json",j=le(f,"utf-8"),O=JSON.parse(j),C={...O.dependencies,...O.devDependencies},W=["openai","@anthropic-ai/sdk","@google/generative-ai","mistralai","cohere-ai"].some(V=>V in C),z="@cachly-dev/openclaw"in C;W&&!z?(o.push(`\u{1F4A1} **openclaw missing:** you use LLM APIs (${Object.keys(C).filter(V=>["openai","@anthropic-ai/sdk"].includes(V)).join(", ")}) but not \`@cachly-dev/openclaw\``),o.push("   \u2192 `npm install @cachly-dev/openclaw` cuts LLM costs 60\u201390% with 3 lines of code")):z&&i.push("\u2705 **@cachly-dev/openclaw installed** (LLM cost caching active)")}catch{}if(p){const f=Math.round((Date.now()-new Date(p.ts).getTime())/6e4),j=f<60?`${f}m`:f<1440?`${Math.round(f/60)}h`:`${Math.round(f/1440)}d`;i.push(`\u{1F550} **Last session:** ${j} ago`)}else o.push("\u274C No session history \u2014 call `session_start` + `session_end` to start tracking");t.length===0?o.push("\u274C No lessons \u2014 call `learn_from_attempts` after solving bugs"):t.length<5&&o.push(`\u{1F4A1} Only ${t.length} lessons \u2014 add more after each problem solved`),L===0&&s.length>=5&&o.push("\u{1F4A4} **IQ Boost is 0%** \u2014 lessons exist but are never recalled. Use `recall_best_solution` BEFORE tasks."),l===0&&o.push("\u{1F4A1} No context \u2014 use `remember_context` to cache architecture docs, ADRs, etc."),g.length>0&&o.push(`\u26A0\uFE0F ${g.length} unresolved failure${g.length>1?"s":""}: ${g.slice(0,3).map(f=>`\`${f.topic}\``).join(", ")}`),w.length>0&&(o.push(`\u{1F534} ${w.length} STALE lesson${w.length>1?"s":""} (>${oe}d, confidence <${X*100}%): ${w.slice(0,3).map(f=>`\`${f.topic}\``).join(", ")}`),o.push("   \u2192 Re-verify with `recall_best_solution` to reset confidence clock")),$.length>0&&o.push(`\u26A0\uFE0F ${$.length} lesson${$.length>1?"s":""} aging (>${ne}d): ${$.slice(0,3).map(f=>`\`${f.topic}\``).join(", ")}`),te>.7&&s.length>5&&o.push(`\u{1F4A1} ${v.length} lessons never recalled \u2014 verify topics match your workflow`);const P=["\u{1FA7A} **Brain Doctor**",`\`${"\u2500".repeat(48)}\``,"","**\u{1F4CA} Health Checks**",...i.map(f=>"  "+f),""];return o.length>0?(P.push(`**\u{1F527} Action Items** (${o.length} issue${o.length>1?"s":""})`),o.forEach((f,j)=>P.push(`  ${j+1}. ${f}`)),P.push(""),P.push("_Fix the action items above, then re-run `brain_doctor` to verify._")):(P.push("**\u2705 All checks passed** \u2014 Brain is healthy!"),P.push(""),P.push("_Keep the brain sharp: `session_start` \u2192 work \u2192 `learn_from_attempts` \u2192 `session_end`_")),P.join(`
+`)}case"brain_hygiene":{const{instance_id:r,dry_run:e=!1,provisional_threshold:a=.5,archive_days:o=30}=y,i=await _(r),t=[],c=i.scanStream({match:"cachly:lesson:best:*",count:200});if(await new Promise((u,S)=>{c.on("data",L=>t.push(...L)),c.on("end",u),c.on("error",S)}),t.length===0)return"\u{1F9F9} **Brain Hygiene** \u2014 no lessons found. Nothing to sweep.";const l=await i.mget(...t),h=[];for(let u=0;u<t.length;u++){const S=l[u],L=T(S??null,null);L&&h.push({...L,_key:t[u]})}const s=Date.now(),n=[],p=[],g=[],v=new Map;for(const u of h){const S=u.state??"active";if(S==="archived")continue;const L=Y(u),x=new Date(u.verified_at??u.ts).getTime(),k=(s-x)/864e5;if(L<=a){const D=u.recall_count??0;if(S==="provisional"&&D<2&&k>o){if(p.push(u.topic),!e){const I={...u,state:"archived",audit_trail:[...u.audit_trail??[],{ts:new Date().toISOString(),action:"archived",prev_state:"provisional"}]};v.set(u._key,I)}}else if(S==="active"&&(n.push(u.topic),!e)){const I={...u,state:"provisional",audit_trail:[...u.audit_trail??[],{ts:new Date().toISOString(),action:"flagged_provisional",prev_state:"active"}]};v.set(u._key,I)}}}for(const u of h){const S=u.state??"active";if(S==="archived"||v.has(u._key)&&v.get(u._key).state==="archived"||u.outcome!=="failure"||(u.recall_count??0)>0)continue;const x=new Date(u.verified_at??u.ts).getTime(),k=(s-x)/864e5;if(k<=o)continue;const D=n.indexOf(u.topic);if(D!==-1&&n.splice(D,1),g.push(`${u.topic} (failure, never recalled, ${Math.round(k)}d old)`),!e){const M=v.get(u._key)??u,I={...M,state:"archived",audit_trail:[...M.audit_trail??[],{ts:new Date().toISOString(),action:"orphan_failure_archived",prev_state:S}]};v.set(u._key,I)}}let A=0,w=0;const $=parseFloat(await i.get(`cachly:stats:time_saved_mins:${r}`)??"0")||0;for(const u of h){if(ge(u)){if((u.recall_count??0)>0){A++;const S=v.get(u._key)??u;v.set(u._key,{...S,recall_count:0})}continue}(u.recall_count??0)>0&&(w+=fe(u))}if(e||await i.set(`cachly:stats:time_saved_mins:${r}`,String(w)).catch(()=>{}),!e&&v.size>0){const u=i.pipeline();for(const[S,L]of v){const{_key:x,...k}=L;u.set(S,JSON.stringify(k))}await u.exec()}const d=[`${e?"\u{1F50D} **Brain Hygiene (dry run)**":"\u{1F9F9} **Brain Hygiene**"} \u2014 scanned **${h.length}** lessons`,"","| Action | Count |","|---|---|",`| Flagged provisional (confidence < ${a}) | ${n.length} |`,`| Archived (stale + low-recall + age > ${o}d) | ${p.length} |`,`| Contradictions auto-resolved | ${g.length} |`,`| Startvorrat entwertet (Z\xE4hler auf 0) | ${A} |`,""];return Math.round($)!==Math.round(w)&&d.push(`**\u23F1\uFE0F Zeitersparnis neu gerechnet:** ${ae($)} \u2192 **${ae(w)}**`,"_Nur eigene Lektionen, und jede genau einmal. Der mitgelieferte Startvorrat ist Allgemeinwissen, kein gelerntes; und wer dieselbe Lektion zum zweiten Mal liest, spart keine zweite Recherche._",""),n.length>0&&(d.push("**\u26A0\uFE0F Provisional (verify or re-learn):**"),n.slice(0,10).forEach(u=>d.push(`  - \`${u}\``)),n.length>10&&d.push(`  - _\u2026and ${n.length-10} more_`),d.push("")),p.length>0&&(d.push("**\u{1F4E6} Archived (excluded from recall):**"),p.slice(0,5).forEach(u=>d.push(`  - \`${u}\``)),p.length>5&&d.push(`  - _\u2026and ${p.length-5} more_`),d.push("")),g.length>0&&(d.push("**\u2694\uFE0F Contradictions resolved (failure archived, success kept):**"),g.slice(0,5).forEach(u=>d.push(`  - ${u}`)),d.push("")),e?d.push("_Run `brain_hygiene(dry_run=false)` to apply these changes._"):n.length+p.length+g.length===0?d.push("\u2705 Brain is clean \u2014 no hygiene actions needed."):d.push("_Changes applied. Run `brain_doctor` to verify the updated health score._"),d.join(`
+`)}case"recall_at":{const{instance_id:r,topic:e,date:a}=y,o=await _(r),i=new Date(a).getTime();if(isNaN(i))return`\u274C Invalid date "${a}". Use ISO format: "2026-01-15"`;const t=`cachly:lessons:${e}`,c=await o.lrange(t,0,-1);if(c.length===0)return`\u{1F4ED} No history found for \`${e}\`. Lessons are stored via \`learn_from_attempts\`.`;const l=c.map(s=>{try{return JSON.parse(s)}catch{return null}}).filter(s=>s!==null&&new Date(s.ts).getTime()<=i).sort((s,n)=>new Date(s.ts).getTime()-new Date(n.ts).getTime());if(l.length===0){const s=T(c[0]??null,null),n=s?.ts?new Date(s.ts).toLocaleDateString("de-DE"):"unknown";return`\u{1F4ED} No entries for \`${e}\` found before **${a}**. Earliest entry: ${n}.`}const h=[`\u{1F3FA} **Brain Archaeology: \`${e}\` before ${a}**`,`_${l.length} of ${c.length} total entries shown_`,""];for(const s of l.slice(-10)){const n=s.outcome==="success"?"\u2705":s.outcome==="partial"?"\u26A0\uFE0F":"\u274C",p=new Date(s.ts).toLocaleDateString("de-DE");h.push(`**${p}** ${n} ${s.outcome}`),s.what_worked&&h.push(`  \u2192 ${s.what_worked.slice(0,100)}`),h.push("")}return h.push(`_Full evolution: ${c.map(s=>{try{const n=JSON.parse(s);return n.outcome==="success"?"\u2705":n.outcome==="partial"?"\u26A0\uFE0F":"\u274C"}catch{return"?"}}).join(" \u2192 ")}_`),h.join(`
+`)}case"trace_dependency":{const{instance_id:r,dependency:e,mark_review:a=!1}=y,o=await _(r),i=`cachly:dep:${e}`,t=await o.get(i);if(!t)return`\u{1F4ED} No lessons found that depend on \`${e}\`.
+
+Add dependencies via: \`learn_from_attempts(..., depends_on=["${e}"])\``;const c=T(t,[]),l=[`\u{1F517} **Causal Chain: \`${e}\`** \u2014 ${c.length} dependent lesson${c.length===1?"":"s"}`,""];for(const h of c){const s=await o.get(`cachly:lesson:best:${h}`);if(!s){l.push(`  \u2022 \`${h}\` _(lesson deleted)_`);continue}const n=T(s,null);if(!n){l.push(`  \u2022 \`${h}\` _(lesson corrupted)_`);continue}const p=n.outcome==="success"?"\u2705":n.outcome==="partial"?"\u26A0\uFE0F":"\u274C",g=n.needs_review?" \u{1F50D} **needs_review**":"";if(l.push(`  ${p} \`${h}\` (${n.severity??"major"})${g}`),a){const v={...n,needs_review:!0};await o.set(`cachly:lesson:best:${h}`,JSON.stringify(v))}}return a?l.push("",`\u{1F50D} All ${c.length} lessons marked as **needs_review** \u2014 verify they still work with the changed dependency.`):l.push("","_Run with `mark_review: true` to flag all dependent lessons for re-verification._"),l.join(`
+`)}case"global_learn":{const{instance_id:r,topic:e,lesson:a,severity:o="minor",tags:i=[]}=y,t=await _(r),c=`cachly:global:lesson:${e}`,l={topic:e,lesson:a,severity:o,tags:i,ts:new Date().toISOString(),scope:"global",recall_count:0},h=await t.get(c);if(h){const s=T(h,null);l.recall_count=s?.recall_count??0}return await t.set(c,JSON.stringify(l)),`\u{1F310} **Global lesson stored**: \`${e}\`
+
+${a}
+
+Recallable from any project via \`global_recall(topic="${e}")\`.`}case"global_recall":{const{instance_id:r,topic:e}=y,a=await _(r),o=[],i=a.scanStream({match:"cachly:global:lesson:*",count:200});await new Promise((l,h)=>{i.on("data",s=>o.push(...s)),i.on("end",l),i.on("error",h)});let t=[];if(o.length>0){const l=await a.mget(...o);for(const h of l){const s=T(h??null,null);s&&t.push(s)}}if(e){const l=e.toLowerCase();t=t.filter(h=>h.topic.toLowerCase().includes(l))}if(t.length===0)return`\u{1F4ED} No global lessons${e?` for \`${e}\``:""}.
+
+Add cross-project knowledge with \`global_learn(topic="...", lesson="...")\`.`;for(const l of t){const h=`cachly:global:lesson:${l.topic}`,s=await a.get(h);if(s){const n=T(s,null);if(!n)continue;n.recall_count=(n.recall_count??0)+1,n.last_recalled_at=new Date().toISOString(),await a.set(h,JSON.stringify(n))}}const c=[`\u{1F310} **Global Brain** \u2014 ${t.length} lesson${t.length>1?"s":""}`,""];for(const l of t){const h=l.severity==="critical"?"\u{1F534} ":l.severity==="major"?"\u{1F7E1} ":"";c.push(`${h}**\`${l.topic}\`**`),c.push(l.lesson.slice(0,200)),c.push("")}return c.join(`
+`)}case"publish_lesson":{const{instance_id:r,topic:e,lesson:a,framework:o="general",severity:i="minor"}=y,t=await _(r),c=a.replace(/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g,"[email]").replace(/\b(sk-|cky_live_|Bearer\s)[A-Za-z0-9_-]{8,}/g,"[token]").replace(/\/Users\/[^\s/]+/g,"/Users/[user]").replace(/\/home\/[^\s/]+/g,"/home/[user]"),l={topic:e,lesson:c,framework:o,severity:i,ts:new Date().toISOString(),published:!0,votes:0},h=`cachly:public:lesson:${o}:${e}`;return await t.set(h,JSON.stringify(l),"EX",365*86400),["\u{1F4E2} **Lesson published!**","",`**Topic:** \`${e}\``,`**Framework:** ${o}`,`**Content:** ${c.slice(0,200)}${c.length>200?"\u2026":""}`,"","This lesson is now available in the Public Brain for other developers.",`Import it anywhere: \`import_public_brain(framework="${o}")\``].join(`
+`)}case"import_public_brain":{const{instance_id:r,framework:e,limit:a=20}=y,o=await _(r),i={nextjs:[{topic:"nextjs:image-layout",lesson:'Use fill + relative parent instead of layout="fill" (deprecated since Next.js 13)',severity:"major"},{topic:"nextjs:app-router-fetch",lesson:'fetch() in Server Components is cached by default \u2014 add {cache:"no-store"} for dynamic data',severity:"major"},{topic:"nextjs:metadata-export",lesson:"Export metadata const or generateMetadata() \u2014 never both in same file",severity:"minor"},{topic:"nextjs:client-boundary",lesson:'"use client" propagates down \u2014 keep it at the lowest component, not at page level',severity:"major"},{topic:"nextjs:env-prefix",lesson:"Only NEXT_PUBLIC_* env vars are exposed to client \u2014 others are server-only",severity:"critical"},{topic:"nextjs:revalidate",lesson:"export const revalidate = 0 disables caching for entire route; use revalidatePath() for on-demand",severity:"minor"}],fastapi:[{topic:"fastapi:async-db",lesson:"Use async session with asyncpg \u2014 sync SQLAlchemy blocks the event loop",severity:"critical"},{topic:"fastapi:pydantic-v2",lesson:"Pydantic v2: use model_validate() instead of parse_obj(), .dict() \u2192 .model_dump()",severity:"major"},{topic:"fastapi:lifespan",lesson:"Use lifespan context manager instead of deprecated on_event startup/shutdown",severity:"minor"},{topic:"fastapi:background-tasks",lesson:"BackgroundTasks run after response is sent \u2014 not in a separate thread pool",severity:"major"},{topic:"fastapi:cors-order",lesson:"CORSMiddleware must be added before other middleware to work correctly",severity:"critical"}],go:[{topic:"go:context-cancel",lesson:"Always call cancel() from context.WithCancel \u2014 leak goroutines if not cancelled",severity:"critical"},{topic:"go:defer-in-loop",lesson:"defer in a loop runs at function return, not loop iteration \u2014 use IIFE or explicit close",severity:"major"},{topic:"go:nil-interface",lesson:"nil interface != interface containing nil pointer \u2014 use explicit nil checks",severity:"major"},{topic:"go:goroutine-leak",lesson:"Goroutines with channel sends block forever if receiver is gone \u2014 use select with done chan",severity:"critical"},{topic:"go:embed-path",lesson:"//go:embed path must be relative and known at compile time \u2014 no os.Getenv",severity:"minor"}],docker:[{topic:"docker:layer-cache",lesson:"Copy package.json before source code \u2014 Docker caches layers, npm install only reruns on dep changes",severity:"major"},{topic:"docker:non-root",lesson:"Run as non-root user (USER 1001) \u2014 some k8s clusters reject root containers by policy",severity:"critical"},{topic:"docker:build-arg-secret",lesson:"Never use ARG for secrets \u2014 visible in image history. Use --secret mount instead",severity:"critical"},{topic:"docker:entrypoint-exec",lesson:'Use exec form ["cmd","arg"] not shell form "cmd arg" \u2014 shell form ignores SIGTERM',severity:"major"},{topic:"docker:multi-stage",lesson:"Multi-stage builds: copy only built artifacts to final stage \u2014 keep image small",severity:"minor"}],kubernetes:[{topic:"k8s:resource-limits",lesson:"Always set resource limits \u2014 unbounded pods cause node evictions and OOMKill",severity:"critical"},{topic:"k8s:liveness-vs-readiness",lesson:"Liveness failures restart pod; Readiness failures remove from LB. Use different endpoints",severity:"major"},{topic:"k8s:imagepullpolicy",lesson:"imagePullPolicy: Always in production \u2014 IfNotPresent can serve stale images",severity:"major"},{topic:"k8s:configmap-env",lesson:"ConfigMap changes don't restart pods \u2014 use rollout restart or mount as volume",severity:"critical"},{topic:"k8s:pdb",lesson:"Set PodDisruptionBudget for stateful apps \u2014 node drains kill all pods without it",severity:"major"}],react:[{topic:"react:useeffect-deps",lesson:"Omitting dependencies from useEffect deps array causes stale closure bugs \u2014 use exhaustive-deps ESLint rule",severity:"critical"},{topic:"react:key-index",lesson:"Never use array index as key in lists \u2014 causes subtle re-render bugs on reorder/delete",severity:"major"},{topic:"react:setState-in-render",lesson:"setState() during render causes infinite loop \u2014 move to useEffect or event handler",severity:"critical"},{topic:"react:memo-reference",lesson:"Object/array literals in JSX recreate on every render \u2014 useMemo for expensive derived values",severity:"minor"}],typescript:[{topic:"ts:type-guard",lesson:'Use "x is Type" return type for type guard functions \u2014 not "boolean"',severity:"minor"},{topic:"ts:strict-null",lesson:"Enable strictNullChecks in tsconfig \u2014 catches 90% of runtime null errors at compile time",severity:"critical"},{topic:"ts:enum-avoid",lesson:'Prefer union types ("a"|"b") over enum \u2014 enums have surprising runtime behavior',severity:"minor"},{topic:"ts:satisfies",lesson:'Use "satisfies" operator to validate type without widening \u2014 more precise than explicit annotation',severity:"minor"}],python:[{topic:"python:mutable-default",lesson:"Never use mutable default arguments (def f(x=[])) \u2014 shared across all calls. Use None + guard",severity:"critical"},{topic:"python:walrus-operator",lesson:":= (walrus) assigns and returns \u2014 useful in while/comprehensions but hard to read in complex expr",severity:"minor"},{topic:"python:asyncio-run",lesson:"asyncio.run() creates new event loop \u2014 calling it inside an existing loop raises RuntimeError",severity:"major"},{topic:"python:typing-optional",lesson:"Optional[X] == Union[X, None] \u2014 in Python 3.10+ use X | None syntax",severity:"minor"}]},t=e.toLowerCase(),c=i[t];if(!c){const n=Object.keys(i).join(", ");return`\u274C No public brain available for \`${e}\`.
+
+Available: ${n}
+
+Or publish your own: \`publish_lesson(framework="${e}", ...)\``}const l=c.slice(0,a);let h=0;for(const n of l){const p=`cachly:lesson:best:${n.topic}`;await o.get(p)||(await o.set(p,JSON.stringify({...n,what_worked:n.lesson,outcome:"success",ts:new Date().toISOString(),recall_count:0,source:"public_brain",version:2})),h++)}return[`\u{1F4E5} **Public Brain imported: ${e}**`,"",`${h} new lessons added (${l.length-h} already existed)`,"","**Imported topics:**",...l.map(n=>`  ${n.severity==="critical"?"\u{1F534}":n.severity==="major"?"\u{1F7E1}":"\u{1F4A1}"} \`${n.topic}\``),"","These lessons will now appear in `session_start` when relevant.",`Recall any time: \`recall_best_solution(topic="${t}:...")\``].join(`
+`)}case"setup_ai_memory":{const{instance_id:r,project_dir:e,embed_provider:a="openai",project_description:o="a software project"}=y,i=await R(`/api/v1/instances/${r}`),t={openai:{key:"OPENAI_API_KEY",hint:"Get at: https://platform.openai.com/api-keys"},mistral:{key:"MISTRAL_API_KEY",hint:"Get at: https://console.mistral.ai/api-keys"},cohere:{key:"COHERE_API_KEY",hint:"Get at: https://dashboard.cohere.com/api-keys"},ollama:{key:"OLLAMA_BASE_URL",hint:"Run: brew install ollama && ollama serve  (free, local, no key needed)"},gemini:{key:"GEMINI_API_KEY",hint:"Get at: https://aistudio.google.com/app/apikey"}},c=t[a]??t.openai,l=!!i.vector_token,h=JSON.stringify({mcpServers:{cachly:{command:"npx",args:["-y","@cachly-dev/mcp-server@latest"],env:{CACHLY_JWT:"your-api-token-from-cachly.dev/settings",[c.key]:a==="ollama"?"http://localhost:11434":"your-key-here",...a!=="openai"?{CACHLY_EMBED_PROVIDER:a}:{}}}}},null,2),s=i.tier.toUpperCase(),n=l?'- `smart_recall("natural language query")` \u2014 semantic search (finds by meaning)':'- `recall_context("arch:*")` \u2014 exact/glob key lookup (upgrade to Speed/Business for smart_recall)',p=l?`Layer 3 (Semantic): smart_recall uses pgvector HNSW on your ${s} instance`:"Layer 3 (Autopilot): this file \u2014 upgrade to Speed/Business tier to unlock smart_recall",g=`# cachly AI Brain \u2014 ${o}
+
+> AI memory system powered by [cachly.dev](${ye("/","team-readme")}). Works with GitHub Copilot, Claude Code, Cursor, Windsurf, Continue.dev, and any MCP-compatible editor.
 
 ---
 
-## 🔴 MANDATORY RULES — Always enforced, no exceptions
+## \u{1F534} MANDATORY RULES \u2014 Always enforced, no exceptions
 
-### Rule 1 — Session Start (FIRST thing in every window)
+### Rule 1 \u2014 Session Start (FIRST thing in every window)
 Call \`session_start\` **before reading any source files or making any changes**:
 
 \`\`\`
 session_start(
-  instance_id = "${instance_id}",
+  instance_id = "${r}",
   focus       = "<what you plan to work on today>",
 )
 \`\`\`
@@ -1498,12 +62,12 @@ Returns: last session summary, handoff from previous window, recent lessons, ope
 1. \`smart_recall("recent lessons <topic>")\`
 2. \`recall_best_solution("<topic>")\`
 
-### Rule 2 — Learn After Every Fix/Deploy/Discovery (AUTOMATIC — no prompting needed)
-After **every** bug fix, deployment, failed attempt, or discovery — call \`learn_from_attempts\` immediately:
+### Rule 2 \u2014 Learn After Every Fix/Deploy/Discovery (AUTOMATIC \u2014 no prompting needed)
+After **every** bug fix, deployment, failed attempt, or discovery \u2014 call \`learn_from_attempts\` immediately:
 
 \`\`\`
 learn_from_attempts(
-  instance_id = "${instance_id}",
+  instance_id = "${r}",
   topic       = "category:keyword",   # deploy:web | fix:auth | debug:db | infra:docker
   outcome     = "success" | "failure" | "partial",
   what_worked = "exact approach or command that worked",
@@ -1515,17 +79,17 @@ learn_from_attempts(
 \`\`\`
 
 **These events MUST automatically trigger \`learn_from_attempts\`:**
-- ✅ Successfully deployed → \`topic="deploy:<component>", outcome="success"\`
-- ✅ Fixed a bug → \`topic="fix:<description>", outcome="success"\`
-- ✅ Discovered root cause → \`topic="debug:<area>", outcome="partial"\`
-- ✅ Tried something that failed → \`topic="<area>", outcome="failure", what_failed="..."\`
-- ✅ Found a config quirk → \`topic="infra:<topic>", outcome="success"\`
-- ✅ Ran a working command → store it in \`commands=[...]\`
-
-### Rule 3 — Session Handoff (when closing window or task list > 3 items)
+- \u2705 Successfully deployed \u2192 \`topic="deploy:<component>", outcome="success"\`
+- \u2705 Fixed a bug \u2192 \`topic="fix:<description>", outcome="success"\`
+- \u2705 Discovered root cause \u2192 \`topic="debug:<area>", outcome="partial"\`
+- \u2705 Tried something that failed \u2192 \`topic="<area>", outcome="failure", what_failed="..."\`
+- \u2705 Found a config quirk \u2192 \`topic="infra:<topic>", outcome="success"\`
+- \u2705 Ran a working command \u2192 store it in \`commands=[...]\`
+
+### Rule 3 \u2014 Session Handoff (when closing window or task list > 3 items)
 \`\`\`
 session_handoff(
-  instance_id     = "${instance_id}",
+  instance_id     = "${r}",
   completed_tasks = ["what was done"],
   remaining_tasks = ["what is still to do"],
   files_changed   = [{"path": "src/...", "status": "modified", "description": "what changed"}],
@@ -1536,20 +100,20 @@ session_handoff(
 
 The next \`session_start\` automatically includes this handoff. The new window sees exactly what's done, what remains, and what NOT to break.
 
-### Rule 4 — Session End (LAST thing before closing)
+### Rule 4 \u2014 Session End (LAST thing before closing)
 \`\`\`
 session_end(
-  instance_id     = "${instance_id}",
+  instance_id     = "${r}",
   summary         = "What was accomplished (2-3 sentences with specifics)",
   files_changed   = ["list", "of", "changed", "files"],
   lessons_learned = <number of learn_from_attempts calls made>,
 )
 \`\`\`
 
-> \`session_end\` **automatically extracts and stores lessons** from the summary text — no manual calls needed.
+> \`session_end\` **automatically extracts and stores lessons** from the summary text \u2014 no manual calls needed.
 
-### Rule 5 — Code Index Invalidation (AUTOMATIC)
-- \`index_project\` tracks MD5 hashes per file — **skips unchanged files automatically**
+### Rule 5 \u2014 Code Index Invalidation (AUTOMATIC)
+- \`index_project\` tracks MD5 hashes per file \u2014 **skips unchanged files automatically**
 - After code changes: next \`index_project\` run re-indexes only modified files
 - After delete/rename: run \`index_project\` again to sync
 - No manual invalidation needed
@@ -1572,14 +136,13 @@ session_end(
 
 | Tool | When to use |
 |------|-------------|
-| \`session_start\` | **FIRST** — mandatory at start of every session |
-| \`session_end\` | **LAST** — mandatory at end, auto-learns from summary |
+| \`session_start\` | **FIRST** \u2014 mandatory at start of every session |
+| \`session_end\` | **LAST** \u2014 mandatory at end, auto-learns from summary |
 | \`session_handoff\` | When closing window with remaining tasks |
 | \`learn_from_attempts\` | **AUTOMATIC** after every fix/deploy/discovery |
 | \`recall_best_solution\` | Before any non-trivial task |
-| \`remember_context\` | After analyzing code — save findings for future sessions |
-${smartRecallNote ? `| \`smart_recall\` | Search brain by meaning/keywords |\n` : ''}\
-| \`recall_context\` | Get exact key (supports glob: \`arch:*\`, \`file:*\`) |
+| \`remember_context\` | After analyzing code \u2014 save findings for future sessions |
+${n?"| `smart_recall` | Search brain by meaning/keywords |\n":""}| \`recall_context\` | Get exact key (supports glob: \`arch:*\`, \`file:*\`) |
 | \`brain_search\` | BM25+ full-text search over all brain data |
 | \`auto_learn_session\` | Batch-learn from a list of observations (optional) |
 | \`index_project\` | Index source files (smart hash, skips unchanged files) |
@@ -1590,373 +153,34 @@ ${smartRecallNote ? `| \`smart_recall\` | Search brain by meaning/keywords |\n`
 
 ## Instance Details
 
-- **Instance ID:** \`${instance_id}\`
-- **Instance name:** ${inst.name}
-- **Tier:** ${tier}
-- **${layerNote}**
-- **Embedding provider:** ${providerArg}
+- **Instance ID:** \`${r}\`
+- **Instance name:** ${i.name}
+- **Tier:** ${s}
+- **${p}**
+- **Embedding provider:** ${a}
 
 ---
 
 ## How the 3-layer system works
 
 \`\`\`
-Layer 1 — Storage:  Your cachly Valkey instance (${inst.name}) — persists forever
-Layer 2 — Tools:    learn_from_attempts · recall_best_solution · brain_search · session_start/end
-Layer 3 — Autopilot: This file — AI reads it and runs tools automatically every session
+Layer 1 \u2014 Storage:  Your cachly Valkey instance (${i.name}) \u2014 persists forever
+Layer 2 \u2014 Tools:    learn_from_attempts \xB7 recall_best_solution \xB7 brain_search \xB7 session_start/end
+Layer 3 \u2014 Autopilot: This file \u2014 AI reads it and runs tools automatically every session
 \`\`\`
 
-Result: Your AI **never solves the same problem twice** and always picks up exactly where it left off. 🚀
-`;
-            const lines = [
-                `🧠 **cachly AI Memory Setup Complete**`,
-                ``,
-                `**Instance:** ${inst.name} (${tier}) · ID: \`${instance_id}\``,
-                `**Embedding Provider:** ${providerArg}`,
-                `**Semantic Search:** ${hasVector ? '✅ pgvector HNSW available' : '⚠️  Not available on ' + tier + ' — upgrade to Speed/Business'}`,
-                ``,
-                `─────────────────────────────────────────────`,
-                `**Step 1 — Add to .mcp.json:**`,
-                `\`\`\`json`,
-                mcpJsonSnippet,
-                `\`\`\``,
-                ``,
-                `**Step 2 — Set your ${providerArg} key:**`,
-                `\`\`\`bash`,
-                `export ${provInfo.key}="your-key-here"`,
-                `\`\`\``,
-                `_(${provInfo.hint})_`,
-                ``,
-                `─────────────────────────────────────────────`,
-                `**Step 3 — copilot-instructions.md (Layer 3 Autopilot):**`,
-                ``,
-                ...(project_dir
-                    ? [`🔍 Detecting IDEs in \`${project_dir}\`…`]
-                    : [`Copy this to \`.github/copilot-instructions.md\` (Copilot), \`CLAUDE.md\` (Claude Code), or \`.cursor/rules\` (Cursor) in your project:`]),
-                ``,
-                `\`\`\`markdown`,
-                copilotInstructions,
-                `\`\`\``,
-                ``,
-                `─────────────────────────────────────────────`,
-                `**How the 3 layers work together:**`,
-                `  Layer 1 → Your Valkey instance stores all lessons + context (persists forever)`,
-                `  Layer 2 → MCP tools (learn_from_attempts, recall_best_solution, smart_recall) read/write it`,
-                `  Layer 3 → copilot-instructions.md makes your AI run them automatically`,
-                ``,
-                `Result: Your AI never solves the same problem twice. 🚀`,
-            ];
-            // ── IDE auto-detection + file writing ────────────────────────────────
-            if (project_dir) {
-                const { mkdir, writeFile, access } = await import('node:fs/promises');
-                const { constants } = await import('node:fs');
-                const exists = async (p) => access(p, constants.F_OK).then(() => true).catch(() => false);
-                const targets = [];
-                let stopHookWritten = false;
-                // GitHub Copilot — always write (universal fallback)
-                targets.push({
-                    ide: 'GitHub Copilot',
-                    path: join(project_dir, '.github', 'copilot-instructions.md'),
-                    content: copilotInstructions,
-                });
-                // Claude Code — CLAUDE.md in project root
-                if (await exists(join(project_dir, 'CLAUDE.md')) || await exists(join(project_dir, '.claude'))) {
-                    targets.push({
-                        ide: 'Claude Code',
-                        path: join(project_dir, 'CLAUDE.md'),
-                        content: copilotInstructions,
-                    });
-                    // Claude Code Stop-Hook — auto-saves checkpoint when Claude stops responding
-                    const claudeDir = join(project_dir, '.claude');
-                    await mkdir(claudeDir, { recursive: true });
-                    const stopHook = {
-                        hooks: {
-                            Stop: [
-                                {
-                                    matcher: '',
-                                    hooks: [
-                                        {
-                                            type: 'command',
-                                            command: `npx --yes @cachly-dev/mcp-server@latest checkpoint --instance-id ${instance_id}`,
-                                        },
-                                    ],
-                                },
-                            ],
-                        },
-                    };
-                    const settingsPath = join(claudeDir, 'settings.json');
-                    let existingSettings = {};
-                    try {
-                        const { readFile: rf } = await import('node:fs/promises');
-                        existingSettings = JSON.parse(await rf(settingsPath, 'utf-8'));
-                    }
-                    catch { /* new file */ }
-                    const merged = { ...existingSettings, hooks: stopHook.hooks };
-                    await writeFile(settingsPath, JSON.stringify(merged, null, 2), 'utf-8');
-                    stopHookWritten = true;
-                }
-                // Cursor — .cursor/rules (new format) or .cursorrules (legacy)
-                if (await exists(join(project_dir, '.cursor')) ||
-                    await exists(join(project_dir, '.cursorrules'))) {
-                    const cursorDir = join(project_dir, '.cursor');
-                    await mkdir(cursorDir, { recursive: true });
-                    targets.push({
-                        ide: 'Cursor',
-                        path: join(cursorDir, 'rules'),
-                        content: copilotInstructions,
-                    });
-                }
-                // Windsurf — .windsurfrules
-                if (await exists(join(project_dir, '.windsurfrules')) ||
-                    await exists(join(project_dir, '.windsurf'))) {
-                    targets.push({
-                        ide: 'Windsurf',
-                        path: join(project_dir, '.windsurfrules'),
-                        content: copilotInstructions,
-                    });
-                }
-                // VS Code (Copilot) — already covered by .github/copilot-instructions.md above
-                // Continue.dev — .continue/config.json is JSON, not markdown — skip, copilot-instructions handles it
-                const written = [];
-                for (const target of targets) {
-                    const dir = target.path.substring(0, target.path.lastIndexOf('/'));
-                    await mkdir(dir, { recursive: true });
-                    await writeFile(target.path, target.content, 'utf-8');
-                    written.push(`✅ [${target.ide}] → \`${target.path.replace(project_dir, '.')}\``);
-                }
-                if (stopHookWritten) {
-                    written.push(`✅ [Claude Code Stop-Hook] → \`.claude/settings.json\` (auto-checkpoint on stop)`);
-                }
-                lines.push(...written);
-            }
-            return lines.join('\n');
-        }
-        // ── team_assign_role ──────────────────────────────────────────────────────
-        // Assign a role (admin | reviewer | contributor | viewer) to a team member.
-        // Only an existing admin can upgrade another member to admin or reviewer.
-        // First call with role="admin" is bootstrapped (no auth required) so the
-        // team can establish governance from a fresh brain.
-        case 'team_assign_role': {
-            const { instance_id, handle, role, assigned_by = '' } = args;
-            if (!instance_id || !handle || !role)
-                return '❌ Required: instance_id, handle, role';
-            const cleanRole = ['admin', 'reviewer', 'contributor', 'viewer'].includes(role)
-                ? role : null;
-            if (!cleanRole)
-                return `❌ Unknown role \`${role}\`. Valid: admin · reviewer · contributor · viewer`;
-            const redis = await getConnection(instance_id);
-            // Bootstrap: if there are no admins yet, the first assignment is free.
-            const allRoles = await redis.hgetall(ROLES_KEY(instance_id)).catch(() => ({}));
-            const hasAdmin = Object.values(allRoles).includes('admin');
-            if (hasAdmin) {
-                // After bootstrap, only an admin can assign roles.
-                const actorRole = assigned_by ? await getRole(redis, instance_id, assigned_by) : null;
-                if (!hasPermission(actorRole, 'admin')) {
-                    return [
-                        `❌ **Permission denied** — only an \`admin\` can assign roles.`,
-                        ``,
-                        `Ask an existing admin to run:`,
-                        `\`team_assign_role(instance_id="${instance_id}", handle="${handle}", role="${role}", assigned_by="<their-handle>")\``,
-                    ].join('\n');
-                }
-            }
-            const prevRole = allRoles[handle.toLowerCase()] ?? null;
-            await redis.hset(ROLES_KEY(instance_id), handle.toLowerCase(), cleanRole);
-            await redis.expire(ROLES_KEY(instance_id), 365 * 2 * 86400); // 2-year TTL
-            // Governance audit trail (W6): record every role change with who made it.
-            await auditLog(redis, instance_id, {
-                action: 'team_assign_role', actor: assigned_by || '(bootstrap)',
-                handle: handle.toLowerCase(), from: prevRole, to: cleanRole,
-            });
-            const isBootstrap = !hasAdmin;
-            const badge = ROLE_BADGE[cleanRole];
-            return [
-                `${badge} **Role assigned** — **${handle}** is now a \`${cleanRole}\``,
-                ``,
-                `**Capabilities:** ${ROLE_CAPABILITIES[cleanRole]}`,
-                ``,
-                isBootstrap ? `_First admin bootstrapped — governance is now active on this brain._` : `_Assigned by ${assigned_by || '(bootstrap)'}_`,
-                ``,
-                `Run \`team_roster\` to see all current roles.`,
-            ].join('\n');
-        }
-        // ── team_whoami ───────────────────────────────────────────────────────────
-        // Shows a team member's own role and what they can do.
-        case 'team_whoami': {
-            const { instance_id, handle } = args;
-            if (!instance_id || !handle)
-                return '❌ Required: instance_id, handle';
-            const redis = await getConnection(instance_id);
-            const role = await getRole(redis, instance_id, handle);
-            if (!role) {
-                const allRoles = await redis.hgetall(ROLES_KEY(instance_id)).catch(() => ({}));
-                const hasAdmin = Object.values(allRoles).includes('admin');
-                return [
-                    `👁️ **${handle}** has no assigned role on this brain.`,
-                    ``,
-                    hasAdmin
-                        ? `Ask an admin to run \`team_assign_role(handle="${handle}", role="contributor")\` to add you.`
-                        : `This brain has no roles set up yet. Establish governance:\n\`team_assign_role(handle="${handle}", role="admin")\``,
-                ].join('\n');
-            }
-            const badge = ROLE_BADGE[role];
-            return [
-                `## ${badge} ${handle} — \`${role}\``,
-                ``,
-                `**You can:** ${ROLE_CAPABILITIES[role]}`,
-                ``,
-                `Run \`team_roster\` to see all team members and their roles.`,
-            ].join('\n');
-        }
-        // ── team_roster ───────────────────────────────────────────────────────────
-        // Full view of all assigned roles, with last-active info from person nodes.
-        case 'team_roster': {
-            const { instance_id } = args;
-            if (!instance_id)
-                return '❌ Required: instance_id';
-            const redis = await getConnection(instance_id);
-            const allRoles = await redis.hgetall(ROLES_KEY(instance_id)).catch(() => ({}));
-            if (Object.keys(allRoles).length === 0) {
-                return [
-                    `## 👥 Team Roster`,
-                    ``,
-                    `No roles assigned yet. Establish governance with:`,
-                    `\`team_assign_role(instance_id="${instance_id}", handle="<your-handle>", role="admin")\``,
-                ].join('\n');
-            }
-            // Sort by role rank desc, then handle alpha
-            const members = Object.entries(allRoles)
-                .map(([h, r]) => ({ handle: h, role: r }))
-                .sort((a, b) => ((ROLE_RANK[b.role] ?? 0) - (ROLE_RANK[a.role] ?? 0)) || a.handle.localeCompare(b.handle));
-            const lines = [
-                `## 👥 Team Roster (${members.length} member${members.length !== 1 ? 's' : ''})`,
-                ``,
-                `| Role | Handle | Capabilities |`,
-                `|---|---|---|`,
-            ];
-            for (const m of members) {
-                const badge = ROLE_BADGE[m.role] ?? '?';
-                lines.push(`| ${badge} ${m.role} | **${m.handle}** | ${ROLE_CAPABILITIES[m.role].split(' · ').slice(0, 2).join(', ')} |`);
-            }
-            lines.push(``, `_Manage with \`team_assign_role\`. Any admin can add or change roles._`);
-            return lines.join('\n');
-        }
-        // ── team_audit ────────────────────────────────────────────────────────────
-        // Governance/compliance trail (W6): who changed roles, who confirmed which
-        // lessons, and when. Admin-gated once governance is active — the audit log is
-        // sensitive (it reveals the team's review activity). Newest entries first.
-        case 'team_audit': {
-            const { instance_id, requester = '', limit = 50 } = args;
-            if (!instance_id)
-                return '❌ Required: instance_id';
-            const redis = await getConnection(instance_id);
-            const denied = await requireRole(redis, instance_id, requester, 'admin', 'view the governance audit log');
-            if (denied)
-                return denied;
-            const max = Math.min(Math.max(1, Number(limit) || 50), 200);
-            const raw = await redis.lrange(`cachly:team:audit:${instance_id}`, -max, -1).catch(() => []);
-            if (raw.length === 0) {
-                return [
-                    `## 📜 Governance Audit Log`,
-                    ``,
-                    `No governance events recorded yet.`,
-                    `Events are logged automatically on \`team_assign_role\` and \`team_confirm\`.`,
-                ].join('\n');
-            }
-            const entries = raw
-                .map(r => safeJsonParse(r, null))
-                .filter((e) => e !== null)
-                .reverse(); // newest first
-            const fmt = (e) => {
-                const when = e.ts ? new Date(e.ts).toISOString().replace('T', ' ').slice(0, 16) : '?';
-                if (e.action === 'team_assign_role') {
-                    return `| ${when} | 👑 role | **${e.actor}** set \`${e.handle}\`: ${e.from ?? '—'} → **${e.to}** |`;
-                }
-                if (e.action === 'team_confirm') {
-                    return `| ${when} | ✅ confirm | **${e.actor}** confirmed \`${e.topic}\` (${e.level}) |`;
-                }
-                return `| ${when} | ${e.action ?? '?'} | ${e.actor ?? '?'} |`;
-            };
-            return [
-                `## 📜 Governance Audit Log (${entries.length} event${entries.length !== 1 ? 's' : ''})`,
-                ``,
-                `| When (UTC) | Type | Detail |`,
-                `|---|---|---|`,
-                ...entries.map(fmt),
-                ``,
-                `_Immutable trail · 2-year retention · last ${max} events. Admin-only._`,
-            ].join('\n');
-        }
-        // ── team_grant_scope ──────────────────────────────────────────────────────
-        // Add (or remove) a member to a named group/sub-team. Group-scoped lessons
-        // only surface in recall for members of that group. Admin-gated after the
-        // role model is bootstrapped (consistent with team_assign_role).
-        case 'team_grant_scope': {
-            const { instance_id, handle, group, action = 'add', assigned_by = '' } = args;
-            if (!instance_id || !handle || !group)
-                return '❌ Required: instance_id, handle, group';
-            const grp = String(group).toLowerCase().trim();
-            if (!grp)
-                return '❌ `group` must be a non-empty name (e.g. "backend", "security")';
-            const redis = await getConnection(instance_id);
-            // Admin gate (skipped during bootstrap, i.e. when no admin exists yet).
-            const allRoles = await redis.hgetall(ROLES_KEY(instance_id)).catch(() => ({}));
-            const hasAdmin = Object.values(allRoles).includes('admin');
-            if (hasAdmin) {
-                const actorRole = assigned_by ? await getRole(redis, instance_id, assigned_by) : null;
-                if (!hasPermission(actorRole, 'admin')) {
-                    return `❌ **Permission denied** — only an \`admin\` can manage group scopes. Ask an admin to set \`assigned_by\`.`;
-                }
-            }
-            if (action === 'remove') {
-                await redis.srem(GROUP_KEY(instance_id, grp), handle.toLowerCase());
-                return `🔓 **${handle}** removed from group \`${grp}\`.`;
-            }
-            await redis.sadd(GROUPS_INDEX_KEY(instance_id), grp);
-            await redis.sadd(GROUP_KEY(instance_id, grp), handle.toLowerCase());
-            await redis.expire(GROUPS_INDEX_KEY(instance_id), 365 * 2 * 86400);
-            await redis.expire(GROUP_KEY(instance_id, grp), 365 * 2 * 86400);
-            return [
-                `🔐 **Scope granted** — **${handle}** is now in group \`${grp}\`.`,
-                ``,
-                `Lessons stored with \`group="${grp}"\` will surface in recall for ${handle} (and other \`${grp}\` members + admins) only.`,
-                ``,
-                `Store a scoped lesson: \`learn_from_attempts(topic="...", group="${grp}", ...)\``,
-            ].join('\n');
-        }
-        // ── team_scopes ───────────────────────────────────────────────────────────
-        // List all groups + members, or the groups a specific handle belongs to.
-        case 'team_scopes': {
-            const { instance_id, handle } = args;
-            if (!instance_id)
-                return '❌ Required: instance_id';
-            const redis = await getConnection(instance_id);
-            if (handle) {
-                const scopes = await getScopes(redis, instance_id, handle);
-                if (scopes.size === 0) {
-                    return `👁️ **${handle}** is in no groups — sees only team-wide + public lessons.`;
-                }
-                return `🔐 **${handle}** belongs to: ${[...scopes].map(g => `\`${g}\``).join(', ')}`;
-            }
-            const groups = await redis.smembers(GROUPS_INDEX_KEY(instance_id)).catch(() => []);
-            if (groups.length === 0) {
-                return [
-                    `## 🔐 Team Scopes`,
-                    ``,
-                    `No groups defined yet. Create one by adding a member:`,
-                    `\`team_grant_scope(instance_id="${instance_id}", handle="alice", group="backend")\``,
-                ].join('\n');
-            }
-            const lines = [`## 🔐 Team Scopes (${groups.length} group${groups.length !== 1 ? 's' : ''})`, ``];
-            for (const g of groups.sort()) {
-                const members = await redis.smembers(GROUP_KEY(instance_id, g)).catch(() => []);
-                lines.push(`- **\`${g}\`** (${members.length}): ${members.length ? members.map(m => `**${m}**`).join(', ') : '_empty_'}`);
-            }
-            lines.push(``, `_Scope a lesson to a group with \`learn_from_attempts(group="...")\`. Members + admins see it; others don't._`);
-            return lines.join('\n');
-        }
-        default:
-            return null;
-    }
-}
-//# sourceMappingURL=team.js.map
+Result: Your AI **never solves the same problem twice** and always picks up exactly where it left off. \u{1F680}
+`,v=["\u{1F9E0} **cachly AI Memory Setup Complete**","",`**Instance:** ${i.name} (${s}) \xB7 ID: \`${r}\``,`**Embedding Provider:** ${a}`,`**Semantic Search:** ${l?"\u2705 pgvector HNSW available":"\u26A0\uFE0F  Not available on "+s+" \u2014 upgrade to Speed/Business"}`,"","\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","**Step 1 \u2014 Add to .mcp.json:**","```json",h,"```","",`**Step 2 \u2014 Set your ${a} key:**`,"```bash",`export ${c.key}="your-key-here"`,"```",`_(${c.hint})_`,"","\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","**Step 3 \u2014 copilot-instructions.md (Layer 3 Autopilot):**","",...e?[`\u{1F50D} Detecting IDEs in \`${e}\`\u2026`]:["Copy this to `.github/copilot-instructions.md` (Copilot), `CLAUDE.md` (Claude Code), or `.cursor/rules` (Cursor) in your project:"],"","```markdown",g,"```","","\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","**How the 3 layers work together:**","  Layer 1 \u2192 Your Valkey instance stores all lessons + context (persists forever)","  Layer 2 \u2192 MCP tools (learn_from_attempts, recall_best_solution, smart_recall) read/write it","  Layer 3 \u2192 copilot-instructions.md makes your AI run them automatically","","Result: Your AI never solves the same problem twice. \u{1F680}"];if(e){const{mkdir:A,writeFile:w,access:$}=await import("node:fs/promises"),{constants:m}=await import("node:fs"),d=async x=>$(x,m.F_OK).then(()=>!0).catch(()=>!1),u=[];let S=!1;if(u.push({ide:"GitHub Copilot",path:E(e,".github","copilot-instructions.md"),content:g}),await d(E(e,"CLAUDE.md"))||await d(E(e,".claude"))){u.push({ide:"Claude Code",path:E(e,"CLAUDE.md"),content:g});const x=E(e,".claude");await A(x,{recursive:!0});const k={hooks:{Stop:[{matcher:"",hooks:[{type:"command",command:`npx --yes @cachly-dev/mcp-server@latest checkpoint --instance-id ${r}`}]}]}},D=E(x,"settings.json");let M={};try{const{readFile:U}=await import("node:fs/promises");M=JSON.parse(await U(D,"utf-8"))}catch{}const I={...M,hooks:k.hooks};await w(D,JSON.stringify(I,null,2),"utf-8"),S=!0}if(await d(E(e,".cursor"))||await d(E(e,".cursorrules"))){const x=E(e,".cursor");await A(x,{recursive:!0}),u.push({ide:"Cursor",path:E(x,"rules"),content:g})}(await d(E(e,".windsurfrules"))||await d(E(e,".windsurf")))&&u.push({ide:"Windsurf",path:E(e,".windsurfrules"),content:g});const L=[];for(const x of u){const k=x.path.substring(0,x.path.lastIndexOf("/"));await A(k,{recursive:!0}),await w(x.path,x.content,"utf-8"),L.push(`\u2705 [${x.ide}] \u2192 \`${x.path.replace(e,".")}\``)}S&&L.push("\u2705 [Claude Code Stop-Hook] \u2192 `.claude/settings.json` (auto-checkpoint on stop)"),v.push(...L)}return v.join(`
+`)}case"team_assign_role":{const{instance_id:r,handle:e,role:a,assigned_by:o=""}=y;if(!r||!e||!a)return"\u274C Required: instance_id, handle, role";const i=["admin","reviewer","contributor","viewer"].includes(a)?a:null;if(!i)return`\u274C Unknown role \`${a}\`. Valid: admin \xB7 reviewer \xB7 contributor \xB7 viewer`;const t=await _(r),c=await t.hgetall(B(r)).catch(()=>({})),l=Object.values(c).includes("admin");if(l){const p=o?await J(t,r,o):null;if(!H(p,"admin"))return["\u274C **Permission denied** \u2014 only an `admin` can assign roles.","","Ask an existing admin to run:",`\`team_assign_role(instance_id="${r}", handle="${e}", role="${a}", assigned_by="<their-handle>")\``].join(`
+`)}const h=c[e.toLowerCase()]??null;await t.hset(B(r),e.toLowerCase(),i),await t.expire(B(r),365*2*86400),await ie(t,r,{action:"team_assign_role",actor:o||"(bootstrap)",handle:e.toLowerCase(),from:h,to:i});const s=!l;return[`${F[i]} **Role assigned** \u2014 **${e}** is now a \`${i}\``,"",`**Capabilities:** ${Q[i]}`,"",s?"_First admin bootstrapped \u2014 governance is now active on this brain._":`_Assigned by ${o||"(bootstrap)"}_`,"","Run `team_roster` to see all current roles."].join(`
+`)}case"team_whoami":{const{instance_id:r,handle:e}=y;if(!r||!e)return"\u274C Required: instance_id, handle";const a=await _(r),o=await J(a,r,e);if(!o){const t=await a.hgetall(B(r)).catch(()=>({})),c=Object.values(t).includes("admin");return[`\u{1F441}\uFE0F **${e}** has no assigned role on this brain.`,"",c?`Ask an admin to run \`team_assign_role(handle="${e}", role="contributor")\` to add you.`:`This brain has no roles set up yet. Establish governance:
+\`team_assign_role(handle="${e}", role="admin")\``].join(`
+`)}return[`## ${F[o]} ${e} \u2014 \`${o}\``,"",`**You can:** ${Q[o]}`,"","Run `team_roster` to see all team members and their roles."].join(`
+`)}case"team_roster":{const{instance_id:r}=y;if(!r)return"\u274C Required: instance_id";const a=await(await _(r)).hgetall(B(r)).catch(()=>({}));if(Object.keys(a).length===0)return["## \u{1F465} Team Roster","","No roles assigned yet. Establish governance with:",`\`team_assign_role(instance_id="${r}", handle="<your-handle>", role="admin")\``].join(`
+`);const o=Object.entries(a).map(([t,c])=>({handle:t,role:c})).sort((t,c)=>(G[c.role]??0)-(G[t.role]??0)||t.handle.localeCompare(c.handle)),i=[`## \u{1F465} Team Roster (${o.length} member${o.length!==1?"s":""})`,"","| Role | Handle | Capabilities |","|---|---|---|"];for(const t of o){const c=F[t.role]??"?";i.push(`| ${c} ${t.role} | **${t.handle}** | ${Q[t.role].split(" \xB7 ").slice(0,2).join(", ")} |`)}return i.push("","_Manage with `team_assign_role`. Any admin can add or change roles._"),i.join(`
+`)}case"team_audit":{const{instance_id:r,requester:e="",limit:a=50}=y;if(!r)return"\u274C Required: instance_id";const o=await _(r),i=await ee(o,r,e,"admin","view the governance audit log");if(i)return i;const t=Math.min(Math.max(1,Number(a)||50),200),c=await o.lrange(`cachly:team:audit:${r}`,-t,-1).catch(()=>[]);if(c.length===0)return["## \u{1F4DC} Governance Audit Log","","No governance events recorded yet.","Events are logged automatically on `team_assign_role` and `team_confirm`."].join(`
+`);const l=c.map(s=>T(s,null)).filter(s=>s!==null).reverse(),h=s=>{const n=s.ts?new Date(s.ts).toISOString().replace("T"," ").slice(0,16):"?";return s.action==="team_assign_role"?`| ${n} | \u{1F451} role | **${s.actor}** set \`${s.handle}\`: ${s.from??"\u2014"} \u2192 **${s.to}** |`:s.action==="team_confirm"?`| ${n} | \u2705 confirm | **${s.actor}** confirmed \`${s.topic}\` (${s.level}) |`:`| ${n} | ${s.action??"?"} | ${s.actor??"?"} |`};return[`## \u{1F4DC} Governance Audit Log (${l.length} event${l.length!==1?"s":""})`,"","| When (UTC) | Type | Detail |","|---|---|---|",...l.map(h),"",`_Immutable trail \xB7 2-year retention \xB7 last ${t} events. Admin-only._`].join(`
+`)}case"team_grant_scope":{const{instance_id:r,handle:e,group:a,action:o="add",assigned_by:i=""}=y;if(!r||!e||!a)return"\u274C Required: instance_id, handle, group";const t=String(a).toLowerCase().trim();if(!t)return'\u274C `group` must be a non-empty name (e.g. "backend", "security")';const c=await _(r),l=await c.hgetall(B(r)).catch(()=>({}));if(Object.values(l).includes("admin")){const s=i?await J(c,r,i):null;if(!H(s,"admin"))return"\u274C **Permission denied** \u2014 only an `admin` can manage group scopes. Ask an admin to set `assigned_by`."}return o==="remove"?(await c.srem(K(r,t),e.toLowerCase()),`\u{1F513} **${e}** removed from group \`${t}\`.`):(await c.sadd(q(r),t),await c.sadd(K(r,t),e.toLowerCase()),await c.expire(q(r),365*2*86400),await c.expire(K(r,t),365*2*86400),[`\u{1F510} **Scope granted** \u2014 **${e}** is now in group \`${t}\`.`,"",`Lessons stored with \`group="${t}"\` will surface in recall for ${e} (and other \`${t}\` members + admins) only.`,"",`Store a scoped lesson: \`learn_from_attempts(topic="...", group="${t}", ...)\``].join(`
+`))}case"team_scopes":{const{instance_id:r,handle:e}=y;if(!r)return"\u274C Required: instance_id";const a=await _(r);if(e){const t=await xe(a,r,e);return t.size===0?`\u{1F441}\uFE0F **${e}** is in no groups \u2014 sees only team-wide + public lessons.`:`\u{1F510} **${e}** belongs to: ${[...t].map(c=>`\`${c}\``).join(", ")}`}const o=await a.smembers(q(r)).catch(()=>[]);if(o.length===0)return["## \u{1F510} Team Scopes","","No groups defined yet. Create one by adding a member:",`\`team_grant_scope(instance_id="${r}", handle="alice", group="backend")\``].join(`
+`);const i=[`## \u{1F510} Team Scopes (${o.length} group${o.length!==1?"s":""})`,""];for(const t of o.sort()){const c=await a.smembers(K(r,t)).catch(()=>[]);i.push(`- **\`${t}\`** (${c.length}): ${c.length?c.map(l=>`**${l}**`).join(", "):"_empty_"}`)}return i.push("",'_Scope a lesson to a group with `learn_from_attempts(group="...")`. Members + admins see it; others don\'t._'),i.join(`
+`)}default:return null}}export{q as GROUPS_INDEX_KEY,K as GROUP_KEY,$e as PROPOSED_LESSON_PREFIX,ve as REVIEW_MODE_KEY,B as ROLES_KEY,F as ROLE_BADGE,Ie as TEAM_TOOL_NAMES,ie as auditLog,J as getRole,xe as getScopes,Pe as handleTeamTool,H as hasPermission,Me as lessonVisibleToScope,_e as rbacActive,ee as requireRole,ke as reviewModeEnabled,we as roleToReviewLevel,Se as storeLessonProposal};