dedsession 2.1.0 → 2.3.0

package/dist/index.js

@@ -8,7 +8,7 @@ import * as path from "path";
 // КОНФИГУРАЦИЯ
 // ============================================================================
 const CONFIG = {
-    VERSION: "2.1.0",
+    VERSION: "2.3.0",
 };
 const state = {
     loadedContext: null,
@@ -435,6 +435,13 @@ function listContexts() {
         return [];
     }
 }
+// Находит путь к контексту по номеру (для context_smart_focus)
+function findContextByNumber(number) {
+    const contexts = listContexts();
+    const numInt = parseInt(number, 10);
+    const found = contexts.find(c => c.number === numInt);
+    return found?.path || null;
+}
 // ============================================================================
 // АДАПТИВНЫЕ ФУНКЦИИ v1.4.3
 // ============================================================================
@@ -1153,6 +1160,157 @@ function saveSolutions(solutions) {
     const filePath = path.join(getMemoryPath(), "solutions.json");
     fs.writeFileSync(filePath, JSON.stringify(solutions, null, 2), "utf-8");
 }
+/**
+ * Извлекает решения из текста контекста (legacy и новый формат)
+ * Ищет паттерны: "Проблема:", "Решение:", "fix", "исправил", "причина" и т.д.
+ */
+function extractSolutionsFromText(text, contextId) {
+    const solutions = [];
+    if (!text || text.length < 50)
+        return solutions;
+    // Паттерн 1: Структурированный формат "Проблема: X / Решение: Y"
+    const structuredPattern = /(?:проблема|problem|issue|баг|bug|ошибка)[:：]\s*([^\n]+)[\s\S]*?(?:решение|solution|fix|исправление)[:：]\s*([^\n]+(?:\n(?!(?:проблема|problem|issue|баг|bug|ошибка))[^\n]+)*)/gi;
+    let match;
+    while ((match = structuredPattern.exec(text)) !== null) {
+        const problem = match[1].trim();
+        const solutionText = match[2].trim();
+        if (problem.length > 10 && solutionText.length > 10) {
+            solutions.push({
+                problem,
+                solution: solutionText.split("\n").map(s => s.trim()).filter(s => s.length > 0),
+                tags: extractSolutionTags(problem + " " + solutionText),
+            });
+        }
+    }
+    // Паттерн 2: Нумерованный список "1. Проблема: X"
+    const numberedPattern = /\d+\.\s*(?:проблема|problem)[:：]?\s*([^\n]+)[\s\S]*?(?:решение|solution|fix)[:：]?\s*([^\n]+(?:\n(?!\d+\.)[^\n]+)*)/gi;
+    while ((match = numberedPattern.exec(text)) !== null) {
+        const problem = match[1].trim();
+        const solutionText = match[2].trim();
+        if (problem.length > 10 && solutionText.length > 10) {
+            // Проверяем что не дубликат
+            if (!solutions.some(s => s.problem.toLowerCase() === problem.toLowerCase())) {
+                solutions.push({
+                    problem,
+                    solution: solutionText.split("\n").map(s => s.trim()).filter(s => s.length > 0),
+                    tags: extractSolutionTags(problem + " " + solutionText),
+                });
+            }
+        }
+    }
+    // Паттерн 3: "исправил X" / "fix: X" / "fixed X"
+    const fixPattern = /(?:исправил|fixed|fix[:：])\s+([^.!?\n]{15,100})/gi;
+    while ((match = fixPattern.exec(text)) !== null) {
+        const fixText = match[1].trim();
+        // Извлекаем контекст вокруг fix
+        const startIdx = Math.max(0, match.index - 200);
+        const context = text.slice(startIdx, match.index);
+        const problemHint = context.match(/(?:проблема|ошибка|баг|issue|bug)[:：]?\s*([^\n]{10,80})/i);
+        if (!solutions.some(s => s.solution.some(sol => sol.includes(fixText.slice(0, 30))))) {
+            solutions.push({
+                problem: problemHint ? problemHint[1].trim() : `Исправление в контексте #${contextId}`,
+                solution: [fixText],
+                tags: extractSolutionTags(fixText),
+            });
+        }
+    }
+    // Паттерн 4: "причина: X" с последующим решением
+    const causePattern = /(?:причина|cause|root cause)[:：]\s*([^\n]+)[\s\S]{0,300}?(?:решение|solution|fix)[:：]\s*([^\n]+)/gi;
+    while ((match = causePattern.exec(text)) !== null) {
+        const cause = match[1].trim();
+        const fix = match[2].trim();
+        if (cause.length > 10 && fix.length > 10) {
+            if (!solutions.some(s => s.problem.includes(cause.slice(0, 30)))) {
+                solutions.push({
+                    problem: cause,
+                    solution: [fix],
+                    tags: extractSolutionTags(cause + " " + fix),
+                });
+            }
+        }
+    }
+    return solutions;
+}
+/**
+ * Извлекает теги из текста решения
+ */
+function extractSolutionTags(text) {
+    const tags = [];
+    const lowerText = text.toLowerCase();
+    const tagPatterns = {
+        git: ["git", "commit", "push", "merge", "rebase", "branch"],
+        npm: ["npm", "package.json", "node_modules", "yarn", "pnpm"],
+        typescript: ["typescript", "ts", "type", "interface", "generic"],
+        react: ["react", "component", "hook", "useState", "useEffect"],
+        api: ["api", "endpoint", "fetch", "axios", "request", "response"],
+        cache: ["cache", "кеш", "npx", "очистка"],
+        build: ["build", "сборка", "compile", "webpack", "vite"],
+        ios: ["ios", "swift", "xcode", "cocoapods"],
+        android: ["android", "kotlin", "gradle"],
+        database: ["database", "db", "sql", "mongo", "postgres"],
+        auth: ["auth", "token", "jwt", "login", "password"],
+        performance: ["performance", "оптимизация", "память", "memory"],
+    };
+    for (const [tag, patterns] of Object.entries(tagPatterns)) {
+        if (patterns.some(p => lowerText.includes(p))) {
+            tags.push(tag);
+        }
+    }
+    return tags.slice(0, 5); // Максимум 5 тегов
+}
+/**
+ * Добавляет извлечённые решения в базу
+ */
+function addSolutionsToIndex(extracted, contextId) {
+    if (extracted.length === 0)
+        return 0;
+    const solutionsIndex = loadSolutions();
+    let added = 0;
+    for (const ext of extracted) {
+        // Проверяем на дубликаты по проблеме
+        const isDuplicate = solutionsIndex.solutions.some(s => s.problem.toLowerCase().includes(ext.problem.toLowerCase().slice(0, 30)) ||
+            ext.problem.toLowerCase().includes(s.problem.toLowerCase().slice(0, 30)));
+        if (!isDuplicate) {
+            const newId = `sol_${contextId}_${solutionsIndex.solutions.length + 1}`;
+            solutionsIndex.solutions.push({
+                id: newId,
+                problem: ext.problem,
+                solution: ext.solution,
+                sourceContexts: [contextId],
+                codeExample: undefined,
+            });
+            added++;
+        }
+        else {
+            // Добавляем контекст к существующему решению
+            const existing = solutionsIndex.solutions.find(s => s.problem.toLowerCase().includes(ext.problem.toLowerCase().slice(0, 30)));
+            if (existing && !existing.sourceContexts.includes(contextId)) {
+                existing.sourceContexts.push(contextId);
+            }
+        }
+    }
+    if (added > 0) {
+        saveSolutions(solutionsIndex);
+    }
+    return added;
+}
+// ============================================================================
+// ПРАВИЛА v2.2: ЛОКАЛЬНЫЕ + ГЛОБАЛЬНЫЕ
+// ============================================================================
+/**
+ * Путь к глобальной конфигурации ~/.dedsession/
+ */
+function getGlobalConfigPath() {
+    const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+    const globalPath = path.join(home, ".dedsession");
+    if (!fs.existsSync(globalPath)) {
+        fs.mkdirSync(globalPath, { recursive: true });
+    }
+    return globalPath;
+}
+/**
+ * Загрузить ЛОКАЛЬНЫЕ правила (из MD_HISTORY/memory/)
+ */
 function loadRules() {
     const filePath = path.join(getMemoryPath(), "rules.json");
     try {
@@ -1163,23 +1321,65 @@ function loadRules() {
     catch { /* ignore */ }
     return { rules: [] };
 }
+/**
+ * Сохранить ЛОКАЛЬНЫЕ правила
+ */
 function saveRules(rules) {
     ensureMemoryStructure();
     const filePath = path.join(getMemoryPath(), "rules.json");
     fs.writeFileSync(filePath, JSON.stringify(rules, null, 2), "utf-8");
 }
+/**
+ * Загрузить ГЛОБАЛЬНЫЕ правила (из ~/.dedsession/)
+ */
+function loadGlobalRules() {
+    const filePath = path.join(getGlobalConfigPath(), "global-rules.json");
+    try {
+        if (fs.existsSync(filePath)) {
+            return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        }
+    }
+    catch { /* ignore */ }
+    return { rules: [] };
+}
+/**
+ * Сохранить ГЛОБАЛЬНЫЕ правила
+ */
+function saveGlobalRules(rules) {
+    const filePath = path.join(getGlobalConfigPath(), "global-rules.json");
+    fs.writeFileSync(filePath, JSON.stringify(rules, null, 2), "utf-8");
+}
+/**
+ * Форматирует блок правил (глобальные + локальные)
+ */
 function formatRulesBlock() {
-    const rulesIndex = loadRules();
-    if (rulesIndex.rules.length === 0)
+    const globalRules = loadGlobalRules();
+    const localRules = loadRules();
+    if (globalRules.rules.length === 0 && localRules.rules.length === 0)
         return "";
-    let output = "# \u{1F534} \u041f\u0420\u0418\u041e\u0420\u0418\u0422\u0415\u0422\u041d\u042b\u0415 \u041f\u0420\u0410\u0412\u0418\u041b\u0410\n\n";
-    output += "> \u042d\u0442\u0438 \u043f\u0440\u0430\u0432\u0438\u043b\u0430 Claude \u041e\u0411\u042f\u0417\u0410\u041d \u0441\u043e\u0431\u043b\u044e\u0434\u0430\u0442\u044c \u0432\u043e \u0412\u0421\u0415\u0425 \u043a\u043e\u043d\u0442\u0435\u043a\u0441\u0442\u0430\u0445!\n\n";
-    for (const rule of rulesIndex.rules) {
-        output += `**${rule.id}.** ${rule.rule}`;
-        if (rule.context)
-            output += ` _(${rule.context})_`;
+    let output = "# 🔴 ПРИОРИТЕТНЫЕ ПРАВИЛА\n\n";
+    output += "> Эти правила Claude ОБЯЗАН соблюдать во ВСЕХ контекстах!\n\n";
+    // Глобальные правила
+    if (globalRules.rules.length > 0) {
+        output += "**🌍 Глобальные (все проекты):**\n";
+        for (const rule of globalRules.rules) {
+            output += `- **G${rule.id}.** ${rule.rule}`;
+            if (rule.context)
+                output += ` _(${rule.context})_`;
+            output += "\n";
+        }
         output += "\n";
     }
+    // Локальные правила
+    if (localRules.rules.length > 0) {
+        output += "**📁 Локальные (этот проект):**\n";
+        for (const rule of localRules.rules) {
+            output += `- **L${rule.id}.** ${rule.rule}`;
+            if (rule.context)
+                output += ` _(${rule.context})_`;
+            output += "\n";
+        }
+    }
     output += "\n---\n\n";
     return output;
 }
@@ -1194,6 +1394,14 @@ const PROJECT_PATTERNS = {
     dedsession: ["dedsession", "mcp", "context", "memory", "session"],
     web: ["web", "react", "vue", "angular", "nextjs", "frontend", "html", "css"],
 };
+// Паттерны для определения людей (для context_smart)
+const PERSON_PATTERNS = {
+    muradbek: ["muradbek", "мурадбек", "мурад", "ibraghimovmuradbek"],
+    vlad: ["vlad", "vlad0sminer", "влад", "stweekmine"],
+    makhach: ["makhach", "махач", "makhach1717"],
+    akhmad: ["akhmad", "ахмад", "blck6rd"],
+    eldad: ["eldad", "эльдар"],
+};
 function detectProject(content, folderName) {
     const lowerContent = (content + " " + folderName).toLowerCase();
     let bestMatch = null;
@@ -1210,6 +1418,92 @@ function detectProject(content, folderName) {
     }
     return bestMatch?.project || null;
 }
+// Определяет человека по содержимому (для context_smart)
+function detectPerson(content) {
+    const lower = content.toLowerCase();
+    for (const [person, patterns] of Object.entries(PERSON_PATTERNS)) {
+        for (const pattern of patterns) {
+            if (lower.includes(pattern)) {
+                return person;
+            }
+        }
+    }
+    return null;
+}
+// Парсит HISTORY.md и возвращает последние N записей (для context_smart)
+function parseHistoryEntries(historyContent, limit = 25) {
+    const entries = [];
+    // Формат записи в HISTORY.md:
+    // ---
+    // #001 | 2026-01-07 | task-name | ✅
+    // **Сводка:** текст сводки...
+    // **Файлы:** список файлов
+    const entryRegex = /#(\d{3})\s*\|\s*(\d{4}-\d{2}-\d{2})\s*\|\s*([^\|]+)\s*\|\s*(✅|⏳|❌)/g;
+    const sections = historyContent.split(/^---$/m);
+    for (const section of sections) {
+        const match = entryRegex.exec(section);
+        if (match) {
+            const [, number, date, name, status] = match;
+            const cleanName = name.trim();
+            // Извлекаем сводку (всё после заголовка записи)
+            const summaryStart = section.indexOf(status) + status.length;
+            const summary = section.slice(summaryStart).trim();
+            // Определяем человека по названию и сводке
+            const person = detectPerson(cleanName + " " + summary);
+            // Извлекаем ключевые слова из названия
+            const keywords = cleanName.split(/[-_\s]+/).filter(w => w.length > 2);
+            entries.push({
+                number,
+                date,
+                name: cleanName,
+                status,
+                summary,
+                person,
+                keywords,
+            });
+        }
+        // Сбрасываем regex для следующей итерации
+        entryRegex.lastIndex = 0;
+    }
+    // Сортируем по номеру (новые первые) и берём limit
+    return entries
+        .sort((a, b) => parseInt(b.number) - parseInt(a.number))
+        .slice(0, limit);
+}
+// Вычисляет релевантность контекста к запросу (для context_smart_focus)
+function scoreContextRelevance(entry, queryPerson, queryKeywords, memoryIndex) {
+    let score = 0;
+    // +10 за совпадение человека
+    if (queryPerson && entry.person === queryPerson) {
+        score += 10;
+    }
+    // +5 за совпадение ключевого слова в названии
+    for (const kw of queryKeywords) {
+        if (entry.name.toLowerCase().includes(kw)) {
+            score += 5;
+        }
+    }
+    // +2 за совпадение ключевого слова в сводке
+    for (const kw of queryKeywords) {
+        if (entry.summary.toLowerCase().includes(kw)) {
+            score += 2;
+        }
+    }
+    // Бонус из Memory v2.0: +3 за совпадение project
+    const contextMeta = memoryIndex.contexts[entry.number];
+    if (contextMeta) {
+        for (const kw of queryKeywords) {
+            if (contextMeta.project && contextMeta.project.toLowerCase().includes(kw)) {
+                score += 3;
+            }
+            // +1 за совпадение в keywords из Memory
+            if (contextMeta.keywords.some(k => k.includes(kw) || kw.includes(k))) {
+                score += 1;
+            }
+        }
+    }
+    return score;
+}
 function extractKeywords(content) {
     const keywords = new Set();
     // Извлекаем технологии и инструменты
@@ -1287,6 +1581,7 @@ function migrateToMemorySystem() {
         migrated: 0,
         projects: [],
         epics: [],
+        solutions: 0,
         errors: [],
     };
     try {
@@ -1311,7 +1606,20 @@ function migrateToMemorySystem() {
                 if (fs.existsSync(changesPath)) {
                     changes = fs.readFileSync(changesPath, "utf-8");
                 }
+                // v2.2: Читаем problems-solutions если есть
+                const problemsPath = path.join(ctx.path, "08-problems-solutions.md");
+                let problemsSolutions = "";
+                if (fs.existsSync(problemsPath)) {
+                    problemsSolutions = fs.readFileSync(problemsPath, "utf-8");
+                }
+                // v2.2: Читаем session-log для legacy решений
+                const sessionLogPath = path.join(ctx.path, "05-session-log.md");
+                let sessionLog = "";
+                if (fs.existsSync(sessionLogPath)) {
+                    sessionLog = fs.readFileSync(sessionLogPath, "utf-8");
+                }
                 const fullContent = readme + "\n" + changes;
+                const solutionsContent = problemsSolutions + "\n" + readme + "\n" + changes + "\n" + sessionLog;
                 // Определяем проект
                 const project = detectProject(fullContent, ctx.name);
                 // Извлекаем ключевые слова
@@ -1381,6 +1689,12 @@ function migrateToMemorySystem() {
                         keywordsIndex.keywords[keyword].push(contextMeta.id);
                     }
                 }
+                // v2.2: Извлекаем решения из контекста
+                const extractedSolutions = extractSolutionsFromText(solutionsContent, contextMeta.id);
+                if (extractedSolutions.length > 0) {
+                    const added = addSolutionsToIndex(extractedSolutions, contextMeta.id);
+                    result.solutions += added;
+                }
                 result.migrated++;
             }
             catch (err) {
@@ -1774,7 +2088,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         },
         {
             name: "context_save_detailed",
-            description: "📚 ПОДРОБНОЕ сохранение контекста (10 файлов). ОБЯЗАТЕЛЬНО вызывай когда пользователь говорит: 'сохрани контекст подробно', 'подробно сохрани', 'детальное сохранение', 'сохрани всё подробно'. Создаёт 10 файлов с максимально качественной информацией. Перед вызовом Claude ОБЯЗАН прочитать гайд по заполнению!",
+            description: "📚 МАКСИМАЛЬНО ПОДРОБНОЕ сохранение контекста (15 файлов). ОБЯЗАТЕЛЬНО вызывай когда пользователь говорит: 'сохрани контекст подробно', 'подробно сохрани', 'детальное сохранение', 'сохрани всё подробно', '15 файлов'. Создаёт 15 файлов с максимально качественной информацией. Перед вызовом Claude ОБЯЗАН прочитать гайд по заполнению!",
             inputSchema: {
                 type: "object",
                 properties: {
@@ -1817,12 +2131,36 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                     },
                     problems_solutions: {
                         type: "string",
-                        description: "Для КАЖДОЙ проблемы: симптомы, root cause, решение, как предотвратить. Минимум 2 проблемы!",
+                        description: "Для КАЖДОЙ проблемы: симптомы, root cause, решение, как предотвратить. Формат: 'Проблема: X / Решение: Y'. Минимум 2 проблемы!",
                     },
                     architecture: {
                         type: "string",
                         description: "Структура модулей, потоки данных, интеграции. Можно ASCII-диаграммы.",
                     },
+                    testing: {
+                        type: "string",
+                        description: "Что тестировали, как тестировали, результаты тестов, покрытие.",
+                    },
+                    api_docs: {
+                        type: "string",
+                        description: "API документация: эндпоинты, параметры, примеры запросов/ответов.",
+                    },
+                    migration: {
+                        type: "string",
+                        description: "Миграции данных, breaking changes, инструкции по обновлению.",
+                    },
+                    performance: {
+                        type: "string",
+                        description: "Оптимизации производительности, метрики до/после, узкие места.",
+                    },
+                    security: {
+                        type: "string",
+                        description: "Анализ безопасности, уязвимости, исправления, рекомендации.",
+                    },
+                    full_context: {
+                        type: "string",
+                        description: "Полный контекст сессии: всё что не вошло в другие файлы, дополнительные заметки.",
+                    },
                     history_summary: {
                         type: "string",
                         description: "⭐ ОБЯЗАТЕЛЬНО: Качественная сводка для HISTORY.md (2-4 предложения). Формат: **Сводка:** суть задачи, что сделано, результат. **Файлы:** список изменённых файлов.",
@@ -2025,7 +2363,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         },
         {
             name: "rules",
-            description: "🔴 Управление ПРИОРИТЕТНЫМИ ПРАВИЛАМИ. ОБЯЗАТЕЛЬНО вызывай когда пользователь говорит: 'добавь правило', 'правила', 'покажи правила', 'удали правило', 'новое правило'. Правила показываются ПЕРВЫМИ при каждой загрузке контекста и Claude ОБЯЗАН их соблюдать.",
+            description: "🔴 Управление ПРИОРИТЕТНЫМИ ПРАВИЛАМИ. ОБЯЗАТЕЛЬНО вызывай когда пользователь говорит: 'добавь правило', 'правила', 'покажи правила', 'удали правило', 'новое правило', 'глобальное правило'. Правила показываются ПЕРВЫМИ при каждой загрузке контекста и Claude ОБЯЗАН их соблюдать.",
             inputSchema: {
                 type: "object",
                 properties: {
@@ -2034,6 +2372,11 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                         enum: ["add", "list", "remove"],
                         description: "Действие: add (добавить), list (показать все), remove (удалить по ID)",
                     },
+                    scope: {
+                        type: "string",
+                        enum: ["local", "global"],
+                        description: "Область: local (только этот проект, по умолчанию), global (все проекты, ~/.dedsession/)",
+                    },
                     rule: {
                         type: "string",
                         description: "Текст правила (для action=add)",
@@ -2050,6 +2393,29 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ["action"],
             },
         },
+        // ========== ТЕСТОВЫЕ КОМАНДЫ SMART CONTEXT ==========
+        {
+            name: "context_smart",
+            description: "🧪 ТЕСТОВАЯ команда. Умная загрузка 25 контекстов с группировкой по людям/темам. ОБЯЗАТЕЛЬНО вызывай когда пользователь говорит: 'умный контекст', 'smart context', 'контекст по людям', 'тестовый контекст'. После обзора опиши задачу для точной подгрузки.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+            },
+        },
+        {
+            name: "context_smart_focus",
+            description: "🧪 ТЕСТОВАЯ команда. Подгружает 2-4 релевантных контекста ПОЛНОСТЬЮ по описанию задачи. Вызывай ПОСЛЕ context_smart или когда пользователь описывает задачу после умного контекста.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    task: {
+                        type: "string",
+                        description: "Описание задачи в свободном формате: 'доска мурадбека', 'влад скрипты', 'рефакторинг как делали'",
+                    },
+                },
+                required: ["task"],
+            },
+        },
     ],
 }));
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
@@ -2203,6 +2569,18 @@ ${args?.changes?.split("\n").map(l => l.trim() ? `- ${l}` : "").join("\n") || "-
                 args?.session_log,
             ].filter(Boolean).join("\n");
             const memoryInfo = addContextToMemory(contextNumber, result.name, taskName, status, fullContent, new Date().toISOString().split("T")[0]);
