@persistadev/mcp-server 3.2.0

package/dist/index.js

@@ -0,0 +1,1936 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Persista MCP Server v3.0 - Complete AI Memory Infrastructure
+ *
+ * FEATURES:
+ * ═══════════════════════════════════════════════════════════════
+ *
+ * 🧠 MEMORY (v3)
+ * - Confidence decay over time
+ * - Semantic search
+ * - Auto-extraction from text
+ * - Code-attached memories
+ * - Memory history/versioning
+ * - Smart merge for conflicts
+ *
+ * 📝 CONTEXT (v3)
+ * - Relevance scoring
+ * - Smart context packing
+ * - Cross-session threading
+ * - Auto-compression
+ * - Milestone marking
+ *
+ * 🔄 SYNC (v3)
+ * - Intent broadcasting
+ * - Conflict detection
+ * - Auto-discovery
+ * - Cursor position sharing
+ *
+ * 📚 KNOWLEDGE (v3)
+ * - Version-aware queries
+ * - Deprecation scanning
+ * - User pattern learning
+ * - Migration guides
+ *
+ * 🚀 AUTO-HOOKS
+ * - Git tracking between sessions
+ * - Codebase analysis
+ * - Proactive context injection
+ * ═══════════════════════════════════════════════════════════════
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const os_1 = __importDefault(require("os"));
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// ============================================
+// CONFIGURATION
+// ============================================
+const API_KEY = process.env.PERSISTA_API_KEY;
+// Default to our clean API URL (custom domain on Supabase)
+const BASE_URL = process.env.PERSISTA_API_URL || 'https://api.persista.dev/functions/v1';
+const USER_ID = process.env.PERSISTA_USER_ID || os_1.default.userInfo().username || 'default';
+// Smart project directory detection
+function findProjectDir() {
+    // 1. Check explicit env var
+    if (process.env.PERSISTA_PROJECT_DIR) {
+        return process.env.PERSISTA_PROJECT_DIR;
+    }
+    // 2. Try to find nearest package.json by walking up from cwd
+    let current = process.cwd();
+    const root = path_1.default.parse(current).root;
+    while (current !== root) {
+        if (fs_1.default.existsSync(path_1.default.join(current, 'package.json')) ||
+            fs_1.default.existsSync(path_1.default.join(current, 'pyproject.toml')) ||
+            fs_1.default.existsSync(path_1.default.join(current, 'Cargo.toml')) ||
+            fs_1.default.existsSync(path_1.default.join(current, 'go.mod')) ||
+            fs_1.default.existsSync(path_1.default.join(current, '.git'))) {
+            return current;
+        }
+        current = path_1.default.dirname(current);
+    }
+    // 3. Fall back to cwd
+    return process.cwd();
+}
+const PROJECT_DIR = findProjectDir();
+if (!API_KEY) {
+    console.error('Error: PERSISTA_API_KEY environment variable is required');
+    process.exit(1);
+}
+// Global session state
+let sessionState = {
+    startTime: new Date(),
+    userId: USER_ID,
+    projectDir: PROJECT_DIR,
+    gitInfo: null,
+    codebaseDNA: null,
+    userMemory: null,
+    recentErrors: [],
+    lastKnownCommit: null,
+    packageVersions: {},
+    // Phase 2
+    buildHistory: [],
+    testHistory: [],
+    antiPatterns: [],
+    lastGitCheck: new Date()
+};
+// Background watcher interval (check every 30 seconds)
+let watcherInterval = null;
+const WATCHER_INTERVAL_MS = 30000;
+// ============================================
+// API HELPER
+// ============================================
+async function apiRequest(method, path, body) {
+    const response = await fetch(`${BASE_URL}${path}`, {
+        method,
+        headers: {
+            'Authorization': `Bearer ${API_KEY}`,
+            'Content-Type': 'application/json',
+        },
+        body: body ? JSON.stringify(body) : undefined,
+    });
+    if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(errorData.error || `API request failed: ${response.status}`);
+    }
+    if (response.status === 204)
+        return null;
+    return response.json();
+}
+// ============================================
+// AUTO-HOOKS - Run on startup
+// ============================================
+function runGitCommand(cmd) {
+    try {
+        return (0, child_process_1.execSync)(cmd, {
+            cwd: PROJECT_DIR,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe']
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+function sanitizeProjectName(dir) {
+    return path_1.default.basename(dir).toLowerCase().replace(/[^a-z0-9]/g, '_');
+}
+async function loadGitInfo() {
+    const isGitRepo = runGitCommand('git rev-parse --is-inside-work-tree');
+    if (isGitRepo !== 'true')
+        return null;
+    const branch = runGitCommand('git branch --show-current') || 'unknown';
+    const lastCommit = runGitCommand('git rev-parse HEAD') || '';
+    const hasChanges = runGitCommand('git status --porcelain');
+    let commitsSinceLastSession = [];
+    try {
+        const projectData = await apiRequest('GET', `/memory/${USER_ID}/context/last_commit_${sanitizeProjectName(PROJECT_DIR)}`);
+        if (projectData && projectData.value) {
+            sessionState.lastKnownCommit = projectData.value;
+            const logOutput = runGitCommand(`git log ${projectData.value}..HEAD --pretty=format:"%H|%s|%an|%ai" 2>/dev/null`);
+            if (logOutput) {
+                commitsSinceLastSession = logOutput.split('\n').filter(Boolean).map(line => {
+                    const [hash, message, author, date] = line.split('|');
+                    return { hash, message, author, date };
+                });
+            }
+        }
+    }
+    catch {
+        // No previous commit stored
+    }
+    const changedFilesOutput = runGitCommand('git diff --name-only HEAD~5 2>/dev/null') || '';
+    const changedFiles = changedFilesOutput.split('\n').filter(Boolean);
+    return {
+        branch,
+        lastCommit,
+        commitsSinceLastSession,
+        changedFiles,
+        hasUncommittedChanges: Boolean(hasChanges && hasChanges.length > 0)
+    };
+}
+async function analyzeCodebase() {
+    try {
+        const projectName = path_1.default.basename(PROJECT_DIR);
+        const techStack = [];
+        const frameworks = [];
+        const entryPoints = [];
+        const packageJsonPath = path_1.default.join(PROJECT_DIR, 'package.json');
+        let packageManager = null;
+        if (fs_1.default.existsSync(packageJsonPath)) {
+            const pkg = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+            const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+            // Store versions for knowledge queries
+            Object.entries(allDeps).forEach(([name, version]) => {
+                sessionState.packageVersions[name] = version.replace(/[\^~]/g, '');
+            });
+            if (allDeps['react']) {
+                techStack.push('React');
+                frameworks.push('React');
+            }
+            if (allDeps['next']) {
+                techStack.push('Next.js');
+                frameworks.push('Next.js');
+            }
+            if (allDeps['vue']) {
+                techStack.push('Vue');
+                frameworks.push('Vue');
+            }
+            if (allDeps['svelte']) {
+                techStack.push('Svelte');
+                frameworks.push('Svelte');
+            }
+            if (allDeps['express']) {
+                techStack.push('Express');
+                frameworks.push('Express');
+            }
+            if (allDeps['fastify']) {
+                techStack.push('Fastify');
+                frameworks.push('Fastify');
+            }
+            if (allDeps['typescript'])
+                techStack.push('TypeScript');
+            if (allDeps['tailwindcss'])
+                techStack.push('Tailwind CSS');
+            if (allDeps['@supabase/supabase-js'])
+                techStack.push('Supabase');
+            if (allDeps['prisma'] || allDeps['@prisma/client'])
+                techStack.push('Prisma');
+            if (allDeps['drizzle-orm'])
+                techStack.push('Drizzle');
+            if (fs_1.default.existsSync(path_1.default.join(PROJECT_DIR, 'bun.lockb')))
+                packageManager = 'bun';
+            else if (fs_1.default.existsSync(path_1.default.join(PROJECT_DIR, 'pnpm-lock.yaml')))
+                packageManager = 'pnpm';
+            else if (fs_1.default.existsSync(path_1.default.join(PROJECT_DIR, 'yarn.lock')))
+                packageManager = 'yarn';
+            else if (fs_1.default.existsSync(path_1.default.join(PROJECT_DIR, 'package-lock.json')))
+                packageManager = 'npm';
+            if (pkg.main)
+                entryPoints.push(pkg.main);
+            if (pkg.module)
+                entryPoints.push(pkg.module);
+        }
+        if (fs_1.default.existsSync(path_1.default.join(PROJECT_DIR, 'requirements.txt')) ||
+            fs_1.default.existsSync(path_1.default.join(PROJECT_DIR, 'pyproject.toml'))) {
+            techStack.push('Python');
+        }
+        if (fs_1.default.existsSync(path_1.default.join(PROJECT_DIR, 'go.mod')))
+            techStack.push('Go');
+        if (fs_1.default.existsSync(path_1.default.join(PROJECT_DIR, 'Cargo.toml')))
+            techStack.push('Rust');
+        let structure = 'flat';
+        if (fs_1.default.existsSync(path_1.default.join(PROJECT_DIR, 'src')))
+            structure = 'src-based';
+        if (fs_1.default.existsSync(path_1.default.join(PROJECT_DIR, 'app')))
+            structure = 'app-based';
+        if (fs_1.default.existsSync(path_1.default.join(PROJECT_DIR, 'packages')))
+            structure = 'monorepo';
+        const hasTests = fs_1.default.existsSync(path_1.default.join(PROJECT_DIR, 'tests')) ||
+            fs_1.default.existsSync(path_1.default.join(PROJECT_DIR, '__tests__')) ||
+            fs_1.default.existsSync(path_1.default.join(PROJECT_DIR, 'test'));
+        const hasTypeScript = fs_1.default.existsSync(path_1.default.join(PROJECT_DIR, 'tsconfig.json'));
+        return {
+            projectName,
+            techStack,
+            structure,
+            hasTests,
+            hasTypeScript,
+            packageManager,
+            frameworks,
+            entryPoints
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function loadUserMemory() {
+    try {
+        const [preferences, facts, behaviors, projects, history, patterns] = await Promise.all([
+            apiRequest('GET', `/memory/${USER_ID}/context/preference`).catch(() => []),
+            apiRequest('GET', `/memory/${USER_ID}/context/fact`).catch(() => []),
+            apiRequest('GET', `/memory/${USER_ID}/context/behavior`).catch(() => []),
+            apiRequest('GET', `/memory/${USER_ID}/projects`).catch(() => []),
+            apiRequest('GET', `/memory/${USER_ID}/history?limit=5`).catch(() => []),
+            apiRequest('GET', `/knowledge/user/${USER_ID}/patterns`).catch(() => [])
+        ]);
+        return {
+            preferences: Array.isArray(preferences) ? preferences : [],
+            facts: Array.isArray(facts) ? facts : [],
+            behaviors: Array.isArray(behaviors) ? behaviors : [],
+            projects: Array.isArray(projects) ? projects : [],
+            recentHistory: Array.isArray(history) ? history : [],
+            patterns: Array.isArray(patterns) ? patterns : []
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function initializeSession() {
+    console.error('🚀 Persista v3: Initializing session...');
+    const [gitInfo, codebaseDNA, userMemory] = await Promise.all([
+        loadGitInfo(),
+        analyzeCodebase(),
+        loadUserMemory()
+    ]);
+    sessionState = {
+        ...sessionState,
+        startTime: new Date(),
+        gitInfo,
+        codebaseDNA,
+        userMemory
+    };
+    // Save current commit for next session
+    if (gitInfo?.lastCommit) {
+        const projectKey = `last_commit_${sanitizeProjectName(PROJECT_DIR)}`;
+        apiRequest('POST', `/memory/${USER_ID}/context`, {
+            category: 'project',
+            key: projectKey,
+            value: gitInfo.lastCommit,
+            source: 'auto'
+        }).catch(() => { });
+    }
+    console.error(`✅ Persista v3: Session initialized for ${USER_ID}`);
+    console.error(`   Project: ${codebaseDNA?.projectName || 'Unknown'}`);
+    console.error(`   Tech: ${codebaseDNA?.techStack.join(', ') || 'Unknown'}`);
+    console.error(`   Git: ${gitInfo?.branch || 'Not a git repo'}`);
+    if (gitInfo?.commitsSinceLastSession.length) {
+        console.error(`   📝 ${gitInfo.commitsSinceLastSession.length} new commits since last session`);
+    }
+    if (userMemory) {
+        console.error(`   🧠 Loaded ${userMemory.preferences.length} preferences, ${userMemory.facts.length} facts, ${userMemory.patterns.length} patterns`);
+    }
+}
+// Error capture helper
+function captureError(error) {
+    sessionState.recentErrors.push(error);
+    apiRequest('POST', `/memory/${USER_ID}/context`, {
+        category: 'behavior',
+        key: `error_${Date.now()}`,
+        value: error,
+        source: 'auto',
+        confidence: 0.8
+    }).catch(() => { });
+}
+// ============================================
+// PHASE 2: BACKGROUND WATCHERS & ERROR LEARNING
+// ============================================
+// Common error patterns to detect
+const ERROR_PATTERNS = [
+    { pattern: /error TS\d+:/i, type: 'typescript', severity: 'high' },
+    { pattern: /SyntaxError:/i, type: 'syntax', severity: 'high' },
+    { pattern: /ReferenceError:/i, type: 'reference', severity: 'high' },
+    { pattern: /TypeError:/i, type: 'type', severity: 'high' },
+    { pattern: /Cannot find module/i, type: 'module_not_found', severity: 'medium' },
+    { pattern: /ENOENT/i, type: 'file_not_found', severity: 'medium' },
+    { pattern: /EACCES/i, type: 'permission', severity: 'medium' },
+    { pattern: /npm ERR!/i, type: 'npm', severity: 'high' },
+    { pattern: /error: /i, type: 'generic', severity: 'low' },
+    { pattern: /failed/i, type: 'failure', severity: 'medium' },
+    { pattern: /FAIL /i, type: 'test_failure', severity: 'high' },
+    { pattern: /✖|✗|❌/i, type: 'failure_symbol', severity: 'medium' },
+];
+// Parse build output for errors
+function parseBuildOutput(output) {
+    const lines = output.split('\n');
+    const errors = [];
+    const warnings = [];
+    for (const line of lines) {
+        const lineLower = line.toLowerCase();
+        if (lineLower.includes('error') || lineLower.includes('failed') || lineLower.includes('fail ')) {
+            errors.push(line.trim());
+        }
+        else if (lineLower.includes('warning') || lineLower.includes('warn')) {
+            warnings.push(line.trim());
+        }
+    }
+    return { errors: errors.slice(0, 20), warnings: warnings.slice(0, 10) };
+}
+// Extract anti-pattern from error
+function extractAntiPattern(error, context) {
+    for (const { pattern, type, severity } of ERROR_PATTERNS) {
+        if (pattern.test(error)) {
+            return {
+                id: `ap_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                pattern: error.substring(0, 200),
+                context: context.substring(0, 500),
+                occurrences: 1,
+                lastSeen: new Date(),
+                severity
+            };
+        }
+    }
+    return null;
+}
+// Check for test result files
+function findTestResults() {
+    const testResultPaths = [
+        // Jest
+        path_1.default.join(PROJECT_DIR, 'coverage', 'coverage-summary.json'),
+        path_1.default.join(PROJECT_DIR, 'jest-results.json'),
+        // Vitest
+        path_1.default.join(PROJECT_DIR, 'vitest-results.json'),
+        // Generic
+        path_1.default.join(PROJECT_DIR, 'test-results.json'),
+    ];
+    for (const resultPath of testResultPaths) {
+        try {
+            if (fs_1.default.existsSync(resultPath)) {
+                const content = fs_1.default.readFileSync(resultPath, 'utf-8');
+                const data = JSON.parse(content);
+                // Jest format
+                if (data.numPassedTests !== undefined) {
+                    return {
+                        framework: 'jest',
+                        passed: data.numPassedTests || 0,
+                        failed: data.numFailedTests || 0,
+                        skipped: data.numPendingTests || 0,
+                        timestamp: new Date(),
+                        failures: (data.testResults || [])
+                            .flatMap((r) => r.assertionResults || [])
+                            .filter((a) => a.status === 'failed')
+                            .slice(0, 10)
+                            .map((a) => ({
+                            testName: a.title || a.fullName,
+                            message: (a.failureMessages || []).join('\n').substring(0, 500)
+                        }))
+                    };
+                }
+                // Generic format
+                if (data.passed !== undefined) {
+                    return {
+                        framework: 'unknown',
+                        passed: data.passed || 0,
+                        failed: data.failed || 0,
+                        skipped: data.skipped || 0,
+                        timestamp: new Date(),
+                        failures: []
+                    };
+                }
+            }
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    return null;
+}
+// Check for build logs
+function findBuildErrors() {
+    const buildLogPaths = [
+        path_1.default.join(PROJECT_DIR, 'npm-debug.log'),
+        path_1.default.join(PROJECT_DIR, '.npm', '_logs'),
+        path_1.default.join(PROJECT_DIR, 'yarn-error.log'),
+        path_1.default.join(PROJECT_DIR, 'tsconfig.tsbuildinfo'),
+    ];
+    // Check for TypeScript build info
+    const tsBuildInfo = path_1.default.join(PROJECT_DIR, 'tsconfig.tsbuildinfo');
+    if (fs_1.default.existsSync(tsBuildInfo)) {
+        try {
+            const stat = fs_1.default.statSync(tsBuildInfo);
+            const content = fs_1.default.readFileSync(tsBuildInfo, 'utf-8');
+            const data = JSON.parse(content);
+            // If there are semantic diagnostics, there were errors
+            if (data.semanticDiagnosticsPerFile && data.semanticDiagnosticsPerFile.length > 0) {
+                const errors = data.semanticDiagnosticsPerFile
+                    .flatMap((f) => Array.isArray(f) ? f.slice(1) : [])
+                    .filter((d) => d && d.messageText)
+                    .map((d) => typeof d.messageText === 'string' ? d.messageText : d.messageText?.messageText || '')
+                    .slice(0, 10);
+                if (errors.length > 0) {
+                    return {
+                        command: 'tsc',
+                        exitCode: 1,
+                        timestamp: stat.mtime,
+                        errors,
+                        warnings: []
+                    };
+                }
+            }
+        }
+        catch {
+            // Ignore
+        }
+    }
+    return null;
+}
+// Check git for new changes
+async function checkGitChanges() {
+    const currentCommit = runGitCommand('git rev-parse HEAD');
+    if (!currentCommit)
+        return false;
+    if (sessionState.gitInfo && currentCommit !== sessionState.gitInfo.lastCommit) {
+        // New commits detected!
+        const newGitInfo = await loadGitInfo();
+        if (newGitInfo) {
+            sessionState.gitInfo = newGitInfo;
+            console.error(`📝 Persista: Detected ${newGitInfo.commitsSinceLastSession.length} new commits`);
+            return true;
+        }
+    }
+    return false;
+}
+// Background watcher tick
+async function watcherTick() {
+    try {
+        // 1. Check for git changes
+        const gitChanged = await checkGitChanges();
+        sessionState.lastGitCheck = new Date();
+        // 2. Check for test results
+        const testResult = findTestResults();
+        if (testResult && testResult.failed > 0) {
+            // New test failures
+            const lastTest = sessionState.testHistory[sessionState.testHistory.length - 1];
+            if (!lastTest || lastTest.timestamp.getTime() !== testResult.timestamp.getTime()) {
+                sessionState.testHistory.push(testResult);
+                console.error(`🧪 Persista: Detected test results - ${testResult.passed} passed, ${testResult.failed} failed`);
+                // Extract anti-patterns from failures
+                for (const failure of testResult.failures) {
+                    const antiPattern = extractAntiPattern(failure.message, failure.testName);
+                    if (antiPattern) {
+                        sessionState.antiPatterns.push(antiPattern);
+                        // Save to Persista
+                        apiRequest('POST', `/memory/${USER_ID}/context`, {
+                            category: 'behavior',
+                            key: `test_failure_${antiPattern.id}`,
+                            value: {
+                                type: 'test_failure',
+                                testName: failure.testName,
+                                message: failure.message,
+                                file: failure.file,
+                                pattern: antiPattern.pattern
+                            },
+                            source: 'auto',
+                            confidence: 0.9
+                        }).catch(() => { });
+                    }
+                }
+            }
+        }
+        // 3. Check for build errors
+        const buildResult = findBuildErrors();
+        if (buildResult && buildResult.errors.length > 0) {
+            const lastBuild = sessionState.buildHistory[sessionState.buildHistory.length - 1];
+            if (!lastBuild || lastBuild.timestamp.getTime() !== buildResult.timestamp.getTime()) {
+                sessionState.buildHistory.push(buildResult);
+                console.error(`🔨 Persista: Detected build errors - ${buildResult.errors.length} errors`);
+                // Extract anti-patterns
+                for (const error of buildResult.errors) {
+                    const antiPattern = extractAntiPattern(error, buildResult.command);
+                    if (antiPattern) {
+                        sessionState.antiPatterns.push(antiPattern);
+                        // Save to Persista
+                        apiRequest('POST', `/memory/${USER_ID}/context`, {
+                            category: 'behavior',
+                            key: `build_error_${antiPattern.id}`,
+                            value: {
+                                type: 'build_error',
+                                command: buildResult.command,
+                                error: error,
+                                pattern: antiPattern.pattern
+                            },
+                            source: 'auto',
+                            confidence: 0.85
+                        }).catch(() => { });
+                    }
+                }
+            }
+        }
+    }
+    catch (err) {
+        // Silent fail - don't interrupt the session
+    }
+}
+// Start background watcher
+function startWatcher() {
+    if (watcherInterval)
+        return;
+    console.error('👀 Persista: Starting background watcher...');
+    watcherInterval = setInterval(watcherTick, WATCHER_INTERVAL_MS);
+    // Also run immediately
+    watcherTick();
+}
+// Stop background watcher
+function stopWatcher() {
+    if (watcherInterval) {
+        clearInterval(watcherInterval);
+        watcherInterval = null;
+        console.error('👀 Persista: Stopped background watcher');
+    }
+}
+// Deep DNA state
+let codebaseDNADeep = null;
+// Analyze file for conventions
+function analyzeFileConventions(content, filePath) {
+    const lines = content.split('\n');
+    // Indentation
+    let tabCount = 0;
+    let spaceCount = 0;
+    let spaceSizes = [];
+    for (const line of lines) {
+        if (line.startsWith('\t'))
+            tabCount++;
+        else if (line.startsWith('  ')) {
+            spaceCount++;
+            const match = line.match(/^( +)/);
+            if (match)
+                spaceSizes.push(match[1].length);
+        }
+    }
+    const indentation = tabCount > spaceCount ? 'tabs' : spaceCount > tabCount ? 'spaces' : 'unknown';
+    const indentSize = spaceSizes.length > 0
+        ? Math.min(...spaceSizes.filter(s => s > 0))
+        : 2;
+    // Semicolons (for JS/TS files)
+    const hasSemicolons = /;\s*$/.test(content);
+    const hasNoSemicolons = /[^;{}\s]\s*\n/.test(content);
+    const semicolons = filePath.match(/\.(js|ts|tsx|jsx)$/)
+        ? (hasSemicolons && !hasNoSemicolons ? true : !hasSemicolons ? false : null)
+        : null;
+    // Quotes
+    const singleQuotes = (content.match(/'/g) || []).length;
+    const doubleQuotes = (content.match(/"/g) || []).length;
+    const quotes = singleQuotes > doubleQuotes * 1.5 ? 'single'
+        : doubleQuotes > singleQuotes * 1.5 ? 'double'
+            : null;
+    return { indentation, indentSize, semicolons, quotes };
+}
+// Detect import patterns
+function detectImportPatterns(content) {
+    const patterns = [];
+    // Check for barrel exports
+    if (/from ['"]\.\/index['"]/.test(content) || /from ['"]@\//.test(content)) {
+        patterns.push('barrel-exports');
+    }
+    // Check for path aliases
+    if (/from ['"]@\//.test(content) || /from ['"]~\//.test(content)) {
+        patterns.push('path-aliases');
+    }
+    // Check for absolute imports
+    if (/from ['"]src\//.test(content)) {
+        patterns.push('absolute-imports');
+    }
+    // Check for relative imports depth
+    if (/from ['"]\.\.\/\.\.\//.test(content)) {
+        patterns.push('deep-relative-imports');
+    }
+    // Check for named exports preference
+    if (/^export \{/.test(content)) {
+        patterns.push('named-exports');
+    }
+    // Check for default exports
+    if (/^export default/.test(content)) {
+        patterns.push('default-exports');
+    }
+    return patterns;
+}
+// Detect React/component patterns
+function detectComponentPatterns(content, filePath) {
+    const patterns = [];
+    if (!filePath.match(/\.(jsx|tsx)$/))
+        return patterns;
+    // Functional vs class components
+    if (/function\s+\w+.*\(.*\).*{[\s\S]*return\s*\(/.test(content) ||
+        /const\s+\w+.*=.*\(.*\).*=>/.test(content)) {
+        patterns.push('functional-components');
+    }
+    if (/class\s+\w+\s+extends\s+(React\.)?Component/.test(content)) {
+        patterns.push('class-components');
+    }
+    // Hooks usage
+    if (/use[A-Z]\w+\(/.test(content)) {
+        patterns.push('hooks');
+    }
+    // Custom hooks
+    if (/^(export\s+)?(function|const)\s+use[A-Z]/.test(content)) {
+        patterns.push('custom-hooks');
+    }
+    // Render props
+    if (/render\s*=\s*\{/.test(content) || /children\s*\(/.test(content)) {
+        patterns.push('render-props');
+    }
+    // HOCs
+    if (/with[A-Z]\w+\(/.test(content) || /export default \w+\(\w+\)/.test(content)) {
+        patterns.push('higher-order-components');
+    }
+    // Compound components
+    if (/\w+\.\w+\s*=/.test(content)) {
+        patterns.push('compound-components');
+    }
+    // Styled components
+    if (/styled\.\w+`/.test(content) || /styled\(\w+\)`/.test(content)) {
+        patterns.push('styled-components');
+    }
+    // CSS Modules
+    if (/import\s+\w+\s+from\s+['"].*\.module\.(css|scss)['"]/.test(content)) {
+        patterns.push('css-modules');
+    }
+    // Tailwind
+    if (/className\s*=\s*['"][^'"]*\b(flex|grid|p-|m-|text-|bg-)\b/.test(content)) {
+        patterns.push('tailwind');
+    }
+    return patterns;
+}
+// Detect architecture style
+function detectArchitecture() {
+    const dirs = new Set();
+    // Check common directories
+    const checkDirs = [
+        'src/components', 'src/pages', 'src/views', 'src/screens',
+        'src/hooks', 'src/utils', 'src/helpers', 'src/lib',
+        'src/services', 'src/api', 'src/store', 'src/state',
+        'src/features', 'src/modules', 'src/domains',
+        'src/types', 'src/interfaces', 'src/models',
+        'app', 'pages', 'components', 'lib', 'utils'
+    ];
+    for (const dir of checkDirs) {
+        if (fs_1.default.existsSync(path_1.default.join(PROJECT_DIR, dir))) {
+            dirs.add(dir.split('/').pop() || dir);
+        }
+    }
+    const layers = Array.from(dirs);
+    // Determine style
+    let style = 'unknown';
+    if (dirs.has('features') || dirs.has('modules') || dirs.has('domains')) {
+        style = 'feature-based';
+    }
+    else if (dirs.has('components') && dirs.has('services') && dirs.has('utils')) {
+        style = 'layer-based';
+    }
+    else if (dirs.has('pages') && dirs.has('components')) {
+        style = 'page-based';
+    }
+    else if (fs_1.default.existsSync(path_1.default.join(PROJECT_DIR, 'app'))) {
+        style = 'app-router'; // Next.js 13+
+    }
+    return { style, layers };
+}
+// Detect test framework
+function detectTestFramework() {
+    const packageJsonPath = path_1.default.join(PROJECT_DIR, 'package.json');
+    if (!fs_1.default.existsSync(packageJsonPath))
+        return null;
+    try {
+        const pkg = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+        const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (allDeps['jest'])
+            return 'jest';
+        if (allDeps['vitest'])
+            return 'vitest';
+        if (allDeps['mocha'])
+            return 'mocha';
+        if (allDeps['ava'])
+            return 'ava';
+        if (allDeps['@testing-library/react'])
+            return 'testing-library';
+        if (allDeps['cypress'])
+            return 'cypress';
+        if (allDeps['playwright'])
+            return 'playwright';
+    }
+    catch { }
+    return null;
+}
+// Detect state management
+function detectStateManagement() {
+    const packageJsonPath = path_1.default.join(PROJECT_DIR, 'package.json');
+    if (!fs_1.default.existsSync(packageJsonPath))
+        return [];
+    try {
+        const pkg = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+        const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+        const patterns = [];
+        if (allDeps['zustand'])
+            patterns.push('zustand');
+        if (allDeps['@reduxjs/toolkit'] || allDeps['redux'])
+            patterns.push('redux');
+        if (allDeps['recoil'])
+            patterns.push('recoil');
+        if (allDeps['jotai'])
+            patterns.push('jotai');
+        if (allDeps['mobx'])
+            patterns.push('mobx');
+        if (allDeps['valtio'])
+            patterns.push('valtio');
+        if (allDeps['@tanstack/react-query'] || allDeps['react-query'])
+            patterns.push('react-query');
+        if (allDeps['swr'])
+            patterns.push('swr');
+        if (patterns.length === 0)
+            patterns.push('context-only');
+        return patterns;
+    }
+    catch {
+        return [];
+    }
+}
+// Detect API patterns
+function detectApiPatterns() {
+    const packageJsonPath = path_1.default.join(PROJECT_DIR, 'package.json');
+    if (!fs_1.default.existsSync(packageJsonPath))
+        return [];
+    try {
+        const pkg = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+        const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+        const patterns = [];
+        if (allDeps['@trpc/client'] || allDeps['@trpc/server'])
+            patterns.push('tRPC');
+        if (allDeps['graphql'] || allDeps['@apollo/client'])
+            patterns.push('GraphQL');
+        if (allDeps['axios'] || allDeps['ky'] || allDeps['got'])
+            patterns.push('REST');
+        if (allDeps['@tanstack/react-query'])
+            patterns.push('React Query');
+        if (allDeps['swr'])
+            patterns.push('SWR');
+        // Check for API routes
+        if (fs_1.default.existsSync(path_1.default.join(PROJECT_DIR, 'pages/api')) ||
+            fs_1.default.existsSync(path_1.default.join(PROJECT_DIR, 'app/api'))) {
+            patterns.push('API-routes');
+        }
+        return patterns;
+    }
+    catch {
+        return [];
+    }
+}
+// Find critical paths
+function findCriticalPaths() {
+    const critical = [];
+    const criticalPatterns = [
+        { pattern: '**/auth/**', reason: 'Authentication logic' },
+        { pattern: '**/api/**', reason: 'API endpoints' },
+        { pattern: '**/middleware*', reason: 'Request middleware' },
+        { pattern: '**/config*', reason: 'Configuration' },
+        { pattern: '**/.env*', reason: 'Environment variables' },
+        { pattern: '**/database*', reason: 'Database logic' },
+        { pattern: '**/prisma/**', reason: 'Database schema' },
+        { pattern: '**/supabase/**', reason: 'Supabase configuration' },
+    ];
+    // Check for common critical directories
+    const checkPaths = [
+        { path: 'src/auth', reason: 'Authentication logic' },
+        { path: 'src/api', reason: 'API layer' },
+        { path: 'src/lib/auth', reason: 'Auth utilities' },
+        { path: 'src/middleware.ts', reason: 'Next.js middleware' },
+        { path: 'middleware.ts', reason: 'Next.js middleware' },
+        { path: 'prisma/schema.prisma', reason: 'Database schema' },
+        { path: 'supabase/migrations', reason: 'Database migrations' },
+        { path: '.env', reason: 'Environment config' },
+        { path: '.env.local', reason: 'Local environment' },
+    ];
+    for (const { path: checkPath, reason } of checkPaths) {
+        const fullPath = path_1.default.join(PROJECT_DIR, checkPath);
+        if (fs_1.default.existsSync(fullPath)) {
+            critical.push({ path: checkPath, reason });
+        }
+    }
+    return critical.slice(0, 10); // Limit to 10
+}
+// Get file naming convention
+function getFileNamingConvention() {
+    const srcDir = path_1.default.join(PROJECT_DIR, 'src');
+    if (!fs_1.default.existsSync(srcDir))
+        return 'mixed';
+    try {
+        const files = [];
+        function scanDir(dir, depth = 0) {
+            if (depth > 2)
+                return;
+            const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isFile() && entry.name.match(/\.(ts|tsx|js|jsx)$/)) {
+                    files.push(entry.name.replace(/\.(ts|tsx|js|jsx)$/, ''));
+                }
+                else if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
+                    scanDir(path_1.default.join(dir, entry.name), depth + 1);
+                }
+            }
+        }
+        scanDir(srcDir);
+        let camelCase = 0, pascalCase = 0, kebabCase = 0, snakeCase = 0;
+        for (const file of files) {
+            if (/^[a-z][a-zA-Z0-9]*$/.test(file) && /[A-Z]/.test(file))
+                camelCase++;
+            else if (/^[A-Z][a-zA-Z0-9]*$/.test(file))
+                pascalCase++;
+            else if (/^[a-z][a-z0-9-]*$/.test(file) && file.includes('-'))
+                kebabCase++;
+            else if (/^[a-z][a-z0-9_]*$/.test(file) && file.includes('_'))
+                snakeCase++;
+        }
+        const max = Math.max(camelCase, pascalCase, kebabCase, snakeCase);
+        if (max === 0)
+            return 'mixed';
+        if (camelCase === max)
+            return 'camelCase';
+        if (pascalCase === max)
+            return 'PascalCase';
+        if (kebabCase === max)
+            return 'kebab-case';
+        if (snakeCase === max)
+            return 'snake_case';
+        return 'mixed';
+    }
+    catch {
+        return 'mixed';
+    }
+}
+// Full deep DNA analysis
+async function analyzeCodebaseDNADeep() {
+    console.error('🧬 Persista: Analyzing codebase DNA...');
+    try {
+        const basicDNA = sessionState.codebaseDNA;
+        if (!basicDNA)
+            return null;
+        // Analyze sample files for conventions
+        const srcDir = path_1.default.join(PROJECT_DIR, 'src');
+        let sampleContent = '';
+        let filesAnalyzed = 0;
+        const importPatterns = new Set();
+        const componentPatterns = new Set();
+        function scanForSamples(dir, depth = 0) {
+            if (depth > 3 || filesAnalyzed > 20)
+                return;
+            if (!fs_1.default.existsSync(dir))
+                return;
+            try {
+                const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (filesAnalyzed > 20)
+                        return;
+                    const fullPath = path_1.default.join(dir, entry.name);
+                    if (entry.isFile() && entry.name.match(/\.(ts|tsx|js|jsx)$/) && !entry.name.includes('.test.') && !entry.name.includes('.spec.')) {
+                        try {
+                            const content = fs_1.default.readFileSync(fullPath, 'utf-8');
+                            if (content.length < 50000) { // Skip huge files
+                                sampleContent += content + '\n';
+                                filesAnalyzed++;
+                                // Collect patterns
+                                detectImportPatterns(content).forEach(p => importPatterns.add(p));
+                                detectComponentPatterns(content, fullPath).forEach(p => componentPatterns.add(p));
+                            }
+                        }
+                        catch { }
+                    }
+                    else if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
+                        scanForSamples(fullPath, depth + 1);
+                    }
+                }
+            }
+            catch { }
+        }
+        scanForSamples(srcDir);
+        scanForSamples(path_1.default.join(PROJECT_DIR, 'app'));
+        scanForSamples(path_1.default.join(PROJECT_DIR, 'pages'));
+        // Analyze conventions
+        const convAnalysis = analyzeFileConventions(sampleContent, 'sample.tsx');
+        // Detect architecture
+        const { style, layers } = detectArchitecture();
+        // Build deep DNA
+        const dna = {
+            projectName: basicDNA.projectName,
+            techStack: basicDNA.techStack,
+            frameworks: basicDNA.frameworks,
+            structure: basicDNA.structure,
+            conventions: {
+                indentation: convAnalysis.indentation,
+                indentSize: convAnalysis.indentSize,
+                semicolons: convAnalysis.semicolons ?? 'mixed',
+                quotes: convAnalysis.quotes ?? 'mixed',
+                trailingCommas: 'mixed', // Hard to detect reliably
+                fileNaming: getFileNamingConvention(),
+                componentNaming: componentPatterns.has('functional-components') ? 'PascalCase' : 'unknown'
+            },
+            patterns: {
+                imports: Array.from(importPatterns),
+                components: Array.from(componentPatterns),
+                stateManagement: detectStateManagement(),
+                apiPatterns: detectApiPatterns(),
+                errorHandling: [] // TODO: detect error handling patterns
+            },
+            architecture: {
+                style,
+                layers,
+                hasTests: basicDNA.hasTests,
+                testFramework: detectTestFramework(),
+                hasCICD: fs_1.default.existsSync(path_1.default.join(PROJECT_DIR, '.github/workflows')) ||
+                    fs_1.default.existsSync(path_1.default.join(PROJECT_DIR, '.gitlab-ci.yml')),
+                hasDocker: fs_1.default.existsSync(path_1.default.join(PROJECT_DIR, 'Dockerfile')) ||
+                    fs_1.default.existsSync(path_1.default.join(PROJECT_DIR, 'docker-compose.yml'))
+            },
+            criticalPaths: findCriticalPaths(),
+            decisions: [] // Loaded from Persista
+        };
+        console.error(`✅ Persista: DNA analyzed - ${style} architecture, ${filesAnalyzed} files scanned`);
+        console.error(`   Patterns: ${Array.from(componentPatterns).slice(0, 5).join(', ')}`);
+        console.error(`   State: ${dna.patterns.stateManagement.join(', ') || 'none detected'}`);
+        return dna;
+    }
+    catch (err) {
+        console.error('Error analyzing DNA:', err);
+        return null;
+    }
+}
+// Load decisions from Persista
+async function loadDecisions() {
+    try {
+        const projectName = sessionState.codebaseDNA?.projectName || 'unknown';
+        const context = await apiRequest('GET', `/memory/${USER_ID}/context/project`);
+        if (!Array.isArray(context))
+            return [];
+        return context
+            .filter((c) => c.key?.startsWith('decision_'))
+            .map((c) => ({
+            decision: c.value?.decision || '',
+            reason: c.value?.reason || '',
+            date: new Date(c.created_at || Date.now()),
+            alternatives: c.value?.alternatives
+        }))
+            .slice(0, 20);
+    }
+    catch {
+        return [];
+    }
+}
+// ============================================
+// CREATE MCP SERVER
+// ============================================
+const server = new index_js_1.Server({
+    name: 'persista',
+    version: '3.0.0',
+}, {
+    capabilities: {
+        tools: {},
+        resources: {},
+    },
+});
+// ============================================
+// RESOURCES - Auto-injected context
+// ============================================
+server.setRequestHandler(types_js_1.ListResourcesRequestSchema, async () => {
+    return {
+        resources: [
+            {
+                uri: 'persista://session/context',
+                name: '🧠 Persista Session Context',
+                description: 'IMPORTANT: Contains user memories, preferences, project context, git changes, and patterns. Read this for personalized responses.',
+                mimeType: 'application/json'
+            },
+            {
+                uri: 'persista://user/memory',
+                name: 'User Memory & Preferences',
+                description: 'All stored memories with effective confidence scores',
+                mimeType: 'application/json'
+            },
+            {
+                uri: 'persista://codebase/dna',
+                name: 'Codebase DNA',
+                description: 'Tech stack, frameworks, structure, package versions',
+                mimeType: 'application/json'
+            },
+            {
+                uri: 'persista://codebase/dna-deep',
+                name: '🧬 Deep Codebase DNA',
+                description: 'Conventions, patterns, architecture, critical paths - the soul of the codebase',
+                mimeType: 'application/json'
+            },
+            {
+                uri: 'persista://git/changes',
+                name: 'Git Changes',
+                description: 'Commits and changes since last session',
+                mimeType: 'application/json'
+            },
+            {
+                uri: 'persista://knowledge/relevant',
+                name: 'Relevant Knowledge',
+                description: 'Best practices for this project\'s tech stack',
+                mimeType: 'application/json'
+            },
+            {
+                uri: 'persista://errors/learned',
+                name: '⚠️ Error Learning',
+                description: 'Build errors, test failures, and anti-patterns detected this session',
+                mimeType: 'application/json'
+            }
+        ]
+    };
+});
+server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    switch (uri) {
+        case 'persista://session/context': {
+            const context = {
+                _note: 'Your persistent context. Use this to personalize responses.',
+                user: {
+                    id: sessionState.userId,
+                    preferences: sessionState.userMemory?.preferences || [],
+                    facts: sessionState.userMemory?.facts || [],
+                    behaviors: sessionState.userMemory?.behaviors || [],
+                    patterns: sessionState.userMemory?.patterns || []
+                },
+                currentProject: {
+                    name: sessionState.codebaseDNA?.projectName,
+                    directory: sessionState.projectDir,
+                    techStack: sessionState.codebaseDNA?.techStack || [],
+                    frameworks: sessionState.codebaseDNA?.frameworks || [],
+                    structure: sessionState.codebaseDNA?.structure,
+                    hasTypeScript: sessionState.codebaseDNA?.hasTypeScript,
+                    packageManager: sessionState.codebaseDNA?.packageManager,
+                    packageVersions: sessionState.packageVersions
+                },
+                gitStatus: sessionState.gitInfo ? {
+                    branch: sessionState.gitInfo.branch,
+                    hasUncommittedChanges: sessionState.gitInfo.hasUncommittedChanges,
+                    commitsSinceLastSession: sessionState.gitInfo.commitsSinceLastSession.length,
+                    recentChanges: sessionState.gitInfo.commitsSinceLastSession.slice(0, 5).map(c => c.message),
+                    changedFiles: sessionState.gitInfo.changedFiles.slice(0, 10)
+                } : null,
+                session: {
+                    startTime: sessionState.startTime,
+                    errorsThisSession: sessionState.recentErrors.length,
+                    buildErrors: sessionState.buildHistory.length,
+                    testFailures: sessionState.testHistory.filter(t => t.failed > 0).length,
+                    antiPatternsLearned: sessionState.antiPatterns.length
+                },
+                recentConversations: sessionState.userMemory?.recentHistory?.slice(0, 3) || [],
+                errorLearning: {
+                    recentBuildErrors: sessionState.buildHistory.slice(-3).map(b => ({
+                        command: b.command,
+                        errorCount: b.errors.length,
+                        timestamp: b.timestamp
+                    })),
+                    recentTestFailures: sessionState.testHistory.slice(-3).map(t => ({
+                        framework: t.framework,
+                        failed: t.failed,
+                        passed: t.passed,
+                        timestamp: t.timestamp
+                    })),
+                    antiPatterns: sessionState.antiPatterns.slice(-5).map(ap => ({
+                        pattern: ap.pattern,
+                        severity: ap.severity,
+                        occurrences: ap.occurrences
+                    }))
+                }
+            };
+            return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(context, null, 2) }] };
+        }
+        case 'persista://user/memory': {
+            return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(sessionState.userMemory || {}, null, 2) }] };
+        }
+        case 'persista://codebase/dna': {
+            return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify({
+                            ...sessionState.codebaseDNA,
+                            packageVersions: sessionState.packageVersions
+                        }, null, 2) }] };
+        }
+        case 'persista://codebase/dna-deep': {
+            // Lazy load deep DNA if not already analyzed
+            if (!codebaseDNADeep) {
+                codebaseDNADeep = await analyzeCodebaseDNADeep();
+                if (codebaseDNADeep) {
+                    codebaseDNADeep.decisions = await loadDecisions();
+                }
+            }
+            return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(codebaseDNADeep || {
+                            error: 'Could not analyze codebase'
+                        }, null, 2) }] };
+        }
+        case 'persista://git/changes': {
+            return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(sessionState.gitInfo || {}, null, 2) }] };
+        }
+        case 'persista://knowledge/relevant': {
+            // Fetch relevant knowledge for this project's tech stack
+            const knowledge = [];
+            for (const tech of (sessionState.codebaseDNA?.techStack || [])) {
+                try {
+                    const version = sessionState.packageVersions[tech.toLowerCase()];
+                    const result = await apiRequest('GET', `/knowledge?domain=${tech.toLowerCase()}${version ? `&version=${version}` : ''}`);
+                    if (Array.isArray(result))
+                        knowledge.push(...result);
+                }
+                catch { }
+            }
+            return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(knowledge, null, 2) }] };
+        }
+        case 'persista://errors/learned': {
+            return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify({
+                            _note: 'Errors and anti-patterns detected this session. Avoid these patterns!',
+                            buildHistory: sessionState.buildHistory.map(b => ({
+                                command: b.command,
+                                exitCode: b.exitCode,
+                                timestamp: b.timestamp,
+                                errors: b.errors,
+                                warnings: b.warnings
+                            })),
+                            testHistory: sessionState.testHistory.map(t => ({
+                                framework: t.framework,
+                                passed: t.passed,
+                                failed: t.failed,
+                                skipped: t.skipped,
+                                timestamp: t.timestamp,
+                                failures: t.failures
+                            })),
+                            antiPatterns: sessionState.antiPatterns.map(ap => ({
+                                pattern: ap.pattern,
+                                context: ap.context,
+                                severity: ap.severity,
+                                occurrences: ap.occurrences,
+                                lastSeen: ap.lastSeen
+                            })),
+                            recentErrors: sessionState.recentErrors.slice(-10)
+                        }, null, 2) }] };
+        }
+        default:
+            throw new Error(`Unknown resource: ${uri}`);
+    }
+});
+// ============================================
+// TOOLS - All capabilities
+// ============================================
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            // ═══════════════════════════════════════
+            // MEMORY TOOLS (v3)
+            // ═══════════════════════════════════════
+            {
+                name: 'memory_save',
+                description: 'Save something about the user to persistent memory. Supports confidence decay, code attachment, and smart merging.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        category: { type: 'string', enum: ['preference', 'fact', 'project', 'behavior', 'custom'] },
+                        key: { type: 'string', description: 'Unique identifier' },
+                        value: { type: 'object', description: 'Data to store (JSON)' },
+                        confidence: { type: 'number', minimum: 0, maximum: 1, description: 'Confidence 0-1 (default 1.0)' },
+                        decay_rate: { type: 'number', description: 'How fast to decay (default 0.01)' },
+                        code_file: { type: 'string', description: 'Attach to specific file' },
+                        code_line_start: { type: 'number', description: 'Start line for code attachment' },
+                        code_line_end: { type: 'number', description: 'End line for code attachment' },
+                        tags: { type: 'array', items: { type: 'string' }, description: 'Tags for categorization' },
+                        merge: { type: 'boolean', description: 'Smart merge with existing (default false)' }
+                    },
+                    required: ['category', 'key', 'value']
+                }
+            },
+            {
+                name: 'memory_get',
+                description: 'Get all memories with effective confidence scores',
+                inputSchema: { type: 'object', properties: {}, required: [] }
+            },
+            {
+                name: 'memory_search',
+                description: 'Semantic search through memories',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        query: { type: 'string', description: 'Search query' },
+                        category: { type: 'string', description: 'Filter by category' }
+                    },
+                    required: ['query']
+                }
+            },
+            {
+                name: 'memory_for_file',
+                description: 'Get memories attached to a specific file/line',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        file: { type: 'string', description: 'File path' },
+                        line: { type: 'number', description: 'Line number (optional)' }
+                    },
+                    required: ['file']
+                }
+            },
+            {
+                name: 'memory_history',
+                description: 'Get history of changes to a memory',
+                inputSchema: {
+                    type: 'object',
+                    properties: { key: { type: 'string' } },
+                    required: ['key']
+                }
+            },
+            {
+                name: 'memory_extract',
+                description: 'Auto-extract memories from text (preferences, facts, tech choices)',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        text: { type: 'string', description: 'Text to analyze' }
+                    },
+                    required: ['text']
+                }
+            },
+            {
+                name: 'memory_forget',
+                description: 'Delete a memory',
+                inputSchema: {
+                    type: 'object',
+                    properties: { key: { type: 'string' } },
+                    required: ['key']
+                }
+            },
+            // ═══════════════════════════════════════
+            // CONTEXT TOOLS (v3)
+            // ═══════════════════════════════════════
+            {
+                name: 'context_pack',
+                description: 'Smart pack context within token budget, prioritizing relevance',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        max_tokens: { type: 'number', description: 'Token budget (default 4000)' },
+                        current_context: { type: 'string', description: 'Current conversation for relevance matching' },
+                        include_memories: { type: 'boolean', description: 'Include memories (default true)' },
+                        include_history: { type: 'boolean', description: 'Include history (default true)' }
+                    },
+                    required: []
+                }
+            },
+            {
+                name: 'context_relevant',
+                description: 'Get most relevant context for current conversation',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        context: { type: 'string', description: 'Current conversation/topic' },
+                        limit: { type: 'number', description: 'Max results (default 10)' }
+                    },
+                    required: []
+                }
+            },
+            {
+                name: 'context_thread_create',
+                description: 'Create a context thread to link related conversations',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string', description: 'Thread name' },
+                        description: { type: 'string' },
+                        tags: { type: 'array', items: { type: 'string' } }
+                    },
+                    required: ['name']
+                }
+            },
+            {
+                name: 'context_summary_save',
+                description: 'Save conversation summary with threading and milestone support',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        summary: { type: 'string' },
+                        key_points: { type: 'array', items: { type: 'string' } },
+                        decisions: { type: 'array', items: { type: 'string' } },
+                        action_items: { type: 'array', items: { type: 'string' } },
+                        thread_id: { type: 'string', description: 'Link to thread' },
+                        priority: { type: 'number', description: '1-10 (default 5)' },
+                        is_milestone: { type: 'boolean', description: 'Mark as important milestone' }
+                    },
+                    required: ['summary']
+                }
+            },
+            // ═══════════════════════════════════════
+            // SYNC TOOLS (v3)
+            // ═══════════════════════════════════════
+            {
+                name: 'sync_discover',
+                description: 'Discover if other AI instances are working on this project',
+                inputSchema: { type: 'object', properties: {}, required: [] }
+            },
+            {
+                name: 'sync_intent',
+                description: 'Broadcast intent to edit a file (prevents conflicts)',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        intent_type: { type: 'string', enum: ['edit', 'refactor', 'delete', 'create'] },
+                        target_file: { type: 'string', description: 'File to edit' },
+                        target_lines: { type: 'string', description: 'Line range e.g. "10-50"' },
+                        description: { type: 'string', description: 'What you plan to do' }
+                    },
+                    required: ['intent_type', 'target_file']
+                }
+            },
+            {
+                name: 'sync_check_conflicts',
+                description: 'Check if anyone else is working on a file',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        file: { type: 'string', description: 'File to check' }
+                    },
+                    required: ['file']
+                }
+            },
+            // ═══════════════════════════════════════
+            // KNOWLEDGE TOOLS (v3)
+            // ═══════════════════════════════════════
+            {
+                name: 'knowledge_check',
+                description: 'Check best practices - VERSION AWARE based on your package.json',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        domain: { type: 'string', description: 'Tech domain (react, nextjs, etc)' },
+                        topic: { type: 'string', description: 'Specific topic' },
+                        version: { type: 'string', description: 'Override version (auto-detected from package.json)' }
+                    },
+                    required: ['domain']
+                }
+            },
+            {
+                name: 'knowledge_deprecations',
+                description: 'Get deprecation warnings for a technology',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        domain: { type: 'string' },
+                        version: { type: 'string' }
+                    },
+                    required: ['domain']
+                }
+            },
+            {
+                name: 'knowledge_scan_code',
+                description: 'Scan code for deprecated patterns',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        code: { type: 'string', description: 'Code to scan' },
+                        file_path: { type: 'string', description: 'File path for context' }
+                    },
+                    required: ['code']
+                }
+            },
+            {
+                name: 'knowledge_learn_pattern',
+                description: 'Learn a user pattern (your personal best practice)',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        domain: { type: 'string', description: 'Tech domain' },
+                        pattern_name: { type: 'string', description: 'Name of the pattern' },
+                        description: { type: 'string' },
+                        code_example: { type: 'string' }
+                    },
+                    required: ['domain', 'pattern_name']
+                }
+            },
+            {
+                name: 'knowledge_my_patterns',
+                description: 'Get user\'s learned patterns',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        domain: { type: 'string', description: 'Filter by domain' }
+                    },
+                    required: []
+                }
+            },
+            // ═══════════════════════════════════════
+            // ERROR TRACKING
+            // ═══════════════════════════════════════
+            {
+                name: 'error_capture',
+                description: 'Capture an error for learning (AI will avoid this pattern)',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        type: { type: 'string', enum: ['build_error', 'runtime_error', 'test_failure', 'lint_error', 'type_error', 'other'] },
+                        message: { type: 'string' },
+                        file: { type: 'string' },
+                        context: { type: 'string', description: 'What was being attempted' },
+                        ai_generated: { type: 'boolean', description: 'Was this AI-generated code?' }
+                    },
+                    required: ['type', 'message']
+                }
+            },
+            {
+                name: 'error_patterns',
+                description: 'Get known error patterns to avoid',
+                inputSchema: { type: 'object', properties: {}, required: [] }
+            },
+            // ═══════════════════════════════════════
+            // SESSION
+            // ═══════════════════════════════════════
+            {
+                name: 'session_refresh',
+                description: 'Refresh session context (reload memories, git, etc)',
+                inputSchema: { type: 'object', properties: {}, required: [] }
+            },
+            {
+                name: 'session_summary',
+                description: 'Get full session context summary',
+                inputSchema: { type: 'object', properties: {}, required: [] }
+            },
+            // ═══════════════════════════════════════
+            // DNA TOOLS (Phase 3)
+            // ═══════════════════════════════════════
+            {
+                name: 'dna_analyze',
+                description: 'Deep analyze the codebase DNA - patterns, conventions, architecture. Run this to understand the codebase deeply.',
+                inputSchema: { type: 'object', properties: {}, required: [] }
+            },
+            {
+                name: 'dna_conventions',
+                description: 'Get coding conventions for this codebase (indentation, quotes, naming, etc.)',
+                inputSchema: { type: 'object', properties: {}, required: [] }
+            },
+            {
+                name: 'dna_patterns',
+                description: 'Get detected code patterns (imports, components, state management, API patterns)',
+                inputSchema: { type: 'object', properties: {}, required: [] }
+            },
+            {
+                name: 'dna_architecture',
+                description: 'Get architecture info (style, layers, critical paths)',
+                inputSchema: { type: 'object', properties: {}, required: [] }
+            },
+            {
+                name: 'dna_add_decision',
+                description: 'Record an architecture or tech decision for this project',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        decision: { type: 'string', description: 'What was decided' },
+                        reason: { type: 'string', description: 'Why this decision was made' },
+                        alternatives: { type: 'array', items: { type: 'string' }, description: 'Alternatives considered' }
+                    },
+                    required: ['decision', 'reason']
+                }
+            },
+            {
+                name: 'dna_decisions',
+                description: 'Get all recorded decisions for this project',
+                inputSchema: { type: 'object', properties: {}, required: [] }
+            },
+            {
+                name: 'dna_critical_paths',
+                description: 'Get critical paths in the codebase that need careful handling',
+                inputSchema: { type: 'object', properties: {}, required: [] }
+            },
+            {
+                name: 'dna_mark_critical',
+                description: 'Mark a path as critical (needs careful handling)',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string', description: 'File or directory path' },
+                        reason: { type: 'string', description: 'Why this is critical' }
+                    },
+                    required: ['path', 'reason']
+                }
+            }
+        ]
+    };
+});
+// ============================================
+// TOOL HANDLERS
+// ============================================
+server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const typedArgs = args;
+    try {
+        switch (name) {
+            // ═══════════════════════════════════════
+            // MEMORY HANDLERS
+            // ═══════════════════════════════════════
+            case 'memory_save': {
+                const result = await apiRequest('POST', `/memory/${USER_ID}/context`, {
+                    category: typedArgs.category,
+                    key: typedArgs.key,
+                    value: typedArgs.value,
+                    confidence: typedArgs.confidence ?? 1.0,
+                    decay_rate: typedArgs.decay_rate ?? 0.01,
+                    code_file: typedArgs.code_file,
+                    code_line_start: typedArgs.code_line_start,
+                    code_line_end: typedArgs.code_line_end,
+                    tags: typedArgs.tags || [],
+                    merge: typedArgs.merge ?? false,
+                    source: 'explicit'
+                });
+                return { content: [{ type: 'text', text: `✅ Saved: ${typedArgs.key}\n${JSON.stringify(result, null, 2)}` }] };
+            }
+            case 'memory_get': {
+                const result = await apiRequest('GET', `/memory/${USER_ID}`);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'memory_search': {
+                const params = new URLSearchParams({ q: typedArgs.query });
+                if (typedArgs.category)
+                    params.append('category', typedArgs.category);
+                const result = await apiRequest('GET', `/memory/${USER_ID}/search?${params}`);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'memory_for_file': {
+                const file = encodeURIComponent(typedArgs.file);
+                const line = typedArgs.line ? `?line=${typedArgs.line}` : '';
+                const result = await apiRequest('GET', `/memory/${USER_ID}/code/${file}${line}`);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'memory_history': {
+                const result = await apiRequest('GET', `/memory/${USER_ID}/history/${typedArgs.key}`);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'memory_extract': {
+                const result = await apiRequest('POST', `/memory/${USER_ID}/extract`, {
+                    text: typedArgs.text
+                });
+                return { content: [{ type: 'text', text: `📝 Extracted:\n${JSON.stringify(result, null, 2)}` }] };
+            }
+            case 'memory_forget': {
+                await apiRequest('DELETE', `/memory/${USER_ID}/context/${typedArgs.key}`);
+                return { content: [{ type: 'text', text: `✅ Deleted: ${typedArgs.key}` }] };
+            }
+            // ═══════════════════════════════════════
+            // CONTEXT HANDLERS
+            // ═══════════════════════════════════════
+            case 'context_pack': {
+                const result = await apiRequest('POST', `/context/${USER_ID}/pack`, {
+                    max_tokens: typedArgs.max_tokens ?? 4000,
+                    current_context: typedArgs.current_context,
+                    include_memories: typedArgs.include_memories ?? true,
+                    include_history: typedArgs.include_history ?? true
+                });
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'context_relevant': {
+                const params = new URLSearchParams();
+                if (typedArgs.context)
+                    params.append('context', typedArgs.context);
+                if (typedArgs.limit)
+                    params.append('limit', String(typedArgs.limit));
+                const result = await apiRequest('GET', `/context/${USER_ID}/relevant?${params}`);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'context_thread_create': {
+                const result = await apiRequest('POST', `/context/${USER_ID}/thread`, {
+                    name: typedArgs.name,
+                    description: typedArgs.description,
+                    tags: typedArgs.tags
+                });
+                return { content: [{ type: 'text', text: `✅ Thread created: ${result.id}` }] };
+            }
+            case 'context_summary_save': {
+                const result = await apiRequest('POST', `/context/${USER_ID}/summary`, {
+                    summary: typedArgs.summary,
+                    key_points: typedArgs.key_points,
+                    decisions: typedArgs.decisions,
+                    action_items: typedArgs.action_items,
+                    thread_id: typedArgs.thread_id,
+                    priority: typedArgs.priority ?? 5,
+                    is_milestone: typedArgs.is_milestone ?? false
+                });
+                return { content: [{ type: 'text', text: `✅ Summary saved${typedArgs.is_milestone ? ' (MILESTONE)' : ''}` }] };
+            }
+            // ═══════════════════════════════════════
+            // SYNC HANDLERS
+            // ═══════════════════════════════════════
+            case 'sync_discover': {
+                const result = await apiRequest('GET', `/sync/discover/${encodeURIComponent(PROJECT_DIR)}`);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'sync_intent': {
+                // First discover/join workspace
+                const discovery = await apiRequest('GET', `/sync/discover/${encodeURIComponent(PROJECT_DIR)}`);
+                if (!discovery.found || !discovery.workspace) {
+                    return { content: [{ type: 'text', text: 'No workspace found. Create one to enable intent broadcasting.' }] };
+                }
+                const result = await apiRequest('POST', `/sync/workspace/${discovery.workspace.id}/intent`, {
+                    instance_id: `${USER_ID}_${sessionState.startTime.getTime()}`,
+                    intent_type: typedArgs.intent_type,
+                    target_file: typedArgs.target_file,
+                    target_lines: typedArgs.target_lines,
+                    description: typedArgs.description
+                });
+                if (result.conflict) {
+                    return { content: [{ type: 'text', text: `⚠️ CONFLICT:\n${JSON.stringify(result, null, 2)}` }] };
+                }
+                return { content: [{ type: 'text', text: `✅ Intent registered: ${typedArgs.intent_type} on ${typedArgs.target_file}` }] };
+            }
+            case 'sync_check_conflicts': {
+                const discovery = await apiRequest('GET', `/sync/discover/${encodeURIComponent(PROJECT_DIR)}`);
+                if (!discovery.found || !discovery.workspace) {
+                    return { content: [{ type: 'text', text: 'No workspace - no conflicts possible' }] };
+                }
+                const result = await apiRequest('GET', `/sync/workspace/${discovery.workspace.id}/intents?file=${encodeURIComponent(typedArgs.file)}`);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            // ═══════════════════════════════════════
+            // KNOWLEDGE HANDLERS
+            // ═══════════════════════════════════════
+            case 'knowledge_check': {
+                const domain = typedArgs.domain.toLowerCase();
+                const version = typedArgs.version || sessionState.packageVersions[domain];
+                const params = new URLSearchParams({ domain });
+                if (typedArgs.topic)
+                    params.append('topic', typedArgs.topic);
+                if (version)
+                    params.append('version', version);
+                const result = await apiRequest('GET', `/knowledge?${params}`);
+                if (!result || result.length === 0) {
+                    return { content: [{ type: 'text', text: `No knowledge for ${domain}${version ? ` v${version}` : ''}` }] };
+                }
+                return { content: [{ type: 'text', text: `📚 Knowledge for ${domain}${version ? ` v${version}` : ''}:\n${JSON.stringify(result, null, 2)}` }] };
+            }
+            case 'knowledge_deprecations': {
+                const domain = typedArgs.domain.toLowerCase();
+                const version = typedArgs.version || sessionState.packageVersions[domain];
+                const params = version ? `?version=${version}` : '';
+                const result = await apiRequest('GET', `/knowledge/deprecated/${domain}${params}`);
+                return { content: [{ type: 'text', text: `⚠️ Deprecations:\n${JSON.stringify(result, null, 2)}` }] };
+            }
+            case 'knowledge_scan_code': {
+                const result = await apiRequest('POST', `/knowledge/scan`, {
+                    code: typedArgs.code,
+                    file_path: typedArgs.file_path,
+                    package_json: { dependencies: sessionState.packageVersions },
+                    user_id: USER_ID
+                });
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'knowledge_learn_pattern': {
+                const result = await apiRequest('POST', `/knowledge/user/${USER_ID}/patterns`, {
+                    domain: typedArgs.domain,
+                    pattern_name: typedArgs.pattern_name,
+                    description: typedArgs.description,
+                    code_example: typedArgs.code_example
+                });
+                return { content: [{ type: 'text', text: `✅ Pattern learned: ${typedArgs.pattern_name}` }] };
+            }
+            case 'knowledge_my_patterns': {
+                const params = typedArgs.domain ? `?domain=${typedArgs.domain}` : '';
+                const result = await apiRequest('GET', `/knowledge/user/${USER_ID}/patterns${params}`);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            // ═══════════════════════════════════════
+            // ERROR HANDLERS
+            // ═══════════════════════════════════════
+            case 'error_capture': {
+                const error = {
+                    type: typedArgs.type,
+                    message: typedArgs.message,
+                    file: typedArgs.file,
+                    context: typedArgs.context,
+                    timestamp: new Date()
+                };
+                captureError(error);
+                if (typedArgs.ai_generated) {
+                    await apiRequest('POST', `/memory/${USER_ID}/context`, {
+                        category: 'behavior',
+                        key: `anti_pattern_${Date.now()}`,
+                        value: {
+                            type: 'error_pattern',
+                            errorType: typedArgs.type,
+                            context: typedArgs.context,
+                            message: typedArgs.message,
+                            file: typedArgs.file
+                        },
+                        source: 'auto',
+                        confidence: 0.9
+                    });
+                }
+                return { content: [{ type: 'text', text: `✅ Error captured for learning` }] };
+            }
+            case 'error_patterns': {
+                const behaviors = await apiRequest('GET', `/memory/${USER_ID}/context/behavior`);
+                const behaviorArray = Array.isArray(behaviors) ? behaviors : [];
+                const antiPatterns = behaviorArray.filter((b) => b.value && b.value.type === 'error_pattern');
+                return { content: [{ type: 'text', text: JSON.stringify({
+                                antiPatterns,
+                                recentSessionErrors: sessionState.recentErrors
+                            }, null, 2) }] };
+            }
+            // ═══════════════════════════════════════
+            // SESSION HANDLERS
+            // ═══════════════════════════════════════
+            case 'session_refresh': {
+                await initializeSession();
+                return { content: [{ type: 'text', text: '✅ Session context refreshed' }] };
+            }
+            case 'session_summary': {
+                return { content: [{ type: 'text', text: JSON.stringify({
+                                user: sessionState.userId,
+                                project: sessionState.codebaseDNA,
+                                git: sessionState.gitInfo,
+                                memory: {
+                                    preferences: sessionState.userMemory?.preferences.length || 0,
+                                    facts: sessionState.userMemory?.facts.length || 0,
+                                    behaviors: sessionState.userMemory?.behaviors.length || 0,
+                                    patterns: sessionState.userMemory?.patterns.length || 0
+                                },
+                                errors: sessionState.recentErrors.length,
+                                packageVersions: sessionState.packageVersions,
+                                sessionStart: sessionState.startTime
+                            }, null, 2) }] };
+            }
+            // ═══════════════════════════════════════
+            // DNA HANDLERS (Phase 3)
+            // ═══════════════════════════════════════
+            case 'dna_analyze': {
+                codebaseDNADeep = await analyzeCodebaseDNADeep();
+                if (codebaseDNADeep) {
+                    codebaseDNADeep.decisions = await loadDecisions();
+                }
+                return { content: [{ type: 'text', text: `🧬 Codebase DNA analyzed:\n${JSON.stringify(codebaseDNADeep, null, 2)}` }] };
+            }
+            case 'dna_conventions': {
+                if (!codebaseDNADeep) {
+                    codebaseDNADeep = await analyzeCodebaseDNADeep();
+                }
+                return { content: [{ type: 'text', text: JSON.stringify({
+                                conventions: codebaseDNADeep?.conventions || {},
+                                _note: 'Follow these conventions when writing code for this project'
+                            }, null, 2) }] };
+            }
+            case 'dna_patterns': {
+                if (!codebaseDNADeep) {
+                    codebaseDNADeep = await analyzeCodebaseDNADeep();
+                }
+                return { content: [{ type: 'text', text: JSON.stringify({
+                                patterns: codebaseDNADeep?.patterns || {},
+                                _note: 'These patterns are used throughout the codebase'
+                            }, null, 2) }] };
+            }
+            case 'dna_architecture': {
+                if (!codebaseDNADeep) {
+                    codebaseDNADeep = await analyzeCodebaseDNADeep();
+                }
+                return { content: [{ type: 'text', text: JSON.stringify({
+                                architecture: codebaseDNADeep?.architecture || {},
+                                criticalPaths: codebaseDNADeep?.criticalPaths || [],
+                                _note: 'Architecture style and important paths'
+                            }, null, 2) }] };
+            }
+            case 'dna_add_decision': {
+                const decision = {
+                    decision: typedArgs.decision,
+                    reason: typedArgs.reason,
+                    alternatives: typedArgs.alternatives,
+                    project: sessionState.codebaseDNA?.projectName,
+                    timestamp: new Date().toISOString()
+                };
+                await apiRequest('POST', `/memory/${USER_ID}/context`, {
+                    category: 'project',
+                    key: `decision_${Date.now()}`,
+                    value: decision,
+                    source: 'explicit',
+                    confidence: 1.0
+                });
+                // Update local cache
+                if (codebaseDNADeep) {
+                    codebaseDNADeep.decisions.push({
+                        decision: decision.decision,
+                        reason: decision.reason,
+                        date: new Date(),
+                        alternatives: decision.alternatives
+                    });
+                }
+                return { content: [{ type: 'text', text: `✅ Decision recorded: ${decision.decision}` }] };
+            }
+            case 'dna_decisions': {
+                const decisions = await loadDecisions();
+                return { content: [{ type: 'text', text: JSON.stringify({
+                                decisions,
+                                count: decisions.length,
+                                _note: 'Past decisions for this project - consider these when making new choices'
+                            }, null, 2) }] };
+            }
+            case 'dna_critical_paths': {
+                if (!codebaseDNADeep) {
+                    codebaseDNADeep = await analyzeCodebaseDNADeep();
+                }
+                // Also load any manually marked critical paths
+                const manualCritical = await apiRequest('GET', `/memory/${USER_ID}/context/project`).catch(() => []);
+                const manual = (Array.isArray(manualCritical) ? manualCritical : [])
+                    .filter((c) => c.key?.startsWith('critical_'))
+                    .map((c) => ({ path: c.value?.path, reason: c.value?.reason }));
+                const allCritical = [
+                    ...(codebaseDNADeep?.criticalPaths || []),
+                    ...manual
+                ];
+                return { content: [{ type: 'text', text: JSON.stringify({
+                                criticalPaths: allCritical,
+                                _note: 'Be careful when modifying these paths!'
+                            }, null, 2) }] };
+            }
+            case 'dna_mark_critical': {
+                await apiRequest('POST', `/memory/${USER_ID}/context`, {
+                    category: 'project',
+                    key: `critical_${Date.now()}`,
+                    value: {
+                        path: typedArgs.path,
+                        reason: typedArgs.reason,
+                        markedAt: new Date().toISOString()
+                    },
+                    source: 'explicit',
+                    confidence: 1.0
+                });
+                return { content: [{ type: 'text', text: `⚠️ Marked as critical: ${typedArgs.path}\nReason: ${typedArgs.reason}` }] };
+            }
+            default:
+                return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        return { content: [{ type: 'text', text: `Error: ${message}` }], isError: true };
+    }
+});
+// ============================================
+// START SERVER
+// ============================================
+async function main() {
+    await initializeSession();
+    // Start background watchers (Phase 2)
+    startWatcher();
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    console.error('✨ Persista MCP v3.1 running with background watchers');
+}
+// Cleanup on exit
+process.on('SIGINT', () => {
+    stopWatcher();
+    process.exit(0);
+});
+process.on('SIGTERM', () => {
+    stopWatcher();
+    process.exit(0);
+});
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    stopWatcher();
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map