+            // v2.2: Извлекаем решения при сохранении
+            let solutionsAdded = 0;
+            if (args?.problems_solutions) {
+                const solutionsContent = [
+                    args?.problems_solutions,
+                    args?.changes,
+                    args?.session_log,
+                ].filter(Boolean).join("\n");
+                const contextId = String(contextNumber).padStart(3, "0");
+                const extracted = extractSolutionsFromText(solutionsContent, contextId);
+                solutionsAdded = addSolutionsToIndex(extracted, contextId);
+            }
             let output = `✅ **Контекст сохранён**\n\n`;
             output += `📁 **Папка:** \`${result.name}\`\n`;
             output += `📄 **Файлов:** ${result.filesCount}\n`;
@@ -2214,6 +2592,9 @@ ${args?.changes?.split("\n").map(l => l.trim() ? `- ${l}` : "").join("\n") || "-
                 output += `\n🧠 **Memory v2.0:**\n`;
                 output += `- Проект: **${memoryInfo.project}**\n`;
                 output += `- Теги: ${memoryInfo.keywords.slice(0, 5).join(", ") || "-"}\n`;
+                if (solutionsAdded > 0) {
+                    output += `- 💡 Решений добавлено: **${solutionsAdded}**\n`;
+                }
             }
             if (state.loadedContext && state.loadedContext !== result.name) {
                 output += `\n🔗 **Parent:** ${state.loadedContext}\n`;
@@ -2260,7 +2641,7 @@ ${args?.changes?.split("\n").map(l => l.trim() ? `- ${l}` : "").join("\n") || "-
                 blocked: "❌ Заблокировано",
             };
             const status = statusMap[args?.status || "completed"] || "✅ Завершено";
-            // Всегда 10 файлов для детального сохранения
+            // Всегда 15 файлов для максимально детального сохранения
             const detailedFiles = [
                 "README.md",
                 "01-task-overview.md",
@@ -2272,13 +2653,19 @@ ${args?.changes?.split("\n").map(l => l.trim() ? `- ${l}` : "").join("\n") || "-
                 "07-decisions.md",
                 "08-problems-solutions.md",
                 "09-architecture.md",
+                "10-testing.md",
+                "11-api-docs.md",
+                "12-migration.md",
+                "13-performance.md",
+                "14-security.md",
+                "15-full-context.md",
             ];
             // Формируем README
             const readme = `# ${taskName}
 
 **Дата:** ${new Date().toISOString().split("T")[0]}
 **Статус:** ${status}
-**Масштаб:** detailed (10 файлов)
+**Масштаб:** detailed (15 файлов)
 
 ## Краткое описание
 
@@ -2304,6 +2691,13 @@ ${state.loadedContext ? `**Parent:** ${state.loadedContext}` : "Нет parent к
                 decisions: args?.decisions || "Решения не документированы",
                 problemsSolutions: args?.problems_solutions || "Проблемы не описаны",
                 architecture: args?.architecture || "Архитектура не описана",
+                // v2.2: Новые поля для 15 файлов
+                testing: args?.testing || "Тестирование не описано",
+                apiDocs: args?.api_docs || "API не документировано",
+                migration: args?.migration || "Миграции отсутствуют",
+                performance: args?.performance || "Оптимизации не проводились",
+                security: args?.security || "Безопасность не анализировалась",
+                fullContext: args?.full_context || "Полный контекст сессии не записан",
                 // v1.4.10: Готовая сводка для HISTORY.md
                 historySummary: args?.history_summary,
             }, undefined, detailedFiles);
@@ -2324,9 +2718,19 @@ ${state.loadedContext ? `**Parent:** ${state.loadedContext}` : "Нет parent к
                 args?.architecture,
             ].filter(Boolean).join("\n");
             const memoryInfo = addContextToMemory(contextNumber, result.name, taskName, status, fullContent, new Date().toISOString().split("T")[0]);
+            // v2.2: Извлекаем решения при сохранении (detailed всегда имеет problems_solutions)
+            let solutionsAdded = 0;
+            const solutionsContent = [
+                args?.problems_solutions,
+                args?.changes,
+                args?.session_log,
+            ].filter(Boolean).join("\n");
+            const contextId = String(contextNumber).padStart(3, "0");
+            const extracted = extractSolutionsFromText(solutionsContent, contextId);
+            solutionsAdded = addSolutionsToIndex(extracted, contextId);
             let output = `✅ **Контекст сохранён ПОДРОБНО**\n\n`;
             output += `📁 **Папка:** \`${result.name}\`\n`;
-            output += `📄 **Файлов:** 10\n`;
+            output += `📄 **Файлов:** 15\n`;
             output += `🎯 **Масштаб:** detailed (максимальная детализация)\n`;
             output += `📍 **Путь:** \`${result.path}\`\n`;
             // v2.0: Показываем Memory info
@@ -2334,6 +2738,9 @@ ${state.loadedContext ? `**Parent:** ${state.loadedContext}` : "Нет parent к
                 output += `\n🧠 **Memory v2.0:**\n`;
                 output += `- Проект: **${memoryInfo.project}**\n`;
                 output += `- Теги: ${memoryInfo.keywords.slice(0, 5).join(", ") || "-"}\n`;
+                if (solutionsAdded > 0) {
+                    output += `- 💡 Решений добавлено: **${solutionsAdded}**\n`;
+                }
             }
             if (state.loadedContext && state.loadedContext !== result.name) {
                 output += `\n🔗 **Parent:** ${state.loadedContext}\n`;
@@ -3158,7 +3565,8 @@ MD_HISTORY/
                 output += `📊 Результаты:\n`;
                 output += `- Проиндексировано контекстов: ${result.migrated}\n`;
                 output += `- Обнаружено проектов: ${result.projects.length} (${result.projects.join(", ") || "-"})\n`;
-                output += `- Эпиков: ${result.epics.length}\n\n`;
+                output += `- Эпиков: ${result.epics.length}\n`;
+                output += `- 💡 Извлечено решений: ${result.solutions}\n\n`;
                 const stats = getMemoryStats();
                 output += `## 🌡️ Распределение по температуре\n\n`;
                 output += `- 🔥 Hot: ${stats.temperatures.hot}\n`;
@@ -3186,17 +3594,23 @@ MD_HISTORY/
         // ==================== RULES ====================
         case "rules": {
             const action = args.action || "list";
+            const scope = args.scope || "local";
             const ruleText = args.rule;
             const ruleId = args.id;
             const ruleContext = args.context;
-            const rulesIndex = loadRules();
+            const isGlobal = scope === "global";
+            const rulesIndex = isGlobal ? loadGlobalRules() : loadRules();
+            const scopeLabel = isGlobal ? "🌍 Глобальное" : "📁 Локальное";
+            const scopePath = isGlobal ? "~/.dedsession/" : "MD_HISTORY/memory/";
             switch (action) {
                 case "add": {
                     if (!ruleText) {
                         return {
                             content: [{
                                     type: "text",
-                                    text: `⚠️ Укажи текст правила.\n\n**Пример:** \`rules add "При работе с Trello пиши 'сгенерировано Claude Code'"\``
+                                    text: `⚠️ Укажи текст правила.\n\n**Примеры:**\n` +
+                                        `- Локальное: \`rules add "Правило для этого проекта"\`\n` +
+                                        `- Глобальное: \`rules add "Правило для ВСЕХ проектов" scope:global\``
                                 }]
                         };
                     }
@@ -3210,12 +3624,18 @@ MD_HISTORY/
                         context: ruleContext,
                     };
                     rulesIndex.rules.push(newRule);
-                    saveRules(rulesIndex);
-                    let output = `# ✅ Правило добавлено\n\n`;
-                    output += `**ID:** ${newRule.id}\n`;
+                    if (isGlobal) {
+                        saveGlobalRules(rulesIndex);
+                    }
+                    else {
+                        saveRules(rulesIndex);
+                    }
+                    let output = `# ✅ ${scopeLabel} правило добавлено\n\n`;
+                    output += `**ID:** ${isGlobal ? "G" : "L"}${newRule.id}\n`;
                     output += `**Правило:** ${newRule.rule}\n`;
                     if (newRule.context)
                         output += `**Контекст:** ${newRule.context}\n`;
+                    output += `**Хранится:** \`${scopePath}\`\n`;
                     output += `\nТеперь это правило будет показываться при каждой загрузке контекста.\n`;
                     output += `\n---\n\n`;
                     output += formatRulesBlock();
@@ -3226,7 +3646,9 @@ MD_HISTORY/
                         return {
                             content: [{
                                     type: "text",
-                                    text: `⚠️ Укажи ID правила для удаления.\n\n**Пример:** \`rules remove 1\``
+                                    text: `⚠️ Укажи ID правила для удаления.\n\n**Примеры:**\n` +
+                                        `- Локальное: \`rules remove 1\`\n` +
+                                        `- Глобальное: \`rules remove 1 scope:global\``
                                 }]
                         };
                     }
@@ -3235,36 +3657,221 @@ MD_HISTORY/
                         return {
                             content: [{
                                     type: "text",
-                                    text: `⚠️ Правило с ID ${ruleId} не найдено.`
+                                    text: `⚠️ ${scopeLabel} правило с ID ${ruleId} не найдено.`
                                 }]
                         };
                     }
                     const removed = rulesIndex.rules.splice(ruleIndex, 1)[0];
-                    saveRules(rulesIndex);
-                    let output = `# ✅ Правило удалено\n\n`;
-                    output += `**ID:** ${removed.id}\n`;
-                    output += `**Было:** ${removed.rule}\n`;
-                    output += `\n---\n\n`;
-                    if (rulesIndex.rules.length > 0) {
-                        output += formatRulesBlock();
+                    if (isGlobal) {
+                        saveGlobalRules(rulesIndex);
                     }
                     else {
+                        saveRules(rulesIndex);
+                    }
+                    let output = `# ✅ ${scopeLabel} правило удалено\n\n`;
+                    output += `**ID:** ${isGlobal ? "G" : "L"}${removed.id}\n`;
+                    output += `**Было:** ${removed.rule}\n`;
+                    output += `\n---\n\n`;
+                    output += formatRulesBlock();
+                    if (loadGlobalRules().rules.length === 0 && loadRules().rules.length === 0) {
                         output += `_Нет активных правил._\n`;
                     }
                     return { content: [{ type: "text", text: output }] };
                 }
                 case "list":
                 default: {
-                    if (rulesIndex.rules.length === 0) {
+                    const globalRules = loadGlobalRules();
+                    const localRules = loadRules();
+                    if (globalRules.rules.length === 0 && localRules.rules.length === 0) {
                         let output = `# 🔴 Приоритетные правила\n\n`;
                         output += `_Нет активных правил._\n\n`;
                         output += `**Добавить правило:**\n`;
-                        output += `\`rules add "При работе с Trello пиши 'сгенерировано Claude Code'" context:trello\`\n`;
+                        output += `- Локальное (этот проект): \`rules add "Текст правила"\`\n`;
+                        output += `- Глобальное (все проекты): \`rules add "Текст правила" scope:global\`\n`;
                         return { content: [{ type: "text", text: output }] };
                     }
-                    return { content: [{ type: "text", text: formatRulesBlock() }] };
+                    let output = formatRulesBlock();
+                    output += `\n**Управление:**\n`;
+                    output += `- Добавить локальное: \`rules add "..."\`\n`;
+                    output += `- Добавить глобальное: \`rules add "..." scope:global\`\n`;
+                    output += `- Удалить: \`rules remove ID [scope:global]\`\n`;
+                    return { content: [{ type: "text", text: output }] };
+                }
+            }
+        }
+        // ========== ТЕСТОВЫЕ HANDLERS SMART CONTEXT ==========
+        case "context_smart": {
+            const history = readHistory();
+            if (!history) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `❌ **HISTORY.md не найден**\n\nСначала создайте контексты или запустите \`context_migrate\`.`,
+                        }],
+                };
+            }
+            const entries = parseHistoryEntries(history, 25);
+            const memoryIndex = loadMemoryIndex();
+            // Группируем по людям
+            const byPerson = {};
+            for (const entry of entries) {
+                const person = entry.person || "other";
+                if (!byPerson[person])
+                    byPerson[person] = [];
+                byPerson[person].push(entry);
+            }
+            // Группируем по проектам из Memory v2.0
+            const byProject = {};
+            for (const entry of entries) {
+                const meta = memoryIndex.contexts[entry.number];
+                const project = meta?.project || "unknown";
+                if (!byProject[project])
+                    byProject[project] = [];
+                byProject[project].push(entry);
+            }
+            // Формируем компактный вывод
+            let output = `# 🧠 Smart Context — Обзор ${entries.length} контекстов\n\n`;
+            // По людям
+            output += `## 👥 По людям:\n`;
+            for (const [person, list] of Object.entries(byPerson)) {
+                if (person !== "other") {
+                    const ids = list.slice(0, 8).map(e => `#${e.number}`).join(", ");
+                    const more = list.length > 8 ? ` (+${list.length - 8})` : "";
+                    output += `- **${person}** (${list.length}): ${ids}${more}\n`;
+                }
+            }
+            if (byPerson["other"]) {
+                output += `- _другие_ (${byPerson["other"].length})\n`;
+            }
+            // По проектам (если есть Memory v2.0 данные)
+            const projectsWithData = Object.entries(byProject).filter(([p]) => p !== "unknown");
+            if (projectsWithData.length > 0) {
+                output += `\n## 📁 По проектам:\n`;
+                for (const [project, list] of projectsWithData) {
+                    output += `- **${project}** (${list.length})\n`;
+                }
+            }
+            // Последние 10 с краткими сводками
+            output += `\n## 📋 Последние 10:\n`;
+            output += `| # | Название | Человек | Сводка |\n|---|----------|---------|--------|\n`;
+            for (const entry of entries.slice(0, 10)) {
+                const shortSummary = entry.summary.slice(0, 50).replace(/\n/g, " ") + "...";
+                output += `| ${entry.number} | ${entry.name} | ${entry.person || "-"} | ${shortSummary} |\n`;
+            }
+            // Генерируем динамические примеры на основе реальных данных
+            output += `\n---\n`;
+            output += `💡 **Опиши задачу** в свободном формате, и я подгружу релевантные контексты:\n`;
+            const examples = [];
+            // Пример с человеком (берём первого найденного)
+            const persons = Object.keys(byPerson).filter(p => p !== "other");
+            if (persons.length > 0) {
+                const person = persons[0];
+                const personEntry = byPerson[person][0];
+                // Извлекаем ключевое слово из названия
+                const keyword = personEntry.name.split("-").find(w => w.length > 3 && !w.includes(person)) || "";
+                examples.push(`"${keyword ? keyword + " " : ""}${person}"`);
+            }
+            // Пример с проектом (если есть)
+            if (projectsWithData.length > 0) {
+                const [project, list] = projectsWithData[0];
+                const entry = list[0];
+                const keyword = entry.name.split("-").find(w => w.length > 3) || "";
+                examples.push(`"${keyword} ${project}"`);
+            }
+            // Пример из последнего контекста
+            if (entries.length > 0) {
+                const lastEntry = entries[0];
+                const words = lastEntry.name.split("-").filter(w => w.length > 3).slice(0, 2);
+                if (words.length > 0) {
+                    examples.push(`"${words.join(" ")}"`);
+                }
+            }
+            // Выводим примеры (максимум 3)
+            for (const example of examples.slice(0, 3)) {
+                output += `- ${example}\n`;
+            }
+            output += `\nClaude автоматически найдёт и загрузит 2-4 релевантных контекста.`;
+            return { content: [{ type: "text", text: output }] };
+        }
+        case "context_smart_focus": {
+            const task = args.task;
+            if (!task) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `❌ **Укажи описание задачи**\n\nПример: "доска мурадбека", "влад скрипты", "рефакторинг"`,
+                        }],
+                };
+            }
+            const history = readHistory();
+            if (!history) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `❌ **HISTORY.md не найден**`,
+                        }],
+                };
+            }
+            // Парсим запрос
+            const queryPerson = detectPerson(task);
+            const queryKeywords = task.toLowerCase()
+                .split(/\s+/)
+                .filter(w => w.length > 2 && !["над", "для", "как", "что", "это", "мы", "работаем"].includes(w));
+            // Загружаем данные
+            const entries = parseHistoryEntries(history, 25);
+            const memoryIndex = loadMemoryIndex();
+            // Скорим контексты
+            const scored = entries.map(entry => ({
+                entry,
+                score: scoreContextRelevance(entry, queryPerson, queryKeywords, memoryIndex),
+            }));
+            // Топ 2-4 по score (минимум score > 0)
+            const top = scored
+                .filter(s => s.score > 0)
+                .sort((a, b) => b.score - a.score)
+                .slice(0, 4);
+            if (top.length === 0) {
+                let output = `❌ **Не найдено релевантных контекстов для:** "${task}"\n\n`;
+                output += `**Искали:**\n`;
+                if (queryPerson)
+                    output += `- Человек: ${queryPerson}\n`;
+                output += `- Ключевые слова: ${queryKeywords.join(", ")}\n\n`;
+                output += `**Попробуй:**\n`;
+                output += `- Уточнить имя человека (muradbek, vlad, makhach, akhmad)\n`;
+                output += `- Использовать ключевые слова из названий контекстов\n`;
+                return { content: [{ type: "text", text: output }] };
+            }
+            // Загружаем контексты полностью
+            let output = `# 🎯 Фокус: "${task}"\n\n`;
+            output += `**Найдено:** ${top.length} релевантных контекстов\n`;
+            if (queryPerson)
+                output += `**Человек:** ${queryPerson}\n`;
+            output += `**Ключевые слова:** ${queryKeywords.join(", ")}\n\n`;
+            output += `---\n\n`;
+            for (const { entry, score } of top) {
+                output += `## #${entry.number}: ${entry.name} (score: ${score})\n\n`;
+                // Загружаем полный контекст
+                const contextPath = findContextByNumber(entry.number);
+                if (contextPath) {
+                    // README.md
+                    const readmePath = path.join(contextPath, "README.md");
+                    if (fs.existsSync(readmePath)) {
+                        const readme = fs.readFileSync(readmePath, "utf-8");
+                        output += readme + "\n\n";
+                    }
+                    // 03-changes.md (если есть)
+                    const changesPath = path.join(contextPath, "03-changes.md");
+                    if (fs.existsSync(changesPath)) {
+                        const changes = fs.readFileSync(changesPath, "utf-8");
+                        output += `### 🔧 Изменения:\n${changes}\n\n`;
+                    }
+                    // Обновляем accessCount в Memory v2.0
+                    updateContextAccess(entry.number);
                 }
+                output += `---\n\n`;
             }
+            output += `💡 **Контексты загружены.** Теперь можешь работать над задачей!`;
+            return { content: [{ type: "text", text: output }] };
         }
         default:
             return { content: [{ type: "text", text: `❌ Неизвестный tool: ${name}` }] };