dedsession 3.0.2 → 4.7.0

package/dist/index.js

@@ -4,17 +4,22 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import * as fs from "fs";
 import * as path from "path";
+import { execFile } from "child_process";
 // ============================================================================
 // КОНФИГУРАЦИЯ
 // ============================================================================
 const CONFIG = {
-    VERSION: "3.0.2",
+    VERSION: "4.7.0",
+    // v3.1: числовая версия схемы памяти. Растёт при изменении структуры memory/*.json.
+    // context_quick сравнивает её с index.schemaVersion и тихо до-мигрирует один раз на репо.
+    SCHEMA_VERSION: 4,
 };
 const state = {
     loadedContext: null,
     loadedContextPath: null,
     sessionStartTime: new Date(),
     isInitialized: false,
+    attachedProjects: [],
 };
 // ============================================================================
 // ВСТРОЕННЫЕ ИНСТРУКЦИИ (fallback)
@@ -331,6 +336,27 @@ function getNextContextNumber() {
     const maxNumber = Math.max(...contexts.map(c => c.number));
     return maxNumber + 1;
 }
+// v3.1 LEGACY-FIX: стабильный уникальный ID контекста.
+// Формат A (NNN_дата_slug) → "001". Формат B (дата_slug без номера, ctx.number===0)
+// → имя папки (уникально на диске), иначе все 69 legacy-контекстов схлопывались в ключ "000".
+function contextIdOf(ctx) {
+    return ctx.number > 0 ? String(ctx.number).padStart(3, "0") : ctx.name;
+}
+// v3.1.1: нормализует значение "**Parent:** X" к тому же id, что contextIdOf.
+// X может быть полным именем папки (NNN_дата_slug → "NNN"; дата_slug формата B → имя),
+// либо голым числом. Раньше regex (\d+) ловил "2024" из даты legacy-родителя — связь рвалась.
+function normalizeParentRef(raw) {
+    const v = (raw || "").trim();
+    if (!v)
+        return null;
+    const parsed = parseContextName(v);
+    if (parsed)
+        return contextIdOf({ number: parsed.number, name: v });
+    const numMatch = v.match(/^#?(\d{1,4})\b/);
+    if (numMatch)
+        return numMatch[1].padStart(3, "0");
+    return v;
+}
 // v1.4.12: Проверка наличия git репозитория
 function isGitConfigured() {
     try {
@@ -348,11 +374,28 @@ function isGitConfigured() {
         return { configured: false };
     }
 }
-function listContexts() {
-    const mdHistory = getMdHistoryPath();
+// v3.1: кэш listContexts с инвалидацией по mtime директории MD_HISTORY.
+// Устраняет двойной/тройной полный скан диска на один save
+// (getNextContextNumber + generateSessionMd + getStatistics).
+let _listContextsCache = null;
+function listContexts(mdHistoryOverride) {
+    // v3.6: опциональный путь — для обхода нескольких репо (context_backfill_all)
+    const mdHistory = mdHistoryOverride || getMdHistoryPath();
     if (!fs.existsSync(mdHistory)) {
         return [];
     }
+    // Кэш-хит: тот же путь и неизменившийся mtime каталога → отдаём готовое.
+    // mtime родителя меняется при добавлении/удалении контекста-папки (главный кейс инвалидации).
+    let dirMtime = 0;
+    try {
+        dirMtime = fs.statSync(mdHistory).mtimeMs;
+        if (_listContextsCache && _listContextsCache.path === mdHistory && _listContextsCache.mtimeMs === dirMtime) {
+            return _listContextsCache.data;
+        }
+    }
+    catch {
+        // если statSync упал — просто не кэшируем
+    }
     try {
         const dirs = fs.readdirSync(mdHistory, { withFileTypes: true })
             .filter(d => d.isDirectory())
@@ -427,8 +470,16 @@ function listContexts() {
             // Новые сверху: сначала по номеру (убывание), потом по дате (убывание)
             if (a.number !== b.number)
                 return b.number - a.number;
-            return b.date.localeCompare(a.date);
+            if (a.date !== b.date)
+                return b.date.localeCompare(a.date);
+            // v3.1.1: детерминированный tie-break по имени папки — иначе при равных номере И дате
+            // (дубли формата A) порядок зависел от ФС, и ключ-коллизия "095" скакал между машинами.
+            return a.name.localeCompare(b.name);
         });
+        // сохраняем в кэш (mtime уже посчитан выше; если был 0 — кэш просто инвалидируется в след. раз)
+        if (dirMtime) {
+            _listContextsCache = { path: mdHistory, mtimeMs: dirMtime, data: dirs };
+        }
         return dirs;
     }
     catch {
@@ -436,39 +487,12 @@ function listContexts() {
     }
 }
 // Находит путь к контексту по номеру (для 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
 // ============================================================================
 /**
  * Оценивает размер контекста в байтах
  */
-function estimateContextSize(contextPath) {
-    try {
-        if (!fs.existsSync(contextPath))
-            return 0;
-        const files = fs.readdirSync(contextPath).filter(f => f.endsWith(".md"));
-        let totalSize = 0;
-        for (const file of files) {
-            try {
-                const stat = fs.statSync(path.join(contextPath, file));
-                totalSize += stat.size;
-            }
-            catch {
-                // Игнорируем ошибки
-            }
-        }
-        return totalSize;
-    }
-    catch {
-        return 0;
-    }
-}
 /**
  * Определяет сколько контекстов загружать для context_quick
  * Возвращает { count: число контекстов, mode: режим загрузки, reason: причина }
@@ -541,9 +565,9 @@ function extractSummaryFromReadme(readme, changesContent) {
     if (descMatch) {
         summary = descMatch[1].trim();
     }
-    // 2. Если нет — ищем "## Выполнено" → первые 2 пункта
+    // 2. Если нет — ищем "## Выполнено" ИЛИ "## Что сделано" (v3.1: README пишет "## Что сделано") → первые 2 пункта
     if (!summary) {
-        const doneMatch = readme.match(/## Выполнено[^\n]*\n((?:[-*✅] [^\n]+\n?){1,2})/);
+        const doneMatch = readme.match(/## (?:Выполнено|Что сделано)[^\n]*\n+((?:[-*✅] [^\n]+\n?){1,2})/);
         if (doneMatch) {
             summary = doneMatch[1]
                 .replace(/[-*✅] /g, "")
@@ -553,10 +577,10 @@ function extractSummaryFromReadme(readme, changesContent) {
                 .join("; ");
         }
     }
-    // 3. Если нет — берём первый параграф после заголовка
+    // 3. Если нет — первый параграф после заголовка, НО не строки-метаданные (**Дата:**/**Статус:** и т.п.)
     if (!summary) {
         const firstPara = readme.match(/^#[^\n]+\n\n([^\n#]+)/m);
-        if (firstPara) {
+        if (firstPara && !/^\s*\*\*[^*]+:\*\*/.test(firstPara[1])) {
             summary = firstPara[1].trim();
         }
     }
@@ -647,53 +671,6 @@ function readHistory() {
  * Миграция всех существующих контекстов в HISTORY.md
  * Проходит по всем контекстам в хронологическом порядке (старые первыми)
  */
-function migrateAllToHistory(force = false) {
-    const historyPath = path.join(getMdHistoryPath(), "HISTORY.md");
-    // Если файл существует и нет force — не перезаписываем
-    if (fs.existsSync(historyPath) && !force) {
-        return { migrated: 0, errors: ["HISTORY.md уже существует. Используй force: true"] };
-    }
-    // Удаляем старый файл если force
-    if (fs.existsSync(historyPath) && force) {
-        fs.unlinkSync(historyPath);
-    }
-    const contexts = listContexts();
-    const errors = [];
-    let migrated = 0;
-    // Сортируем по номеру (старые первыми для правильного хронологического порядка)
-    contexts.sort((a, b) => a.number - b.number);
-    for (const ctx of contexts) {
-        try {
-            // Читаем README.md
-            const readmePath = path.join(ctx.path, "README.md");
-            let readme = "";
-            if (fs.existsSync(readmePath)) {
-                readme = fs.readFileSync(readmePath, "utf-8");
-            }
-            // Читаем changes если есть
-            const changesPath = path.join(ctx.path, "03-changes.md");
-            let changes = "";
-            if (fs.existsSync(changesPath)) {
-                changes = fs.readFileSync(changesPath, "utf-8");
-            }
-            // Извлекаем сводку
-            const summary = extractSummaryFromReadme(readme, changes);
-            // Добавляем в историю
-            appendToHistory({
-                number: ctx.number,
-                date: ctx.date,
-                name: ctx.title,
-                status: ctx.status,
-                summary
-            });
-            migrated++;
-        }
-        catch (err) {
-            errors.push(`${ctx.name}: ${String(err)}`);
-        }
-    }
-    return { migrated, errors };
-}
 /**
  * Определяет масштаб сохранения на основе данных
  * Возвращает scale и список файлов для создания
@@ -812,6 +789,9 @@ function loadContext(contextName) {
 function saveContext(taskName, content, parentContext, filesToCreate // Опционально — какие файлы создавать
 ) {
     const date = new Date().toISOString().split("T")[0];
+    // v3.1.2 FIX H: фиксируем РОДИТЕЛЯ до того, как saveContext перезапишет state.loadedContext
+    // на только что созданный контекст (иначе addContextToMemory получал self-parent).
+    const effectiveParent = parentContext || state.loadedContext || null;
     const number = getNextContextNumber();
     const paddedNumber = String(number).padStart(3, "0");
     // Санитизация имени: только латиница, цифры и дефисы
@@ -831,7 +811,8 @@ function saveContext(taskName, content, parentContext, filesToCreate // Опци
         .replace(/[^a-z0-9-]/g, "-")
         .replace(/-+/g, "-")
         .replace(/^-|-$/g, "")
-        .slice(0, 50) || "unnamed-context";
+        .slice(0, 50)
+        .replace(/-+$/, "") || "unnamed-context"; // v3.1.2: срез до 50 может оставить хвостовой дефис — убираем
     const contextName = `${paddedNumber}_${date}_${safeName}`;
     const contextPath = path.join(getMdHistoryPath(), contextName);
     try {
@@ -849,8 +830,9 @@ function saveContext(taskName, content, parentContext, filesToCreate // Опци
             "README.md": readmeContent,
             "01-task-overview.md": content.taskOverview ? `# 📋 Обзор задачи\n\n${content.taskOverview}` : undefined,
             "02-analysis.md": content.analysis ? `# 🔍 Анализ\n\n${content.analysis}` : undefined,
-            "03-changes.md": `# 🔧 Изменения\n\n${content.changes}`,
-            "04-summary.md": `# 📝 Итоги\n\n${content.summary}`,
+            // v3.1.1: пишем только при непустом контенте — иначе создавался файл с голым заголовком (мусор на каждом save)
+            "03-changes.md": content.changes && content.changes.trim() ? `# 🔧 Изменения\n\n${content.changes}` : undefined,
+            "04-summary.md": content.summary && content.summary.trim() ? `# 📝 Итоги\n\n${content.summary}` : undefined,
             "05-session-log.md": content.sessionLog ? `# 💬 Лог сессии\n\n**Дата:** ${new Date().toISOString()}\n\n${content.sessionLog}` : undefined,
             "06-code-snippets.md": content.codeSnippets ? `# 💻 Фрагменты кода\n\n${content.codeSnippets}` : undefined,
             "07-decisions.md": content.decisions ? `# 🎯 Принятые решения\n\n${content.decisions}` : undefined,
@@ -917,7 +899,12 @@ function saveContext(taskName, content, parentContext, filesToCreate // Опци
             // Не прерываем сохранение если HISTORY.md не удалось обновить
             console.error("[dedsession] Ошибка обновления HISTORY.md:", err);
         }
-        return { success: true, path: contextPath, name: contextName, filesCount };
+        // v3.1: публикуем выжимку репо в глобальный digest (publish-on-save)
+        try {
+            publishToGlobalDigest();
+        }
+        catch { /* не критично */ }
+        return { success: true, path: contextPath, name: contextName, filesCount, parentRef: effectiveParent };
     }
     catch (err) {
         return { success: false, path: "", name: "", filesCount: 0, error: String(err) };
@@ -1016,22 +1003,6 @@ function generateSessionMd() {
 // ============================================================================
 // ЧТЕНИЕ АРХИТЕКТУРЫ ПРОЕКТА
 // ============================================================================
-function readProjectArchitecture() {
-    const mdDir = path.join(getWorkingDir(), "MD");
-    const results = [];
-    if (!fs.existsSync(mdDir)) {
-        return results;
-    }
-    const files = fs.readdirSync(mdDir).filter(f => f.endsWith(".md") && (f.includes("ARCHITECTURE") ||
-        f.includes("PROTOCOL") ||
-        f.includes("API") ||
-        f.includes("REFERENCE")));
-    for (const file of files.slice(0, 3)) {
-        const content = fs.readFileSync(path.join(mdDir, file), "utf-8");
-        results.push(`### ${file}\n\n${content.slice(0, 1000)}${content.length > 1000 ? "\n...(обрезано)" : ""}`);
-    }
-    return results;
-}
 function getStatistics() {
     const contexts = listContexts();
     const now = new Date();
@@ -1071,7 +1042,7 @@ function ensureMemoryStructure() {
     ensureDir(memoryPath);
     // Инициализация пустых файлов если не существуют
     const files = [
-        { name: "index.json", default: { version: CONFIG.VERSION, lastMigration: "", contexts: {} } },
+        { name: "index.json", default: { version: CONFIG.VERSION, lastMigration: "", schemaVersion: CONFIG.SCHEMA_VERSION, contexts: {} } },
         { name: "projects.json", default: { projects: {} } },
         { name: "epics.json", default: { epics: {} } },
         { name: "keywords.json", default: { keywords: {} } },
@@ -1094,8 +1065,13 @@ function loadMemoryIndex() {
             return JSON.parse(fs.readFileSync(filePath, "utf-8"));
         }
     }
-    catch { /* ignore */ }
-    return { version: CONFIG.VERSION, lastMigration: "", contexts: {} };
+    catch {
+        // v3.1.1: файл ЕСТЬ, но битый JSON → schemaVersion 0, чтобы гейт ЗАПУСТИЛ миграцию
+        // и переиндексировал диск (иначе битый индекс «замораживался» как свежий и контексты терялись).
+        return { version: CONFIG.VERSION, lastMigration: "", schemaVersion: 0, contexts: {} };
+    }
+    // файла НЕТ → свежий репо → актуальная схема (не мигрировать зря на пустом, F1)
+    return { version: CONFIG.VERSION, lastMigration: "", schemaVersion: CONFIG.SCHEMA_VERSION, contexts: {} };
 }
 function saveMemoryIndex(index) {
     ensureMemoryStructure();
@@ -1244,7 +1220,7 @@ function renderOverviewMd(digest) {
     md += `## Что это за проект\n`;
     md += `${digest.currentState.description || "_Описание будет добавлено после digest_refresh_"}\n\n`;
     md += `## Текущее состояние\n`;
-    md += `- **Контекстов:** ${digest.statistics.totalContexts} (✅ ${digest.statistics.completed} | ⏳ ${digest.statistics.inProgress})\n`;
+    md += `- **Контекстов:** ${digest.statistics.totalContexts}\n`; // v4.4.0 блок J: без статусов
     md += `- **Период:** ${digest.statistics.firstDate} — ${digest.statistics.lastDate}\n`;
     if (digest.currentState.techStack.length > 0) {
         md += `- **Стек:** ${digest.currentState.techStack.join(", ")}\n`;
@@ -1263,22 +1239,9 @@ function renderOverviewMd(digest) {
             md += `${phase.description}\n\n`;
         }
     }
-    // В работе сейчас
-    const inProgress = digest.recentTasks.filter(t => t.status === "⏳" || t.status === "⏳ В процессе" || t.status === "in_progress");
-    if (inProgress.length > 0) {
-        md += `## В работе сейчас\n`;
-        for (const task of inProgress.slice(0, 5)) {
-            md += `- **#${task.contextId}: ${task.name}** — ${task.summary}\n`;
-        }
-        md += "\n";
-    }
-    if (digest.knownIssues.length > 0) {
-        md += `## Известные проблемы\n`;
-        for (const issue of digest.knownIssues) {
-            md += `- ${issue}\n`;
-        }
-        md += "\n";
-    }
+    // v4.4.0 блок J: секции «В работе сейчас» и «Известные проблемы» убраны —
+    // строились по статусам (in_progress), которые работали криво («давно пофиксили, а висит»).
+    // По контекстам и так видно, над чем работа (см. Timeline / последние задачи).
     return md;
 }
 function renderTimelineMd(digest) {
@@ -1287,19 +1250,19 @@ function renderTimelineMd(digest) {
         md += "_Нет задач_\n";
         return md;
     }
-    // Таблица всех задач
-    md += `| # | Дата | Задача | Статус | Суть |\n`;
-    md += `|---|------|--------|--------|------|\n`;
+    // Таблица всех задач (v4.4.0 блок J: без колонки «Статус»)
+    md += `| # | Дата | Задача | Суть |\n`;
+    md += `|---|------|--------|------|\n`;
     for (const task of digest.recentTasks) {
         const summary = task.summary || "";
         const shortSummary = summary.length > 60 ? summary.slice(0, 57) + "..." : summary;
-        md += `| ${task.contextId} | ${task.date} | ${task.name} | ${task.status} | ${shortSummary} |\n`;
+        md += `| ${task.contextId} | ${task.date} | ${task.name} | ${shortSummary} |\n`;
     }
     md += "\n";
     // Детали последних 10
     md += `## Детали последних ${Math.min(10, digest.recentTasks.length)} задач\n\n`;
     for (const task of digest.recentTasks.slice(0, 10)) {
-        md += `### #${task.contextId}: ${task.name} (${task.date}) ${task.status}\n`;
+        md += `### #${task.contextId}: ${task.name} (${task.date})\n`;
         md += `Суть: ${task.summary || ""}\n`;
         if (task.keyChanges && task.keyChanges.length > 0) {
             md += `Изменения:\n`;
@@ -1359,25 +1322,104 @@ function renderSolutionsMd(digest) {
 // ============================================================================
 // PROJECT DIGEST v3.0 — detectProjectFromWorkDir + update
 // ============================================================================
+// v3.1.1: читает имя проекта из git remote origin (стабильно при переименовании папки).
+function readGitOriginName(repoDir) {
+    try {
+        const cfg = path.join(repoDir, ".git", "config");
+        // .git может быть файлом (worktree/submodule) — тогда config нет, вернём null → fallback на basename
+        if (!fs.existsSync(cfg) || !fs.statSync(cfg).isFile())
+            return null;
+        const txt = fs.readFileSync(cfg, "utf-8");
+        // v3.1.1 FIX: берём url ИМЕННО из секции [remote "origin"], а не первый попавшийся
+        // (иначе [submodule]/[remote "upstream"] выше origin давали чужое имя проекта).
+        const originSection = txt.match(/\[remote "origin"\]([\s\S]*?)(?=\n\[|\s*$)/);
+        const scope = originSection ? originSection[1] : txt;
+        const m = scope.match(/url\s*=\s*(.+)/);
+        if (!m)
+            return null;
+        let url = m[1].trim().replace(/\.git$/, "");
+        // basename из URL (ssh git@host:user/repo, https://host/user/repo, локальный путь, windows \)
+        const base = url.split(/[/:\\]/).filter(Boolean).pop();
+        return base || null;
+    }
+    catch {
+        return null;
+    }
+}
+// v3.5.1: полный git origin URL (для привязки «где репо, кто работает» в командной стате)
+function readGitRemoteUrl(repoDir) {
+    try {
+        const cfg = path.join(repoDir, ".git", "config");
+        if (!fs.existsSync(cfg) || !fs.statSync(cfg).isFile())
+            return null;
+        const txt = fs.readFileSync(cfg, "utf-8");
+        const originSection = txt.match(/\[remote "origin"\]([\s\S]*?)(?=\n\[|\s*$)/);
+        const scope = originSection ? originSection[1] : "";
+        const m = scope.match(/url\s*=\s*(.+)/);
+        return m ? m[1].trim() : null;
+    }
+    catch {
+        return null;
+    }
+}
+// v3.5.1: git user.name из .git/config репо или глобального ~/.gitconfig (кто коммитит)
+function readGitUser(repoDir) {
+    try {
+        const candidates = [path.join(repoDir, ".git", "config"), path.join(process.env.HOME || "", ".gitconfig")];
+        for (const cfg of candidates) {
+            if (!fs.existsSync(cfg) || !fs.statSync(cfg).isFile())
+                continue;
+            const txt = fs.readFileSync(cfg, "utf-8");
+            const userSection = txt.match(/\[user\]([\s\S]*?)(?=\n\[|\s*$)/);
+            const scope = userSection ? userSection[1] : "";
+            const m = scope.match(/name\s*=\s*(.+)/);
+            if (m)
+                return m[1].trim();
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+// v3.5.3: реальный автор контекста — по git log на ДАТУ контекста (а не текущий git config,
+// который на одной машине всегда один и тот же → все контексты ошибочно под одним ником).
+// Берём автора последнего коммита НЕ позже конца дня контекста. Кэш по (repo|date).
+// v3.6.2: АСИНХРОННО (execFile) — git log не блокирует event loop, вызовы идут конкурентно.
+const _gitAuthorCache = new Map();
+function readGitAuthorForDate(repoDir, date) {
+    if (!date || !/^\d{4}-\d{2}-\d{2}$/.test(date))
+        return Promise.resolve(null);
+    const key = repoDir + "|" + date;
+    if (_gitAuthorCache.has(key))
+        return Promise.resolve(_gitAuthorCache.get(key));
+    return new Promise((resolve) => {
+        execFile("git", ["-C", repoDir, "log", "--until=" + date + " 23:59:59", "--format=%an", "-n", "1"], { encoding: "utf-8", timeout: 4000 }, (err, stdout) => {
+            const author = (!err && stdout) ? (stdout.trim() || null) : null;
+            _gitAuthorCache.set(key, author);
+            resolve(author);
+        });
+    });
+}
 function detectProjectFromWorkDir() {
     try {
         const workDir = getWorkingDir();
-        const dirName = path.basename(workDir).toLowerCase();
-        // Проверяем PROJECT_PATTERNS
-        for (const [project, patterns] of Object.entries(PROJECT_PATTERNS)) {
-            for (const pattern of patterns) {
-                if (dirName.includes(pattern)) {
-                    return project;
-                }
-            }
-        }
-        // Возвращаем имя директории КАК ЕСТЬ
+        // v3.1.1 FIX коллизии: project = git-origin basename ИЛИ имя папки репо КАК ЕСТЬ.
+        // НЕ паттерн-матч PROJECT_PATTERNS — он схлопывал dedvpn-app-ios/dedai-app-ios в один "ios"
+        // → секции проектов затирали друг друга в global digest. Имя папки уникально, его и берём.
+        const origin = readGitOriginName(workDir);
+        if (origin)
+            return origin;
         return path.basename(workDir);
     }
     catch {
         return null;
     }
 }
+// v3.6: project для ПРОИЗВОЛЬНОГО репо (для context_backfill_all)
+// v3.6: найти все dedsession-проекты (папки с MD_HISTORY) от корня root до глубины depth.
+// v3.6.1: РЕКУРСИВНО заходит и в подпапки найденного проекта (вложенные/под-проекты тоже),
+// не останавливаясь на верхнем уровне. Пропускаем мусорные/скрытые директории.
 function extractKeyChangesFromText(changes) {
     if (!changes)
         return [];
@@ -1662,9 +1704,13 @@ function addSolutionsToIndex(extracted, contextId) {
 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 });
+    try {
+        if (!fs.existsSync(globalPath)) {
+            fs.mkdirSync(globalPath, { recursive: true });
+        }
+        fs.chmodSync(globalPath, 0o700); // v3.1.1: приватность (там токены/правила/digest)
     }
+    catch { /* права не критичны для работы */ }
     return globalPath;
 }
 /**
@@ -1708,21 +1754,686 @@ function saveGlobalRules(rules) {
     const filePath = path.join(getGlobalConfigPath(), "global-rules.json");
     fs.writeFileSync(filePath, JSON.stringify(rules, null, 2), "utf-8");
 }
+// ============================================================================
+// ГЛОБАЛЬНАЯ ПАМЯТЬ v3.1 — реестр проектов + глобальный digest
+// ~/.dedsession/global-digest.json — ЕДИНЫЙ файл: у каждого проекта своя секция
+// (по git-origin), поэтому объединение происходит само и без коллизий.
+// Это "digest из digest'ов": агрегирует выжимки локальных digest, а НЕ 15000 контекстов,
+// поэтому остаётся компактным независимо от объёма истории.
+// ============================================================================
+const GLOBAL_DIGEST_SCHEMA = 1;
+function getGlobalDigestPath() {
+    return path.join(getGlobalConfigPath(), "global-digest.json");
+}
+function loadGlobalDigest() {
+    const filePath = getGlobalDigestPath();
+    try {
+        if (fs.existsSync(filePath)) {
+            const raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+            // self-heal схемы (как loadDigest)
+            raw.schemaVersion = raw.schemaVersion || GLOBAL_DIGEST_SCHEMA;
+            raw.updated = raw.updated || "";
+            raw.projects = raw.projects || {};
+            return raw;
+        }
+    }
+    catch { /* ignore */ }
+    return { schemaVersion: GLOBAL_DIGEST_SCHEMA, updated: "", projects: {} };
+}
+function saveGlobalDigest(gd) {
+    try {
+        gd.updated = new Date().toISOString();
+        // атомарная запись через tmp+rename (+ pid в имени tmp, чтобы параллельные процессы не делили один tmp)
+        const filePath = getGlobalDigestPath();
+        const tmp = `${filePath}.tmp.${process.pid}`;
+        fs.writeFileSync(tmp, JSON.stringify(gd, null, 2), "utf-8");
+        fs.renameSync(tmp, filePath);
+        try {
+            fs.chmodSync(filePath, 0o600);
+        }
+        catch { /* */ } // v3.1.1: приватность файла
+    }
+    catch { /* глобальный digest не критичен для работы репо */ }
+}
+// v3.1.1: синхронный сон без busy-loop (Atomics.wait) — для файлового лока в CLI-процессе.
+function sleepSyncMs(ms) {
+    try {
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+    }
+    catch { /* fallback: no-op */ }
+}
+// v3.1.1: best-effort межпроцессный лок через эксклюзивное создание .lock-файла.
+// Защищает read-modify-write глобального digest от гонки двух MCP-процессов в разных репо.
+function withGlobalDigestLock(fn) {
+    const lockPath = getGlobalDigestPath() + ".lock";
+    let fd = -1;
+    for (let i = 0; i < 50; i++) {
+        try {
+            fd = fs.openSync(lockPath, "wx");
+            break;
+        }
+        catch {
+            // v3.1.1: НЕ сносим живой чужой лок. Сносим только ПРОТУХШИЙ (>15с = владелец явно умер),
+            // затем повторяем openSync на следующей итерации (атомарный wx → выиграет ровно один).
+            try {
+                const age = Date.now() - fs.statSync(lockPath).mtimeMs;
+                if (age > 15000) {
+                    fs.unlinkSync(lockPath);
+                    continue;
+                }
+            }
+            catch {
+                continue;
+            } // лок исчез между stat и сейчас — сразу повторим openSync
+            sleepSyncMs(20);
+        }
+    }
+    // если за ~1с лок так и не взят (постоянная контенция, не протухание) — пишем best-effort без него
+    try {
+        return fn();
+    }
+    finally {
+        if (fd >= 0) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch { /* */ }
+            try {
+                fs.unlinkSync(lockPath);
+            }
+            catch { /* */ }
+        }
+    }
+}
+// Фильтр против мусора A13: оставляем только то, что похоже на реальный путь/файл кода
+function isRealFilePath(s) {
+    if (!s || s.length > 120)
+        return false;
+    if (/^[\d.\s]+$/.test(s))
+        return false; // числа/версии (26.9px, 0.15)
+    if (/[{};:#]/.test(s) && !s.includes("/"))
+        return false; // CSS-селекторы
+    // v3.1.1: отсекаем абсолютные системные пути (инфраструктура) из публикуемого списка
+    if (/^\/(root|home|etc|var|usr|opt)\b/.test(s))
+        return false;
+    return s.includes("/") || /\.(ts|js|tsx|jsx|py|swift|kt|kts|go|php|rb|rs|java|c|cpp|h|html|css|scss|json|yaml|yml|sh|sql|vue|md|toml|gradle|xml)$/i.test(s);
+}
+// v3.1.1: вычищает секреты/инфраструктуру из текста ПЕРЕД публикацией в глобальный digest.
+// Без него /root/-пути, IP, ключи, пароли утекали бы в ~/.dedsession (и потом в облако DedPanel).
+function scrubSecrets(s) {
+    if (!s)
+        return s;
+    // v3.1.1: значение секрета — только секрето-подобное (≥8 симв, без пробела), а не любое соседнее слово,
+    // чтобы "token: refresh logic" не превращалось в "token=[REDACTED] logic".
+    const secretVal = "([^\\s'\"]{8,})";
+    return s
+        // срезаем ТОЛЬКО реальные протёкшие tool-call теги (A4) — без англо-слов summary/analysis/security,
+        // которые ломали бы markdown <details><summary> и осмысленный текст.
+        .replace(/<\/?(?:invoke|parameter|function_calls|antml:[a-z_]+)[^>]*>/gi, "")
+        .replace(/-----BEGIN[\s\S]*?-----END[^-]*-----/g, "[REDACTED_KEY]")
+        // v3.2.1: пароль внутри connection-URI (redis://user:pass@host, postgres://, mongodb://)
+        .replace(/\b([a-z][a-z0-9+.-]*:\/\/[^\s:@/]+):[^\s:@/]+@/gi, "$1:[REDACTED]@")
+        .replace(new RegExp(`\\b(password|passwd|pwd|secret|token|api[_-]?key|private[_-]?key|totp[_-]?secret|access[_-]?key)\\b\\s*[:=]\\s*${secretVal}`, "gi"), (_m, k) => `${k}=[REDACTED]`)
+        // base64-ключи: длинные И с признаком base64 (есть +/= или смесь регистров+цифр) — НЕ чистый hex/слова
+        .replace(/\b(?=[A-Za-z0-9+/]{44,}={0,2}\b)(?=[A-Za-z0-9+/]*[+/=])[A-Za-z0-9+/]{44,}={0,2}\b/g, "[REDACTED_B64]")
+        // IPv4 с валидацией октетов (0-255) — не задевает версии типа 1.2.3.4 с числами >255, но 4 валидных октета редки в прозе
+        .replace(/\b(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\b/g, "[IP]")
+        .replace(/ssh-(rsa|ed25519)\s+\S+/g, "[REDACTED_SSHKEY]")
+        .replace(/\broot@[^\s'"]+/g, "[REDACTED_HOST]")
+        .replace(/\/root\/[^\s'"]*/g, "~/")
+        .replace(/\/home\/[^/\s'"]+\/?/g, "~/");
+}
+/**
+ * Публикует выжимку ТЕКУЩЕГО репо в глобальный digest (publish-on-save).
+ * Грамотное объединение: трогаем только секцию своего проекта по ключу.
+ */
+function publishToGlobalDigest() {
+    try {
+        const project = detectProjectFromWorkDir() || path.basename(getWorkingDir());
+        if (!project)
+            return;
+        if (isPrivateProject(project))
+            return; // v4.4.0 блок G: приватный проект не публикуем
+        const mdHistory = getMdHistoryPath();
+        const contexts = listContexts();
+        if (contexts.length === 0)
+            return;
+        const stats = getStatistics();
+        const localDigest = loadDigest();
+        // recentTasks: предпочитаем сжатый локальный digest (чистый слой summary), иначе из README
+        let recentTasks = [];
+        if (localDigest && localDigest.recentTasks.length > 0) {
+            recentTasks = localDigest.recentTasks.slice(0, 12).map(t => ({
+                ctx: t.contextId, date: t.date, name: scrubSecrets(t.name), summary: scrubSecrets((t.summary || "").slice(0, 160)),
+            }));
+        }
+        else {
+            recentTasks = contexts.slice(0, 12).map(c => {
+                let summary = "";
+                const r = path.join(c.path, "README.md");
+                if (fs.existsSync(r)) {
+                    const m = fs.readFileSync(r, "utf-8").match(/## Краткое описание\n\n([^\n#]+)/);
+                    if (m)
+                        summary = m[1].trim();
+                }
+                return { ctx: contextIdOf(c), date: c.date, name: scrubSecrets(c.title), summary: scrubSecrets(summary.slice(0, 160)) };
+            });
+        }
+        // topFiles: фильтр мусора/абсолютных путей + scrub на остаток (страховка)
+        // v3.1.2: topFiles уже отфильтрованы isRealFilePath (нет /root//home/секретов) — это пути кода.
+        // НЕ гоняем по ним b64-scrub: длинный путь src/.../GoBackend.java = непрерывный прогон с "/" → ложный [REDACTED_B64].
+        const topFiles = (localDigest?.currentState.keyFiles || []).filter(isRealFilePath).slice(0, 15);
+        const activeEpics = (localDigest?.currentState.activeEpics || []).map(scrubSecrets);
+        const currentFocus = scrubSecrets((localDigest?.currentState.description || "").slice(0, 200));
+        const lastActive = contexts[0]?.date || "";
+        const section = {
+            project, mdHistory,
+            contexts: stats.total, completed: stats.completed, inProgress: stats.inProgress,
+            lastActive, lastSync: new Date().toISOString(),
+            currentFocus, activeEpics, recentTasks, topFiles,
+        };
+        // v3.1.1: под локом перечитываем СВЕЖИЙ файл и пишем ТОЛЬКО свою секцию —
+        // параллельный save в другом репо не затрёт чужие секции (read-modify-write race).
+        withGlobalDigestLock(() => {
+            const fresh = loadGlobalDigest();
+            fresh.projects[project] = section; // ← объединение: только своя секция
+            saveGlobalDigest(fresh);
+        });
+    }
+    catch { /* никогда не ломаем основную работу */ }
+}
+// v3.4: вызов pairing-эндпоинтов БЕЗ токена (новое устройство ещё не авторизовано)
+async function dedPanelPairCall(panelUrl, action, params = {}) {
+    const body = new URLSearchParams({ action, ...params });
+    const res = await fetch(panelUrl.replace(/\/+$/, "") + "/", {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: body.toString(),
+        signal: AbortSignal.timeout(8000),
+    });
+    return await res.json();
+}
+// v3.4: попытка открыть ссылку в браузере пользователя (best-effort, не критично)
+async function tryOpenBrowser(url) {
+    try {
+        const cp = await import("child_process");
+        const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+        cp.spawn(opener, [url], { detached: true, stdio: "ignore" }).unref();
+    }
+    catch { /* нет GUI/браузера — пользователь откроет ссылку сам */ }
+}
+function getSyncConfigPath() {
+    return path.join(getGlobalConfigPath(), "sync.json");
+}
+function loadSyncConfig() {
+    try {
+        const p = getSyncConfigPath();
+        if (fs.existsSync(p))
+            return JSON.parse(fs.readFileSync(p, "utf-8"));
+    }
+    catch { /* */ }
+    return null;
+}
+function saveSyncConfig(cfg) {
+    try {
+        const p = getSyncConfigPath();
+        fs.writeFileSync(p, JSON.stringify(cfg, null, 2), "utf-8");
+        fs.chmodSync(p, 0o600);
+    }
+    catch { /* */ }
+}
+// v3.5.2: атомарное обновление ТОЛЬКО переданных полей (read-merge-write).
+// Параллельные фоновые задачи (pull/push/revoke) пишут свою дельту, не затирая чужие поля.
+function updateSyncConfig(patch) {
+    const cur = loadSyncConfig() || { panelUrl: "https://dedpanel.com", token: "" };
+    saveSyncConfig({ ...cur, ...patch });
+}
+// v3.6.2: вызов с ретраями — повтор на сеть/таймаут/rate-limit (для массового бэкфилла, чтобы ничего не терялось).
+async function dedPanelCallRetry(action, params, retries = 4) {
+    for (let i = 0; i <= retries; i++) {
+        try {
+            const r = await dedPanelCall(action, params);
+            if (r && r.success)
+                return r;
+            // постоянные ошибки (Invalid token и т.п.) — отдаём сразу; временные (rate limit) — повтор
+            if (r && r.error && !/rate limit|too many|retry/i.test(String(r.error)))
+                return r;
+        }
+        catch { /* сеть/таймаут — повтор */ }
+        if (i < retries)
+            await _sleep(200 * (i + 1) + Math.floor((i + 1) * 50)); // backoff
+    }
+    return { success: false, error: "retry_exhausted" };
+}
+// v3.6.2: конкурентный прогон с заданной параллельностью (мощная машина → быстро).
+// worker НЕ должен бросать (ловим), результат по индексу; null при ошибке.
+async function runConcurrent(items, worker, concurrency = 24) {
+    const results = new Array(items.length).fill(null);
+    let idx = 0;
+    const lane = async () => {
+        for (;;) {
+            const i = idx++;
+            if (i >= items.length)
+                break;
+            try {
+                results[i] = await worker(items[i], i);
+            }
+            catch {
+                results[i] = null;
+            }
+        }
+    };
+    const lanes = Math.max(1, Math.min(concurrency, items.length || 1));
+    await Promise.all(Array.from({ length: lanes }, () => lane()));
+    return results;
+}
+// v3.2: УСИЛЕННЫЙ scrub для данных, уходящих в ОБЛАКО (строже scrubSecrets):
+// дополнительно режет длинные hex-токены и SCREAMING_SNAKE env-секреты (находка k05),
+// т.к. global-rules содержат пользовательские токены (напр. в правилах G5/G13).
+function scrubForSync(s) {
+    if (!s)
+        return s;
+    return scrubSecrets(s)
+        // v3.5.2: userinfo в URL (https://user:token@host) — креды в git_remote/origin
+        .replace(/:\/\/[^/@\s]*@/g, "://")
+        // SCREAMING_SNAKE секреты: SS_PASSWORD=, API_TOKEN=, REDIS_PASSWORD= (ключ-слово в любой позиции идентификатора)
+        .replace(/\b[A-Z0-9_]{0,30}(?:PASSWORD|PASSWD|TOKEN|SECRET|APIKEY|PRIVATEKEY|ACCESSKEY|PWD)[A-Z0-9_]{0,30}\s*[:=]\s*['"]?[^\s'"]{4,}/g, (m) => m.split(/\s*[:=]\s*/)[0] + "=[REDACTED]")
+        // длинные hex-токены/ключи (32+ hex) — частый формат API-токенов (вкл. токен DedPanel)
+        .replace(/\b[0-9a-fA-F]{32,}\b/g, "[REDACTED_HEX]");
+}
+async function dedPanelCall(action, params = {}, override) {
+    // v3.2.1: override позволяет проверить токен-КАНДИДАТ до записи в sync.json (auth_login)
+    const cfg = override || loadSyncConfig();
+    if (!cfg || !cfg.panelUrl || !cfg.token)
+        throw new Error("dedpanel_not_configured");
+    const body = new URLSearchParams({ action, ...params });
+    const res = await fetch(cfg.panelUrl.replace(/\/+$/, "") + "/", {
+        method: "POST",
+        headers: { "X-API-Token": cfg.token, "Content-Type": "application/x-www-form-urlencoded" },
+        body: body.toString(),
+        signal: AbortSignal.timeout(8000),
+    });
+    return await res.json();
+}
+// v3.5: при отзыве токена сервер отдаёт {success:false,error:"Invalid API token"} → затираем токен,
+// следующий tool-call уйдёт в pairing (как backgroundRevokeCheck).
+function handleRevokeIfNeeded(r) {
+    if (r && r.success === false && /Invalid API token/i.test(String(r.error || ""))) {
+        updateSyncConfig({ token: "" });
+    }
+}
+// PUSH: выгрузка глобальной памяти в аккаунт DedPanel (с усиленным scrub)
+async function dedPanelSyncPush() {
+    const pushed = [], errors = [];
+    // v3.5.3: global-rules НЕ пушим автоматически — DedPanel источник истины правил
+    // (иначе автопуш затирал бы правки во вкладке MCP). Правила тянутся pull'ом, локальные
+    // изменения через tool `rules` пушатся точечно (pushGlobalRules).
+    const items = [
+        // v3.2.1: digest через scrubForSync (базовый scrub при публикации пропускал SCREAMING_SNAKE/hex — k05/s10)
+        // v4.4.0 блок G/H: ПРИВАТНЫЕ проекты вырезаем из глобального дайджеста перед пушем (не утекают никуда)
+        ["global-digest", () => scrubForSync(JSON.stringify(globalDigestForPush()))],
+        // v3.5: статистика и паттерны — «всё важное на аккаунт»
+        ["global-stats", () => scrubForSync(JSON.stringify(buildGlobalStats()))],
+        ["global-patterns", () => scrubForSync(JSON.stringify(buildPatterns()))],
+    ];
+    for (const [key, build] of items) {
+        try {
+            const r = await dedPanelCall("ded_kv_set", { key, value: build() });
+            if (r && r.success)
+                pushed.push(key);
+            else {
+                errors.push(key);
+                handleRevokeIfNeeded(r);
+            }
+        }
+        catch {
+            errors.push(key);
+        }
+    }
+    return { pushed, errors };
+}
+// v4.2: МУЛЬТИ-УСТРОЙСТВО МЕРЖ ГЛОБАЛЬНЫХ ПРАВИЛ (дедуп по тексту + дата + устройство).
+// Нормализованный текст правила → ключ дедупа (одно правило с разных устройств = одно).
+function ruleHash(text) {
+    const norm = (text || "").toLowerCase().replace(/\s+/g, " ").trim();
+    let h = 0;
+    for (let i = 0; i < norm.length; i++) {
+        h = ((h << 5) - h + norm.charCodeAt(i)) | 0;
+    }
+    return "r" + (h >>> 0).toString(36);
+}
+let _deviceNameCache = null;
+function getDeviceName() {
+    if (_deviceNameCache !== null)
+        return _deviceNameCache;
+    let name = "dedsession";
+    try {
+        name = require("os").hostname() || name;
+    }
+    catch { /* */ }
+    _deviceNameCache = name.slice(0, 40);
+    return _deviceNameCache;
+}
+// миграция: проставить hash/created-время/device правилам, где их нет
+function ensureRuleMeta(idx) {
+    let changed = false;
+    for (const r of idx.rules) {
+        if (!r.hash) {
+            r.hash = ruleHash(r.rule);
+            changed = true;
+        }
+        if (!r.device) {
+            r.device = getDeviceName();
+            changed = true;
+        }
+        if (r.created && r.created.length <= 10) {
+            r.created = r.created + "T00:00:00Z";
+            changed = true;
+        } // дата → datetime
+    }
+    return changed;
+}
+// Единый MERGE-синк глобальных правил: шлём локальные на сервер → сервер union по hash (last-write,
+// tombstone на удаление) → получаем полный union → сохраняем локально. Заменяет push/pull-overwrite.
+async function syncRulesMerge() {
+    const local = loadGlobalRules();
+    ensureRuleMeta(local);
+    const r = await dedPanelCall("mcp_rules_merge", {
+        rules: scrubForSync(JSON.stringify(local.rules)),
+        device: getDeviceName(),
+    });
+    handleRevokeIfNeeded(r);
+    if (r && r.success && Array.isArray(r.rules)) {
+        saveGlobalRules({ rules: r.rules });
+        return true;
+    }
+    return false;
+}
+function pushGlobalRulesInBackground() {
+    const cfg = loadSyncConfig();
+    if (!cfg || !cfg.token)
+        return;
+    void (async () => { try {
+        await syncRulesMerge();
+    }
+    catch { /* оффлайн — синкнётся при следующем quick */ } })();
+}
+// PULL правил = тот же MERGE (union, не overwrite) — ничего не теряется между устройствами.
+async function dedPanelSyncPull() {
+    const pulled = [], errors = [];
+    try {
+        if (await syncRulesMerge())
+            pulled.push("global-rules");
+    }
+    catch {
+        errors.push("global-rules");
+    }
+    return { pulled, errors };
+}
+// v3.5: неблокирующие обёртки авто-синка — вызываются из context_quick/context_save.
+// Всё в фоне (void), в try/catch — оффлайн/ошибка НЕ ломают основную работу.
+const AUTO_PULL_MIN_INTERVAL_MS = 5 * 60 * 1000; // не чаще раза в 5 минут
+function autoPullInBackground() {
+    const cfg = loadSyncConfig();
+    if (!cfg || !cfg.token)
+        return;
+    const last = cfg.lastAutoPull ? Date.parse(cfg.lastAutoPull) : 0;
+    if (last && (Date.now() - last) < AUTO_PULL_MIN_INTERVAL_MS)
+        return;
+    void (async () => {
+        try {
+            await dedPanelSyncPull(); // заодно подтверждает токен (revoke ловится внутри)
+            const fresh = loadSyncConfig();
+            if (fresh && fresh.token)
+                updateSyncConfig({ lastAutoPull: new Date().toISOString(), lastValidated: new Date().toISOString() });
+        }
+        catch { /* оффлайн — молча */ }
+    })();
+}
+function autoPushInBackground() {
+    const cfg = loadSyncConfig();
+    if (!cfg || !cfg.token)
+        return;
+    if (isPrivateProject(detectProjectFromWorkDir() || path.basename(getWorkingDir())))
+        return; // v4.4.0 блок G
+    void (async () => {
+        try {
+            const r = await dedPanelSyncPush();
+            const fresh = loadSyncConfig();
+            if (fresh && fresh.token && r.pushed.length)
+                updateSyncConfig({ lastAutoPush: new Date().toISOString(), lastValidated: new Date().toISOString() });
+        }
+        catch { /* оффлайн — молча, локаль не страдает */ }
+    })();
+}
+// v3.5.2: локальный реестр уже-залитых контекстов (защита от дублей: повторно не грузим).
+// { "<project>": ["001","002",...] }. Дополняет серверный дедуп.
+function getSyncedRegistryPath() { return path.join(getGlobalConfigPath(), "synced-contexts.json"); }
+function loadSyncedRegistry() {
+    try {
+        const p = getSyncedRegistryPath();
+        if (fs.existsSync(p))
+            return JSON.parse(fs.readFileSync(p, "utf-8"));
+    }
+    catch { /* */ }
+    return {};
+}
+// Батч-пометка: один read-merge-write вместо N (меньше окон гонки в цикле backfill).
+function markContextsSynced(project, ctxIds) {
+    if (!project || ctxIds.length === 0)
+        return;
+    try {
+        const reg = loadSyncedRegistry(); // re-read перед записью (свежий, мёрж с чужими записями)
+        const arr = reg[project] || (reg[project] = []);
+        let changed = false;
+        for (const id of ctxIds) {
+            if (id && !arr.includes(id)) {
+                arr.push(id);
+                changed = true;
+            }
+        }
+        if (changed) {
+            fs.writeFileSync(getSyncedRegistryPath(), JSON.stringify(reg), "utf-8");
+            fs.chmodSync(getSyncedRegistryPath(), 0o600);
+        }
+    }
+    catch { /* */ }
+}
+function markContextSynced(project, ctxId) {
+    markContextsSynced(project, [ctxId]);
+}
+// v4.4.0 блок G: ПРИВАТНЫЕ проекты — не уходят НИКУДА (ни события, ни digest, ни бэкфилл).
+// Флаг хранится локально: список в ~/.dedsession/private-projects.json + маркер .dedsession-private в репо.
+function getPrivateProjectsPath() { return path.join(getGlobalConfigPath(), "private-projects.json"); }
+function loadPrivateProjects() {
+    try {
+        const p = getPrivateProjectsPath();
+        if (fs.existsSync(p)) {
+            const j = JSON.parse(fs.readFileSync(p, "utf-8"));
+            if (Array.isArray(j))
+                return j;
+        }
+    }
+    catch { /* */ }
+    return [];
+}
+function isPrivateProject(project) {
+    try {
+        const wd = getWorkingDir();
+        if (fs.existsSync(path.join(wd, ".dedsession-private")))
+            return true; // маркер в репо
+    }
+    catch { /* */ }
+    if (!project)
+        return false;
+    return loadPrivateProjects().includes(project);
+}
+// v4.4.0 блок G/H: глобальный дайджест БЕЗ приватных проектов — то, что реально уходит на сервер.
+function globalDigestForPush() {
+    const gd = loadGlobalDigest();
+    try {
+        const priv = new Set(loadPrivateProjects());
+        if (priv.size && gd.projects) {
+            for (const name of Object.keys(gd.projects))
+                if (priv.has(name))
+                    delete gd.projects[name];
+        }
+    }
+    catch { /* */ }
+    return gd;
+}
+function markProjectPrivate(project) {
+    try {
+        const list = loadPrivateProjects();
+        if (project && !list.includes(project)) {
+            list.push(project);
+            fs.writeFileSync(getPrivateProjectsPath(), JSON.stringify(list, null, 2), "utf-8");
+            fs.chmodSync(getPrivateProjectsPath(), 0o600);
+        }
+    }
+    catch { /* */ }
+    try {
+        const wd = getWorkingDir();
+        fs.writeFileSync(path.join(wd, ".dedsession-private"), "Приватный проект dedsession.\nКонтексты этого проекта НЕ синхронизируются на сервер — только локально.\nУдали этот файл и проект снова станет синхронизируемым.\n", "utf-8");
+    }
+    catch { /* */ }
+}
+// v3.5.2: догон недостающих контекстов в стату при context_quick — идемпотентно (через git, как легаси).
+// Шлёт только те, которых НЕТ в реестре; серверный дедуп страхует от повторов. Если всё залито — ничего.
+let _bgBackfillInflight = false; // не запускаем несколько волн при частых quick
+function autoBackfillMissingInBackground() {
+    if (_bgBackfillInflight)
+        return;
+    const cfg = loadSyncConfig();
+    if (!cfg || !cfg.token)
+        return;
+    if (isPrivateProject(detectProjectFromWorkDir() || path.basename(getWorkingDir())))
+        return; // v4.4.0 блок G
+    _bgBackfillInflight = true;
+    void (async () => {
+        try {
+            const workDir = getWorkingDir();
+            const project = detectProjectFromWorkDir() || path.basename(workDir);
+            const reg = loadSyncedRegistry();
+            const done = new Set(reg[project] || []);
+            const missing = listContexts().filter(c => !done.has(contextIdOf(c)));
+            if (missing.length === 0)
+                return; // всё уже залито — забить
+            const account = String(cfg.username || cfg.uid || "");
+            const gitRemote = scrubForSync(readGitRemoteUrl(workDir) || "");
+            const gitUserCfg = String(readGitUser(workDir) || "").slice(0, 80);
+            // v3.6.2: параллельно (16 lanes — фон при quick) + ретраи
+            const res = await runConcurrent(missing, async (c) => {
+                const status = "saved"; // v4.4.0 блок J: понятие «выполнено/застряло» убрано — событие = просто сохранение
+                const ts = c.date ? Math.floor(new Date(c.date).getTime() / 1000) : Math.floor(Date.now() / 1000);
+                const gitUser = ((await readGitAuthorForDate(workDir, c.date)) || gitUserCfg).slice(0, 80);
+                const r = await dedPanelCallRetry("ded_event", {
+                    project, ctx_id: contextIdOf(c), status, size: String(c.filesCount || 0),
+                    topic: scrubForSync(c.title || "").slice(0, 200), tags: "", solutions_count: "0",
+                    ts: String(isNaN(ts) ? Math.floor(Date.now() / 1000) : ts),
+                    account, git_remote: gitRemote, git_user: gitUser, legacy: "1",
+                });
+                if (r && !r.success)
+                    handleRevokeIfNeeded(r);
+                return { ok: !!(r && r.success), id: contextIdOf(c) };
+            }, 16);
+            markContextsSynced(project, res.filter(x => x && x.ok).map(x => x.id)); // один write в конце (batch)
+        }
+        catch { /* не критично */ }
+        finally {
+            _bgBackfillInflight = false;
+        }
+    })();
+}
+// v3.5: append-событие в лог аккаунта («схема логов»). Только метаполя, scrubForSync на topic.
+function logEventInBackground(ev) {
+    const cfg = loadSyncConfig();
+    if (!cfg || !cfg.token)
+        return;
+    if (isPrivateProject(String(ev.project ?? "")))
+        return; // v4.4.0 блок G: приватный проект не логируем на сервер
+    void (async () => {
+        try {
+            // v3.5.1: привязка «кто/где» — аккаунт DedPanel + git-репо + git-автор
+            const workDir = getWorkingDir();
+            const params = {
+                project: String(ev.project ?? ""),
+                ctx_id: String(ev.ctxId ?? ""),
+                status: "saved", // v4.4.0 блок J: статусы убраны — всегда «saved»
+                size: String(ev.size ?? 0),
+                topic: scrubForSync(String(ev.topic ?? "")).slice(0, 200),
+                tags: Array.isArray(ev.tags) ? ev.tags.slice(0, 5).join(",") : "",
+                solutions_count: String(ev.solutionsCount ?? 0),
+                ts: String(ev.ts ? Number(ev.ts) : Math.floor(Date.now() / 1000)),
+                account: String(cfg.username || cfg.uid || ""),
+                git_remote: scrubForSync(readGitRemoteUrl(workDir) || ""),
+                git_user: String(readGitUser(workDir) || "").slice(0, 80),
+                legacy: ev.legacy ? "1" : "0",
+            };
+            const r = await dedPanelCall("ded_event", params);
+            handleRevokeIfNeeded(r);
+            // помечаем контекст залитым (защита от повторной заливки при quick-догоне)
+            if (r && r.success && ev.ctxId)
+                markContextSynced(params.project, String(ev.ctxId));
+        }
+        catch { /* оффлайн — событие пропускаем, не критично */ }
+    })();
+}
+// v4.5.0: статистика git-коммитов по авторам текущего репо → DedPanel (собирается dedsession).
+// git log --all --no-merges --format=%an, считаем по авторам. Приватные проекты не шлём. Кэш-троттл.
+let _commitStatsSentAt = 0;
+function collectCommitStatsInBackground() {
+    const cfg = loadSyncConfig();
+    if (!cfg || !cfg.token)
+        return;
+    if (Date.now() - _commitStatsSentAt < 10 * 60 * 1000)
+        return; // не чаще раза в 10 мин
+    const project = detectProjectFromWorkDir() || path.basename(getWorkingDir());
+    if (isPrivateProject(project))
+        return; // v4.4.0 блок G: приватный проект — не шлём
+    _commitStatsSentAt = Date.now();
+    void (async () => {
+        try {
+            const workDir = getWorkingDir();
+            const authors = await new Promise((resolve) => {
+                execFile("git", ["-C", workDir, "log", "--all", "--no-merges", "--format=%an"], { encoding: "utf-8", timeout: 8000, maxBuffer: 20 * 1024 * 1024 }, (err, stdout) => {
+                    const acc = {};
+                    if (!err && stdout)
+                        for (const line of stdout.split("\n")) {
+                            const a = line.trim().slice(0, 80);
+                            if (a)
+                                acc[a] = (acc[a] || 0) + 1;
+                        }
+                    resolve(acc);
+                });
+            });
+            if (Object.keys(authors).length === 0)
+                return;
+            const r = await dedPanelCall("mcp_commit_stats", { op: "set", project, stats: JSON.stringify(authors) });
+            handleRevokeIfNeeded(r);
+        }
+        catch { /* оффлайн/нет git — не критично */ }
+    })();
+}
 /**
  * Форматирует блок правил (глобальные + локальные)
  */
 function formatRulesBlock() {
     const globalRules = loadGlobalRules();
     const localRules = loadRules();
-    if (globalRules.rules.length === 0 && localRules.rules.length === 0)
+    // v4.4.0 блок D: считаем активные (без tombstone) глобальные + локальные
+    const activeGlobal = globalRules.rules.filter(r => !r.deleted);
+    const activeLocal = localRules.rules.filter(r => !r.deleted);
+    if (activeGlobal.length === 0 && activeLocal.length === 0)
         return "";
     let output = "# 🔴 ПРИОРИТЕТНЫЕ ПРАВИЛА\n\n";
-    output += "> Эти правила Claude ОБЯЗАН соблюдать во ВСЕХ контекстах!\n\n";
-    // Глобальные правила
-    if (globalRules.rules.length > 0) {
+    output += `> Загружено правил: **${activeGlobal.length}** глобальных + **${activeLocal.length}** локальных. Claude ОБЯЗАН соблюдать их во ВСЕХ контекстах!\n\n`;
+    // Глобальные правила (v4.2: tombstone-удалённые скрываем)
+    if (activeGlobal.length > 0) {
         output += "**🌍 Глобальные (все проекты):**\n";
-        for (const rule of globalRules.rules) {
-            output += `- **G${rule.id}.** ${rule.rule}`;
+        for (const rule of activeGlobal) {
+            const head = rule.title ? `**${rule.title}** — ` : ""; // v4.4.0 блок C: заголовок впереди
+            output += `- **G${rule.id}.** ${head}${rule.rule}`;
             if (rule.context)
                 output += ` _(${rule.context})_`;
             output += "\n";
@@ -1730,9 +2441,9 @@ function formatRulesBlock() {
         output += "\n";
     }
     // Локальные правила
-    if (localRules.rules.length > 0) {
+    if (activeLocal.length > 0) {
         output += "**📁 Локальные (этот проект):**\n";
-        for (const rule of localRules.rules) {
+        for (const rule of activeLocal) {
             output += `- **L${rule.id}.** ${rule.rule}`;
             if (rule.context)
                 output += ` _(${rule.context})_`;
@@ -1778,91 +2489,8 @@ 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;
-    // +5 за совпадение человека (было +10, уменьшено для баланса)
-    if (queryPerson && entry.person === queryPerson) {
-        score += 5;
-    }
-    // +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: +5 за совпадение project (было +3, увеличено)
-    const contextMeta = memoryIndex.contexts[entry.number];
-    if (contextMeta) {
-        for (const kw of queryKeywords) {
-            if (contextMeta.project && contextMeta.project.toLowerCase().includes(kw)) {
-                score += 5;
-            }
-            // +3 за совпадение в keywords из Memory (было +1, увеличено для технологий)
-            if (contextMeta.keywords.some(k => k.includes(kw) || kw.includes(k))) {
-                score += 3;
-            }
-        }
-    }
-    return score;
-}
 function extractKeywords(content) {
     const keywords = new Set();
     // Извлекаем технологии и инструменты
@@ -1913,14 +2541,17 @@ function calculateTemperature(lastAccess, accessCount) {
     return "archive";
 }
 function detectEpicFromContext(contextName, readme, existingEpics) {
-    // Проверяем есть ли parent в readme
-    const parentMatch = readme.match(/\*\*Parent:\*\*\s*(\d+)/);
+    // Проверяем есть ли parent в readme (v3.1.1: полное значение, не только \d+ — иначе legacy-родитель рвался)
+    const parentMatch = readme.match(/\*\*Parent:\*\*\s*(.+)/);
     if (parentMatch) {
-        const parentId = parentMatch[1];
-        // Проверяем в каком эпике находится parent
-        for (const [epicName, epic] of Object.entries(existingEpics.epics)) {
-            if (epic.chain.some(id => id.includes(parentId))) {
-                return epicName;
+        const parentId = normalizeParentRef(parentMatch[1]) || "";
+        // v3.1.1: точное сравнение id, не includes (иначе "001" ложно матчил формат-B id и "100"⊂"1001",
+        // а пустой parentId матчил любой эпик). Пустой parentId — пропускаем.
+        if (parentId) {
+            for (const [epicName, epic] of Object.entries(existingEpics.epics)) {
+                if (epic.chain.some(id => id === parentId)) {
+                    return epicName;
+                }
             }
         }
     }
@@ -1950,6 +2581,12 @@ function migrateToMemorySystem() {
         const projectsIndex = loadProjects();
         const keywordsIndex = loadKeywords();
         const epicsIndex = loadEpics();
+        // v3.1.1: reindex — полный REBUILD из диска (а не merge). Иначе: (1) старые мусорные
+        // keyword-ключи проектов оставались; (2) memoryIndex.contexts копил orphans удалённых папок
+        // и держал дубль под двумя ключами при смене порядка обхода. Диск = источник истины.
+        projectsIndex.projects = {};
+        memoryIndex.contexts = {};
+        keywordsIndex.keywords = {};
         // Проходим по всем контекстам
         for (const ctx of contexts) {
             try {
@@ -1979,8 +2616,9 @@ function migrateToMemorySystem() {
                 }
                 const fullContent = readme + "\n" + changes;
                 const solutionsContent = problemsSolutions + "\n" + readme + "\n" + changes + "\n" + sessionLog;
-                // Определяем проект
-                const project = detectProject(fullContent, ctx.name);
+                // v3.1.1: проект = репозиторий (один репо = один project), а не контент-паттерн.
+                // Раньше detectProject(content) разбрасывал контексты бэкенда по dedsession/web/scripts.
+                const project = detectProjectFromWorkDir() || detectProject(fullContent, ctx.name);
                 // Извлекаем ключевые слова
                 const keywords = extractKeywords(fullContent);
                 // Определяем эпик
@@ -1991,7 +2629,7 @@ function migrateToMemorySystem() {
                     : [];
                 // Создаём мету контекста
                 const contextMeta = {
-                    id: String(ctx.number).padStart(3, "0"),
+                    id: contextIdOf(ctx), // v3.1 LEGACY-FIX: не схлопывать формат B в "000"
                     folder: ctx.name,
                     name: ctx.title,
                     date: ctx.date,
@@ -2012,14 +2650,19 @@ function migrateToMemorySystem() {
                     files,
                     size: ctx.size,
                 };
-                // Извлекаем parent из readme
-                const parentMatch = readme.match(/\*\*Parent:\*\*\s*(\d+)/);
+                // Извлекаем parent из readme (v3.1.1: полное значение → normalizeParentRef, чтобы legacy-формат B резолвился)
+                const parentMatch = readme.match(/\*\*Parent:\*\*\s*(.+)/);
                 if (parentMatch) {
-                    contextMeta.relations.parent = parentMatch[1].padStart(3, "0");
+                    contextMeta.relations.parent = normalizeParentRef(parentMatch[1]);
+                }
+                // v3.1.1 ДУБЛИ ФОРМАТА A: если этот id уже занят ДРУГИМ контекстом (два #076, два #095)
+                // — ключуем по имени папки (уникально на диске), иначе теряли до 33 контекстов (dedai-backend).
+                if (memoryIndex.contexts[contextMeta.id] && memoryIndex.contexts[contextMeta.id].folder !== ctx.name) {
+                    contextMeta.id = ctx.name;
                 }
                 // Сохраняем в индекс
                 memoryIndex.contexts[contextMeta.id] = contextMeta;
-                // Обновляем проекты
+                // Обновляем проекты (идемпотентно: без дублей при повторном reindex)
                 if (project) {
                     if (!projectsIndex.projects[project]) {
                         projectsIndex.projects[project] = {
@@ -2030,9 +2673,11 @@ function migrateToMemorySystem() {
                             hotContexts: [],
                         };
                     }
-                    projectsIndex.projects[project].contexts.push(contextMeta.id);
-                    projectsIndex.projects[project].count++;
-                    if (contextMeta.temperature === "hot") {
+                    if (!projectsIndex.projects[project].contexts.includes(contextMeta.id)) {
+                        projectsIndex.projects[project].contexts.push(contextMeta.id);
+                        projectsIndex.projects[project].count = projectsIndex.projects[project].contexts.length;
+                    }
+                    if (contextMeta.temperature === "hot" && !projectsIndex.projects[project].hotContexts.includes(contextMeta.id)) {
                         projectsIndex.projects[project].hotContexts.push(contextMeta.id);
                     }
                     if (ctx.date > projectsIndex.projects[project].lastActive) {
@@ -2105,65 +2750,6 @@ function updateContextAccess(contextId) {
         }
     }
 }
-function getContextsByProject(projectName) {
-    const memoryIndex = loadMemoryIndex();
-    const projectsIndex = loadProjects();
-    const project = projectsIndex.projects[projectName];
-    if (!project)
-        return [];
-    return project.contexts
-        .map(id => memoryIndex.contexts[id])
-        .filter((ctx) => ctx !== undefined)
-        .sort((a, b) => {
-        // Сначала по температуре (hot > warm > cold > archive)
-        const tempOrder = { hot: 0, warm: 1, cold: 2, archive: 3 };
-        if (tempOrder[a.temperature] !== tempOrder[b.temperature]) {
-            return tempOrder[a.temperature] - tempOrder[b.temperature];
-        }
-        // Потом по дате
-        return b.date.localeCompare(a.date);
-    });
-}
-function getContextsByEpic(epicName) {
-    const memoryIndex = loadMemoryIndex();
-    const epicsIndex = loadEpics();
-    const epic = epicsIndex.epics[epicName];
-    if (!epic)
-        return [];
-    return epic.chain
-        .map(id => memoryIndex.contexts[id])
-        .filter((ctx) => ctx !== undefined);
-}
-function searchByKeywords(query) {
-    const memoryIndex = loadMemoryIndex();
-    const keywordsIndex = loadKeywords();
-    const queryWords = query.toLowerCase().split(/\s+/);
-    const contextScores = new Map();
-    // Ищем по ключевым словам
-    for (const word of queryWords) {
-        for (const [keyword, contextIds] of Object.entries(keywordsIndex.keywords)) {
-            if (keyword.includes(word) || word.includes(keyword)) {
-                for (const id of contextIds) {
-                    contextScores.set(id, (contextScores.get(id) || 0) + 1);
-                }
-            }
-        }
-    }
-    // Ищем по названиям контекстов
-    for (const [id, ctx] of Object.entries(memoryIndex.contexts)) {
-        for (const word of queryWords) {
-            if (ctx.name.toLowerCase().includes(word) || ctx.folder.toLowerCase().includes(word)) {
-                contextScores.set(id, (contextScores.get(id) || 0) + 2);
-            }
-        }
-    }
-    // Сортируем по score
-    return Array.from(contextScores.entries())
-        .sort((a, b) => b[1] - a[1])
-        .slice(0, 10)
-        .map(([id]) => memoryIndex.contexts[id])
-        .filter((ctx) => ctx !== undefined);
-}
 function findSimilarContexts(contextId) {
     const memoryIndex = loadMemoryIndex();
     const ctx = memoryIndex.contexts[contextId];
@@ -2196,19 +2782,6 @@ function findSimilarContexts(contextId) {
         .map(([id]) => memoryIndex.contexts[id])
         .filter((ctx) => ctx !== undefined);
 }
-function getUnfinishedEpics() {
-    const epicsIndex = loadEpics();
-    const memoryIndex = loadMemoryIndex();
-    const unfinished = [];
-    for (const [name, epic] of Object.entries(epicsIndex.epics)) {
-        if (epic.status === "in_progress") {
-            const lastContextId = epic.chain[epic.chain.length - 1];
-            const lastContext = lastContextId ? memoryIndex.contexts[lastContextId] : null;
-            unfinished.push({ name, epic, lastContext });
-        }
-    }
-    return unfinished;
-}
 function getMemoryStats() {
     const memoryIndex = loadMemoryIndex();
     const projectsIndex = loadProjects();
@@ -2231,17 +2804,77 @@ function getMemoryStats() {
         solutionsCount: solutionsIndex.solutions.length,
     };
 }
+// v3.5: расширенная статистика «сколько работаю» — для хранения на аккаунте и дашборда.
+// Только числа/имена проектов (всё равно прогоняется через scrubForSync при пуше).
+function buildGlobalStats() {
+    const ctx = listContexts(); // { date, status, ... }
+    const byDay = {};
+    for (const c of ctx) {
+        if (c.date)
+            byDay[c.date] = (byDay[c.date] || 0) + 1;
+    }
+    const days = Object.keys(byDay).sort();
+    const now = Date.now();
+    const weekAgo = now - 7 * 24 * 60 * 60 * 1000;
+    const perWeek = ctx.filter(c => c.date && new Date(c.date).getTime() >= weekAgo).length;
+    let peakDay = { date: "", count: 0 };
+    for (const [d, n] of Object.entries(byDay))
+        if (n > peakDay.count)
+            peakDay = { date: d, count: n };
+    const mem = getMemoryStats();
+    return {
+        schemaVersion: 1,
+        generated: new Date().toISOString(),
+        totals: getStatistics(),
+        memory: mem,
+        velocity: {
+            perWeek,
+            avgPerActiveDay: Math.round((ctx.length / Math.max(1, days.length)) * 100) / 100,
+            activeDays: days.length,
+        },
+        peakDay,
+        distributionByProject: mem.projects,
+    };
+}
+// v3.5: паттерны решений — частота проблем по ключевым словам, top повторяющихся решений.
+function buildPatterns() {
+    const sols = loadSolutions().solutions;
+    const wordFreq = {};
+    const stop = new Set(["после", "через", "когда", "чтобы", "которые", "этого", "больше", "нужно", "можно", "будет", "this", "that", "with", "from", "then", "null", "true", "false", "которое"]);
+    for (const s of sols) {
+        const words = (s.problem || "").toLowerCase().match(/[a-zа-яё0-9_]{4,}/gi) || [];
+        for (const w of words) {
+            if (stop.has(w))
+                continue;
+            wordFreq[w] = (wordFreq[w] || 0) + 1;
+        }
+    }
+    const topProblems = Object.entries(wordFreq).sort((a, b) => b[1] - a[1]).slice(0, 25).map(([word, count]) => ({ word, count }));
+    const topSolutions = sols
+        .slice()
+        .sort((a, b) => (b.sourceContexts?.length || 0) - (a.sourceContexts?.length || 0))
+        .slice(0, 15)
+        .map(s => ({ problem: (s.problem || "").slice(0, 120), uses: s.sourceContexts?.length || 0 }));
+    return {
+        schemaVersion: 1,
+        generated: new Date().toISOString(),
+        totalSolutions: sols.length,
+        topProblems,
+        topSolutions,
+    };
+}
 /**
  * Добавляет новый контекст в Memory System v2.0
  * Вызывается автоматически при context_save
  */
-function addContextToMemory(contextNumber, folderName, taskName, status, content, date) {
+function addContextToMemory(contextNumber, folderName, taskName, status, content, date, parentRef // v3.1.2 FIX H: явный родитель (state.loadedContext к этому моменту уже перезаписан)
+) {
     try {
         const memoryIndex = loadMemoryIndex();
         const projectsIndex = loadProjects();
         const keywordsIndex = loadKeywords();
-        // Определяем проект
-        const project = detectProject(content, folderName);
+        // v3.1.1: проект = репозиторий (один репо = один project), а не контент-паттерн.
+        const project = detectProjectFromWorkDir() || detectProject(content, folderName);
         // Извлекаем ключевые слова
         const keywords = extractKeywords(content);
         const contextId = String(contextNumber).padStart(3, "0");
@@ -2259,7 +2892,9 @@ function addContextToMemory(contextNumber, folderName, taskName, status, content
             accessCount: 1,
             lastAccess: date,
             relations: {
-                parent: state.loadedContext ? state.loadedContext.split("_")[0].padStart(3, "0") : null,
+                // v3.1.2 FIX H: ТОЛЬКО явный parentRef (из result, вычислен до перезаписи state).
+                // Fallback на state.loadedContext убран — к этому моменту он уже = только что созданный контекст (self).
+                parent: parentRef ? normalizeParentRef(parentRef) : null,
                 children: [],
                 similar: [],
                 epicPrev: null,
@@ -2352,19 +2987,30 @@ server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
     return { contents: [{ uri, mimeType: "text/markdown", text: content }] };
 });
 // TOOLS
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: [
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    // v3.7: ПУБЛИЧНО показываем только ядро — вся остальная логика (миграции, дайджест, синк,
+    // глобал, поиск-дозагрузка, fallback-start) зашита в context_quick/context_save/context_load.
+    // Минимум команд без перегруза. Остальные обработчики остаются внутренними.
+    const _PUBLIC = new Set(["context_quick", "context_save", "context_load", "context_attach", "context_private", "rules", "auth_pair", "auth_status", "auth_logout"]);
+    const _allTools = [
         {
-            name: "context_start",
-            description: "🚀 ГЛАВНАЯ КОМАНДА. Инициализация системы контекста dedsession. Показывает инструкции, статистику и список последних контекстов с выбором действия. ОБЯЗАТЕЛЬНО вызывай когда пользователь говорит: 'запусти контекст', 'загрузи контекст', 'загрузи', 'контекст', 'начни сессию', 'инициализация', 'dedsession', 'старт', 'начало'. Это ПЕРВОЕ что нужно сделать — НЕ вызывай context_load напрямую без context_start!",
-            inputSchema: {
-                type: "object",
-                properties: {},
-            },
+            name: "auth_pair",
+            description: "🔐 Авторизация dedsession через БРАУЗЕР (как OAuth у Claude): генерирует ссылку, открывает браузер, ты жмёшь «Подтвердить» на странице DedPanel — устройство привязывается само. Вызывай когда пользователь говорит: 'авторизуйся', 'привяжи устройство', 'войти через браузер', 'pair', 'подключи dedpanel'. Повторный вызов поллит подтверждение.",
+            inputSchema: { type: "object", properties: {} },
+        },
+        {
+            name: "auth_status",
+            description: "🔐 Показать статус привязки к аккаунту DedPanel (кто авторизован, жив ли токен). Вызывай когда пользователь говорит: 'статус авторизации', 'auth status', 'кто я', 'привязан ли аккаунт'.",
+            inputSchema: { type: "object", properties: {} },
+        },
+        {
+            name: "auth_logout",
+            description: "🔐 Отвязать аккаунт DedPanel (удалить локальный токен). Вызывай когда пользователь говорит: 'выйди', 'отвяжи аккаунт', 'auth logout', 'разлогинься'.",
+            inputSchema: { type: "object", properties: {} },
         },
         {
             name: "context_save",
-            description: "💾 Сохранить контекст работы в MD_HISTORY/. УМНОЕ СОХРАНЕНИЕ: автоматически определяет масштаб задачи (3-15 файлов). Маленькая задача = 3 файла, большая задача = до 15 файлов. ОБЯЗАТЕЛЬНО вызывай когда пользователь говорит: 'сохрани контекст', 'сохрани работу', 'сохранить', 'сохрани', 'запомни работу'.",
+            description: "💾 ЕДИНЫЙ УМНЫЙ РЕЖИМ сохранения контекста (v3.1). Один режим на всё — НЕ нужно выбирать 'подробно/кратко'. Заполняй ЛЮБЫЕ поля, какие есть (можно много, можно мало) — система сохранит ТОЛЬКО непустые секции (пустые не создаются, мусор не копится) и извлечёт максимум пользы для будущего. Чтобы извлечь максимум — старайся заполнять problems_solutions (с Симптом/Root cause/Решение/Профилактика), decisions, key changes. ОБЯЗАТЕЛЬНО вызывай когда пользователь говорит: 'сохрани контекст', 'сохрани работу', 'сохранить', 'сохрани', 'запомни работу', 'сохрани подробно', 'детальное сохранение'. Это ЕДИНСТВЕННАЯ команда сохранения — context_save_detailed устарел и идентичен этой.",
             inputSchema: {
                 type: "object",
                 properties: {
@@ -2372,11 +3018,6 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                         type: "string",
                         description: "Краткое название задачи (станет частью имени папки)",
                     },
-                    status: {
-                        type: "string",
-                        enum: ["completed", "in_progress", "blocked"],
-                        description: "Статус задачи: completed (✅), in_progress (⏳), blocked (❌)",
-                    },
                     task_overview: {
                         type: "string",
                         description: "Описание задачи: что делали, какая была цель",
@@ -2449,139 +3090,30 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ["task_name", "changes", "summary", "session_log"],
             },
         },
-        {
-            name: "context_save_detailed",
-            description: "📚 МАКСИМАЛЬНО ПОДРОБНОЕ сохранение контекста (15 файлов). ОБЯЗАТЕЛЬНО вызывай когда пользователь говорит: 'сохрани контекст подробно', 'подробно сохрани', 'детальное сохранение', 'сохрани всё подробно', '15 файлов'. Создаёт 15 файлов с максимально качественной информацией. Перед вызовом Claude ОБЯЗАН прочитать гайд по заполнению!",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    task_name: {
-                        type: "string",
-                        description: "Краткое название задачи латиницей через дефис (пример: user-auth-fix)",
-                    },
-                    status: {
-                        type: "string",
-                        enum: ["completed", "in_progress", "blocked"],
-                        description: "Статус: completed (✅), in_progress (⏳), blocked (❌)",
-                    },
-                    task_overview: {
-                        type: "string",
-                        description: "ПОДРОБНО: Какую проблему решали? Какая цель? Какой контекст/предыстория? Минимум 5-7 предложений!",
-                    },
-                    analysis: {
-                        type: "string",
-                        description: "ПОДРОБНО: Что нашли при исследовании? Какие проблемы? Какие зависимости? Какие риски? Минимум 5-7 пунктов!",
-                    },
-                    changes: {
-                        type: "string",
-                        description: "КРИТИЧЕСКИ ВАЖНО! Для КАЖДОГО файла: путь, номера строк, что изменено и ПОЧЕМУ, код до/после. Это ГЛАВНЫЙ файл контекста!",
-                    },
-                    summary: {
-                        type: "string",
-                        description: "Что сделано (список), что работает по-другому, что осталось, known issues. Минимум 10 пунктов!",
-                    },
-                    session_log: {
-                        type: "string",
-                        description: "ХРОНОЛОГИЯ сессии: время, действия, ошибки, решения. Формат: '### HH:MM - Событие'. Минимум 5 записей!",
-                    },
-                    code_snippets: {
-                        type: "string",
-                        description: "ВСЕ важные куски кода: новые функции целиком, сложная логика, конфигурации. С комментариями!",
-                    },
-                    decisions: {
-                        type: "string",
-                        description: "Для КАЖДОГО решения: варианты, почему выбрали это, trade-offs. Минимум 3 решения!",
-                    },
-                    problems_solutions: {
-                        type: "string",
-                        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 предложения). Формат: **Сводка:** суть задачи, что сделано, результат. **Файлы:** список изменённых файлов.",
-                    },
-                    digest_update: {
-                        type: "string",
-                        description: "(v3.0) Обновление описания/состояния проекта для дайджеста. Если передано — обновляет описание проекта в 00-overview.md",
-                    },
-                },
-                required: ["task_name", "task_overview", "analysis", "changes", "summary", "session_log", "code_snippets", "decisions", "problems_solutions", "architecture", "history_summary"],
-            },
-        },
         {
             name: "context_load",
-            description: "📂 Загрузить КОНКРЕТНЫЙ контекст по номеру/имени. НЕ вызывай напрямую! Сначала ВСЕГДА context_start. Вызывай ТОЛЬКО когда пользователь выбрал конкретный номер из списка: '1', '2', '3', '001', '002'. Или после context_list когда пользователь указал номер.",
+            description: "📂 Умная ДОЗАГРУЗКА КОНКРЕТНОГО/СВЯЗАННОГО контекста по запросу: номер ('001', '42'), имя папки, или тема/ключевое слово (найдёт и загрузит релевантное). Вызывай когда пользователь говорит: 'загрузи контекст 42', 'покажи контекст про auth', 'найди контекст где делали X', 'открой контекст по теме Y'. Без запроса — список последних для выбора.",
             inputSchema: {
                 type: "object",
                 properties: {
                     query: {
                         type: "string",
-                        description: "Номер контекста (1, 2, 001), имя папки или поисковый запрос. Если пусто - показать список для выбора.",
+                        description: "Номер контекста (1, 2, 001), имя папки или поисковый запрос по теме. Если пусто - показать список.",
                     },
                 },
             },
         },
         {
-            name: "context_list",
-            description: "📋 Показать список всех контекстов со статистикой. ОБЯЗАТЕЛЬНО вызывай когда пользователь говорит: 'покажи контексты', 'список контекстов', 'что сохранено', 'все контексты', '1' (после context_start).",
+            name: "context_attach",
+            description: "🔗 МУЛЬТИ-ПРОЕКТ: подключить ДРУГОЙ репозиторий и прочитать его контекст, чтобы работать с двумя проектами одновременно. Вызывай когда пользователь говорит: 'посмотри этот проект <путь>', 'прочитай контекст проекта <имя>', 'подключи проект', 'работаем в двух проектах', 'объедини проект A и B', 'attach'. Грузит дайджест+последние контексты указанного репо. Пока проект присоединён, context_save дублирует сохранение и туда (работа в обоих). Без аргумента — показать присоединённые / отсоединить.",
             inputSchema: {
                 type: "object",
                 properties: {
-                    limit: {
-                        type: "number",
-                        description: "Максимальное количество (по умолчанию 10)",
-                    },
-                    search: {
-                        type: "string",
-                        description: "Поиск по ключевому слову",
-                    },
+                    project: { type: "string", description: "Путь к репозиторию (/home/.../repo) или имя проекта из карты (git-origin). Пусто — список присоединённых." },
+                    detach: { type: "boolean", description: "true — отсоединить указанный проект (или все, если project пуст)." },
                 },
             },
         },
-        {
-            name: "context_status",
-            description: "📊 Текущий статус сессии: загруженный контекст, статистика, время работы.",
-            inputSchema: {
-                type: "object",
-                properties: {},
-            },
-        },
-        {
-            name: "context_help",
-            description: "❓ Справка по системе контекста. Вызывай когда пользователь говорит 'как работает контекст?', 'помощь', 'справка', 'faq' и т.п.",
-            inputSchema: {
-                type: "object",
-                properties: {},
-            },
-        },
         {
             name: "context_quick",
             description: "⚡ ПЕРВЫЙ ПРИОРИТЕТ! Быстрая загрузка последних контекстов. ОБЯЗАТЕЛЬНО вызывай СРАЗУ когда пользователь говорит: 'быстрый контекст', 'краткий контекст', 'кратко контекст', 'quick context', 'контекст быстро', 'загрузи быстро'. НЕ используй другие инструменты — ТОЛЬКО context_quick! Читает ВСЕ файлы последних контекстов.",
@@ -2591,143 +3123,15 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
             },
         },
         {
-            name: "context_full",
-            description: "📚 Загрузить ВСЕ контексты полностью. ОБЯЗАТЕЛЬНО вызывай когда пользователь говорит: 'все контексты', 'полный контекст', 'загрузи всё', 'прочитай всё'. Читает ВСЕ файлы ВСЕХ контекстов.",
-            inputSchema: {
-                type: "object",
-                properties: {},
-            },
-        },
-        {
-            name: "context_to_history",
-            description: "🔄 Миграция контекстов в HISTORY.md. Возвращает ВСЕ README контекстов — Claude сам анализирует и формирует качественные сводки. При повторном запуске обновляет ВСЕ записи. ОБЯЗАТЕЛЬНО вызывай когда пользователь говорит: 'миграция контекстов', 'создай history', 'индексируй контексты', 'обнови history'.",
-            inputSchema: {
-                type: "object",
-                properties: {},
-            },
-        },
-        {
-            name: "context_history_write",
-            description: "📝 Записывает готовый HISTORY.md от Claude. Вызывай ТОЛЬКО после context_to_history, когда сформировал качественные сводки для всех контекстов.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    content: {
-                        type: "string",
-                        description: "Полный текст HISTORY.md с качественными сводками всех контекстов",
-                    },
-                },
-                required: ["content"],
-            },
-        },
-        {
-            name: "context_related",
-            description: "🔍 Умный поиск контекстов по смыслу. ОБЯЗАТЕЛЬНО вызывай когда пользователь говорит: 'найди контекст про X', 'подгрузи связанный с X', 'контекст связанный с', 'найди похожий контекст', 'поиск контекста'. Claude анализирует HISTORY.md и сам выбирает релевантные контексты по смыслу запроса.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    query: {
-                        type: "string",
-                        description: "Что ищем — описание темы, ключевые слова, смысл задачи",
-                    },
-                },
-                required: ["query"],
-            },
-        },
-        // ==================== MEMORY v2.0 TOOLS ====================
-        {
-            name: "context_project",
-            description: "📁 Показать все контексты проекта. ОБЯЗАТЕЛЬНО вызывай когда пользователь говорит: 'проект ios', 'загрузи проект windows', 'контексты android', 'покажи проект X'. Группирует по температуре: HOT → WARM → COLD → ARCHIVE.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    project: {
-                        type: "string",
-                        description: "Имя проекта: ios, windows, android, scripts, dedsession, web",
-                    },
-                },
-                required: ["project"],
-            },
-        },
-        {
-            name: "context_epic",
-            description: "🔗 Показать цепочку эпика (связанных задач). ОБЯЗАТЕЛЬНО вызывай когда пользователь говорит: 'эпик X', 'цепочка X', 'история задачи X'. Показывает все контексты в хронологическом порядке с ключевыми решениями.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    epic: {
-                        type: "string",
-                        description: "Имя эпика (например: cloudpayments, free-logic, auth-system)",
-                    },
-                },
-                required: ["epic"],
-            },
-        },
-        {
-            name: "context_search",
-            description: "🔎 Полнотекстовый поиск по контекстам. ОБЯЗАТЕЛЬНО вызывай когда пользователь говорит: 'найди X', 'поиск X', 'где упоминается X'. Ищет по ключевым словам, названиям файлов, содержимому.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    query: {
-                        type: "string",
-                        description: "Поисковый запрос: ключевые слова, имя файла, технология",
-                    },
-                },
-                required: ["query"],
-            },
-        },
-        {
-            name: "context_similar",
-            description: "🔄 Найти похожие контексты. ОБЯЗАТЕЛЬНО вызывай когда пользователь говорит: 'похожее на X', 'как делал X раньше', 'аналогичные задачи'. Находит по проекту, эпику, ключевым словам, связям.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    context_id: {
-                        type: "string",
-                        description: "ID контекста (001, 002, ...) для поиска похожих",
-                    },
-                },
-                required: ["context_id"],
-            },
-        },
-        {
-            name: "context_continue",
-            description: "▶️ Показать незавершённые задачи. ОБЯЗАТЕЛЬНО вызывай когда пользователь говорит: 'продолжи', 'что осталось', 'незавершённое', 'in_progress задачи'. Показывает эпики и задачи в статусе in_progress.",
-            inputSchema: {
-                type: "object",
-                properties: {},
-            },
-        },
-        {
-            name: "context_solutions",
-            description: "💡 Показать извлечённые решения. ОБЯЗАТЕЛЬНО вызывай когда пользователь говорит: 'решения', 'паттерны', 'как решал X', 'best practices'. Показывает готовые решения из solutions.json.",
+            name: "context_private",
+            description: "🔒 Сделать ТЕКУЩИЙ проект ПРИВАТНЫМ. ОБЯЗАТЕЛЬНО вызывай когда пользователь говорит: 'сделай проект приватным', 'приватный проект', 'context private', 'не синхронизируй этот проект', 'убери проект с сервера'. После этого контексты проекта НЕ уходят никуда (только локально), и ВСЁ связанное с ним удаляется с сервера DedPanel. Чтобы вернуть синхронизацию — удалить файл .dedsession-private в корне проекта.",
             inputSchema: {
                 type: "object",
                 properties: {
-                    query: {
-                        type: "string",
-                        description: "Поиск по проблеме (опционально)",
-                    },
+                    confirm: { type: "boolean", description: "Подтверждение (по умолчанию true). Удаление данных проекта на сервере необратимо." },
                 },
             },
         },
-        {
-            name: "context_memory",
-            description: "🧠 Статистика системы памяти v2.0. ОБЯЗАТЕЛЬНО вызывай когда пользователь говорит: 'память', 'статистика памяти', 'memory stats'. Показывает проекты, температуры, эпики, решения.",
-            inputSchema: {
-                type: "object",
-                properties: {},
-            },
-        },
-        {
-            name: "context_migrate",
-            description: "🔄 Миграция контекстов в Memory v2.0. ОБЯЗАТЕЛЬНО вызывай когда пользователь говорит: 'миграция в память', 'индексируй в memory', 'обнови memory'. Создаёт JSON индексы для всех контекстов.",
-            inputSchema: {
-                type: "object",
-                properties: {},
-            },
-        },
         {
             name: "rules",
             description: "🔴 Управление ПРИОРИТЕТНЫМИ ПРАВИЛАМИ. ОБЯЗАТЕЛЬНО вызывай когда пользователь говорит: 'добавь правило', 'правила', 'покажи правила', 'удали правило', 'новое правило', 'глобальное правило'. Правила показываются ПЕРВЫМИ при каждой загрузке контекста и Claude ОБЯЗАН их соблюдать.",
@@ -2746,7 +3150,11 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                     },
                     rule: {
                         type: "string",
-                        description: "Текст правила (для action=add)",
+                        description: "Текст правила / описание (для action=add)",
+                    },
+                    title: {
+                        type: "string",
+                        description: "Короткий заголовок правила (опционально, для action=add). Если не указан — берётся начало текста.",
                     },
                     id: {
                         type: "number",
@@ -2760,210 +3168,236 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ["action"],
             },
         },
-        // ========== PROJECT DIGEST v3.0 ==========
-        {
-            name: "context_digest",
-            description: "📦 Просмотр дайджеста проекта. ОБЯЗАТЕЛЬНО вызывай когда пользователь говорит: 'дайджест', 'digest', 'обзор проекта'. Загружает и показывает ВСЕ 5 MD файлов из _DIGEST/.",
-            inputSchema: {
-                type: "object",
-                properties: {},
-            },
-        },
-        {
-            name: "context_digest_migrate",
-            description: "📦 Миграция: создать дайджест из существующих контекстов. ОБЯЗАТЕЛЬНО вызывай когда пользователь говорит: 'миграция дайджеста', 'создай дайджест', 'digest migrate'. Сканирует ВСЕ контексты и строит полный дайджест. Безопасен для повторного запуска.",
-            inputSchema: {
-                type: "object",
-                properties: {},
-            },
-        },
-        {
-            name: "context_digest_refresh",
-            description: "🔄 Claude перечитывает и обновляет дайджест. ОБЯЗАТЕЛЬНО вызывай когда пользователь говорит: 'обнови дайджест', 'refresh digest'. Возвращает текущий digest.json + README последних 10 контекстов. Claude анализирует и вызывает context_digest_write.",
-            inputSchema: {
-                type: "object",
-                properties: {},
-            },
-        },
-        {
-            name: "context_digest_write",
-            description: "📝 Запись качественного дайджеста от Claude. Вызывается ПОСЛЕ context_digest_refresh. Claude передаёт проанализированные данные для обновления дайджеста.",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    description: {
-                        type: "string",
-                        description: "Описание проекта: цель, суть, для кого (3-5 предложений)",
-                    },
-                    tech_stack: {
-                        type: "string",
-                        description: "Стек технологий через запятую: TypeScript, Node.js, MCP, etc.",
-                    },
-                    key_files: {
-                        type: "string",
-                        description: "Ключевые файлы через запятую: src/index.ts, package.json, etc.",
-                    },
-                    active_epics: {
-                        type: "string",
-                        description: "Активные эпики через запятую",
-                    },
-                    known_issues: {
-                        type: "string",
-                        description: "Известные проблемы, каждая на новой строке",
-                    },
-                    phases: {
-                        type: "string",
-                        description: "Фазы эволюции проекта. Формат: 'Название фазы | даты | описание' на каждой строке",
-                    },
-                    key_decisions: {
-                        type: "string",
-                        description: "Ключевые решения, каждое на новой строке",
-                    },
-                },
-            },
-        },
-        // ========== ТЕСТОВЫЕ КОМАНДЫ 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) => {
-    const { name, arguments: args } = request.params;
-    switch (name) {
-        // ==================== CONTEXT_START ====================
-        case "context_start": {
-            state.isInitialized = true;
-            const guide = getInstruction("init");
-            const stats = getStatistics();
-            const contexts = listContexts().slice(0, 5);
-            const architecture = readProjectArchitecture();
-            const workDir = getWorkingDir();
-            const mdHistoryPath = getMdHistoryPath();
-            // v1.4.7: Читаем HISTORY.md
-            const history = readHistory();
-            let output = `# 🚀 Dedsession v${CONFIG.VERSION}\n\n`;
-            output += `📁 **Рабочая директория:** \`${workDir}\`\n`;
-            output += `📂 **MD_HISTORY:** \`${mdHistoryPath}\`\n\n`;
-            // v2.1: Правила показываются ПЕРВЫМИ
-            output += formatRulesBlock();
-            // v1.4.7: Выводим HISTORY.md первым
-            if (history) {
-                output += `---\n\n`;
-                output += `# 📜 HISTORY.md — Полная история работы\n\n`;
-                output += history;
-                output += `\n\n---\n\n`;
+    ];
+    return { tools: _allTools.filter(t => _PUBLIC.has(t.name)) };
+});
+// v3.3: ЖЁСТКИЙ auth-gate — dedsession не работает без привязки к аккаунту DedPanel.
+// С оффлайн-грейсом (фоллбэк на локальный кеш при недоступности DedPanel).
+// v3.5: два порога вместо одного TTL — баланс «нет тормозов / revoke ловится быстро».
+const AUTH_SOFT_TTL_MS = 60 * 1000; // <60с от последней валидации — отдаём ok, сеть не дёргаем
+const AUTH_HARD_TTL_MS = 12 * 60 * 60 * 1000; // потолок онлайн-свежести (бывший AUTH_TTL_MS)
+const AUTH_TTL_MS = AUTH_HARD_TTL_MS; // алиас (на случай прочих ссылок)
+const AUTH_OFFLINE_GRACE_MS = 7 * 24 * 60 * 60 * 1000; // 7д оффлайн-грейс (фоллбэк)
+const AUTH_EXEMPT = new Set(["auth_login", "auth_pair", "auth_status", "auth_logout", "context_help"]);
+const _sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+// v3.4.1: пытается завершить pending pairing немедленно (один poll). null — если нечего проверять.
+async function tryFinishPairing(panelUrl, cfg) {
+    if (!cfg?.pairPid || !cfg.pairCreated || (Date.now() - cfg.pairCreated) >= 600000)
+        return null;
+    try {
+        const chk = await dedPanelPairCall(panelUrl, "mcp_pair_check", { pid: cfg.pairPid });
+        if (chk?.success && chk.status === "confirmed" && chk.token) {
+            saveSyncConfig({ panelUrl, token: chk.token, uid: chk.uid, username: chk.username, lastValidated: new Date().toISOString() });
+            return { ok: true, message: `✅ Авторизовано (${chk.username}). Продолжаю.` };
+        }
+        if (chk?.status === "rejected") {
+            saveSyncConfig({ panelUrl, token: "" });
+            return { ok: false, message: "🚫 Авторизация отклонена в браузере. Повтори команду, чтобы начать заново." };
+        }
+    }
+    catch { /* */ }
+    return null; // ещё pending / недоступно
+}
+// v3.4: browser-pairing с БЛОКИРУЮЩИМ ожиданием — после открытия браузера сам ждёт подтверждения и продолжает.
+async function beginOrContinuePairing() {
+    const prev = loadSyncConfig();
+    const panelUrl = (prev?.panelUrl) || "https://dedpanel.com";
+    // 1) если есть свежий pending — сначала быстрый poll (вдруг уже подтвердили)
+    const fin = await tryFinishPairing(panelUrl, prev);
+    if (fin)
+        return fin;
+    // 2) инициируем новый pairing
+    let pid = prev?.pairPid, url = prev?.pairUrl, code = prev?.pairCode;
+    const stillValid = prev?.pairPid && prev.pairCreated && (Date.now() - prev.pairCreated) < 540000;
+    if (!stillValid) {
+        try {
+            let device = "dedsession";
+            try {
+                device = `${(await import("os")).hostname()} · ${path.basename(getWorkingDir())}`;
+            }
+            catch { /* */ }
+            const init = await dedPanelPairCall(panelUrl, "mcp_pair_init", { device });
+            if (!init?.success || !init.pid)
+                return { ok: false, message: `🔒 Не удалось начать авторизацию (${init?.error || "?"}). Проверь доступность ${panelUrl}.` };
+            pid = init.pid;
+            url = init.confirm_url;
+            code = init.code;
+            saveSyncConfig({ panelUrl, token: prev?.token || "", pairPid: pid, pairUrl: url, pairCode: code, pairCreated: Date.now() });
+            await tryOpenBrowser(url);
+        }
+        catch (e) {
+            return { ok: false, message: `🔒 DedPanel (${panelUrl}) недоступен: ${String(e).slice(0, 80)}. (Обход: env DEDSESSION_NO_AUTH=1.)` };
+        }
+    }
+    // 3) БЛОКИРУЮЩЕЕ ожидание подтверждения (~90с) — чтобы dedsession продолжил САМ, без "повтори команду"
+    for (let i = 0; i < 45; i++) {
+        await _sleep(2000);
+        try {
+            const chk = await dedPanelPairCall(panelUrl, "mcp_pair_check", { pid: pid });
+            if (chk?.success && chk.status === "confirmed" && chk.token) {
+                saveSyncConfig({ panelUrl, token: chk.token, uid: chk.uid, username: chk.username, lastValidated: new Date().toISOString() });
+                return { ok: true, message: `✅ Устройство авторизовано (${chk.username}). Продолжаю команду.` };
             }
-            output += guide + "\n\n---\n\n";
-            // Читаем session.md если есть
-            const sessionMdPath = path.join(getMdHistoryPath(), "session.md");
-            if (fs.existsSync(sessionMdPath)) {
-                output += `## 📋 Из session.md\n\n`;
-                const sessionContent = fs.readFileSync(sessionMdPath, "utf-8");
-                // Берём только секцию "Последний контекст"
-                const lastContextMatch = sessionContent.match(/## Последний контекст[\s\S]*?(?=## |$)/);
-                if (lastContextMatch) {
-                    output += lastContextMatch[0] + "\n---\n\n";
-                }
+            if (chk?.status === "rejected") {
+                saveSyncConfig({ panelUrl, token: "" });
+                return { ok: false, message: "🚫 Авторизация отклонена в браузере." };
             }
-            // v3.0: Показываем дайджест если есть
-            const startDigest = loadDigest();
-            if (startDigest) {
-                output += `## 📦 Project Digest: ${startDigest.project}\n\n`;
-                output += `${(startDigest.currentState.description || "_Описание не задано_").slice(0, 500)}\n\n`;
-                output += `| Показатель | Значение |\n|------------|----------|\n`;
-                output += `| Всего контекстов | ${startDigest.statistics.totalContexts} |\n`;
-                output += `| Завершено | ${startDigest.statistics.completed} |\n`;
-                output += `| В процессе | ${startDigest.statistics.inProgress} |\n`;
-                output += `| Период | ${startDigest.statistics.firstDate} — ${startDigest.statistics.lastDate} |\n\n`;
-                // Последние 5 задач из таймлайна
-                if (startDigest.recentTasks.length > 0) {
-                    output += `### Последние задачи\n\n`;
-                    output += `| # | Дата | Задача | Статус |\n|---|------|--------|--------|\n`;
-                    for (const task of startDigest.recentTasks.slice(0, 5)) {
-                        output += `| ${task.contextId} | ${task.date} | ${task.name} | ${task.status} |\n`;
-                    }
-                    output += "\n";
-                }
-                output += `💡 Полный дайджест: \`context_digest\`\n\n`;
-                output += `---\n\n`;
+            if (chk?.error === "expired" || chk?.error === "not_found")
+                break;
+        }
+        catch { /* сетевой сбой — продолжаем поллить */ }
+    }
+    return { ok: false, message: `🔐 **Авторизация dedsession** — подтверди в браузере:\n${url}\nКод: **${code}**\n\nНе дождался за 90с — нажми «Подтвердить» и повтори команду (подхвачу сразу).` };
+}
+// v3.5: фоновая неблокирующая проверка токена. Не тормозит команды; при revoke
+// затирает токен в sync.json → СЛЕДУЮЩИЙ вызов уйдёт в pairing-блок (заблокирован).
+let _bgAuthInflight = false;
+function backgroundRevokeCheck(cfg) {
+    if (_bgAuthInflight)
+        return;
+    _bgAuthInflight = true;
+    void (async () => {
+        try {
+            const who = await dedPanelCall("api_whoami");
+            const fresh = loadSyncConfig();
+            if (!fresh || fresh.token !== cfg.token)
+                return; // токен уже сменили — не трогаем
+            if (who && who.success) {
+                updateSyncConfig({ uid: who.uid, username: who.username, lastValidated: new Date().toISOString() });
             }
             else {
-                output += `## 📊 Статистика\n\n`;
-                output += `| Показатель | Значение |\n|------------|----------|\n`;
-                output += `| Всего контекстов | ${stats.total} |\n`;
-                output += `| За неделю | ${stats.thisWeek} |\n`;
-                output += `| Завершено | ${stats.completed} |\n`;
-                output += `| В процессе | ${stats.inProgress} |\n\n`;
-                // v3.0: Предложить создать дайджест если контексты есть
-                if (stats.total > 0) {
-                    output += `<claude-instruction>Project Digest НЕ найден. Предложи пользователю создать дайджест командой "миграция дайджеста" — это даст полную историю проекта при каждой загрузке контекста.</claude-instruction>\n`;
-                    output += `> 💡 **Dedsession v3.0:** Создайте Project Digest для мгновенного восстановления контекста: "миграция дайджеста"\n\n`;
-                }
-            }
-            // Архитектура проекта если есть
-            if (architecture.length > 0) {
-                output += `## 🏗️ Архитектура проекта (из MD/)\n\n`;
-                for (const arch of architecture) {
-                    output += arch + "\n\n";
-                }
-                output += `---\n\n`;
-            }
-            if (contexts.length > 0) {
-                output += `## 📦 Последние контексты\n\n`;
-                output += `| # | Название | Дата | Статус |\n|---|----------|------|--------|\n`;
-                for (const ctx of contexts) {
-                    output += `| ${ctx.number || "-"} | ${ctx.title} | ${ctx.date} | ${ctx.status} |\n`;
-                }
-                output += "\n";
+                // REVOKE: токен снят с DedPanel → затираем, следующий tool-call уйдёт в pairing
+                updateSyncConfig({ token: "" });
             }
-            else {
-                output += `## 📦 Контексты\n\nПока нет сохранённых контекстов.\n\n`;
+        }
+        catch { /* оффлайн — ничего; offline-grace отработает в ensureAuthorized */ }
+        finally {
+            _bgAuthInflight = false;
+        }
+    })();
+}
+async function ensureAuthorized(toolName) {
+    if (process.env.DEDSESSION_NO_AUTH === "1")
+        return { ok: true }; // аварийный обход
+    if (AUTH_EXEMPT.has(toolName))
+        return { ok: true };
+    const cfg = loadSyncConfig();
+    if (!cfg || !cfg.token) {
+        // v3.4: не сухой блок, а browser-pairing (ссылка + подтверждение + авто-подхват)
+        return await beginOrContinuePairing();
+    }
+    const now = Date.now();
+    const lastValidatedMs = cfg.lastValidated ? Date.parse(cfg.lastValidated) : 0;
+    const age = lastValidatedMs ? (now - lastValidatedMs) : Infinity;
+    // 1) очень свежо (<soft) — отдаём ok, сеть не дёргаем вообще
+    if (age < AUTH_SOFT_TTL_MS)
+        return { ok: true };
+    // 2) зона soft..hard — ok МГНОВЕННО по кешу, но в фоне проверяем revoke
+    if (age < AUTH_HARD_TTL_MS) {
+        backgroundRevokeCheck(cfg);
+        return { ok: true };
+    }
+    // 3) старше hard — блокирующая онлайн-проверка
+    try {
+        const who = await dedPanelCall("api_whoami");
+        if (who && who.success) {
+            updateSyncConfig({ uid: who.uid, username: who.username, lastValidated: new Date().toISOString() });
+            return { ok: true };
+        }
+        // токен отозван/недействителен → сброс + browser-pairing
+        updateSyncConfig({ token: "" });
+        return await beginOrContinuePairing();
+    }
+    catch {
+        // DedPanel недоступен → оффлайн-грейс по локальному кешу
+        if (age < AUTH_OFFLINE_GRACE_MS)
+            return { ok: true };
+        return { ok: false, message: "🔒 DedPanel недоступен, токен не подтверждался >7 дней. Нужна связь с DedPanel (или `DEDSESSION_NO_AUTH=1` для обхода)." };
+    }
+}
+// v4.7.0: ВЕРСИОННЫЙ БЛОК — сервер задаёт минимальный билд dedsession. Старый клиент блокируется
+// и просит обновиться. Кэш 5 мин. Не привязан/оффлайн/сервер молчит → НЕ блокируем (fail-open).
+function cmpSemver(a, b) {
+    const pa = String(a).split(".").map(n => parseInt(n) || 0);
+    const pb = String(b).split(".").map(n => parseInt(n) || 0);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const d = (pa[i] || 0) - (pb[i] || 0);
+        if (d !== 0)
+            return d < 0 ? -1 : 1;
+    }
+    return 0;
+}
+let _verGateCache = null;
+async function checkVersionGate() {
+    const cfg = loadSyncConfig();
+    if (!cfg || !cfg.token)
+        return null; // не привязан — не блокируем
+    try {
+        if (!_verGateCache || Date.now() - _verGateCache.at > 5 * 60 * 1000) {
+            const r = await dedPanelCall("mcp_version_gate", { op: "get" });
+            if (!r || !r.success)
+                return null; // не достучались — fail-open
+            _verGateCache = { at: Date.now(), min: String(r.min_version || "0.0.0"), message: String(r.message || "") };
+        }
+        if (cmpSemver(CONFIG.VERSION, _verGateCache.min) < 0) {
+            const extra = _verGateCache.message ? `\n\n📢 ${_verGateCache.message}` : "";
+            return `⛔ Версия dedsession ${CONFIG.VERSION} НЕ АКТУАЛЬНА.\n\nТребуется минимум **${_verGateCache.min}**. Обновитесь и перезапустите Claude Code:\n\`\`\`\nnpm install -g dedsession   # или npm update -g dedsession\n\`\`\`\nДо обновления dedsession работать не будет.${extra}`;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    // v3.3: жёсткая авторизация перед любой командой (кроме auth_*/help)
+    const _auth = await ensureAuthorized(name);
+    if (!_auth.ok)
+        return { content: [{ type: "text", text: _auth.message }] };
+    // v4.7.0: версионный блок (кроме auth_* — чтобы можно было проверить статус/отвязаться/обновить привязку)
+    if (!AUTH_EXEMPT.has(name)) {
+        const _block = await checkVersionGate();
+        if (_block)
+            return { content: [{ type: "text", text: _block }] };
+    }
+    switch (name) {
+        // ==================== AUTH_PAIR (v3.4 browser-pairing) ====================
+        case "auth_pair": {
+            const r = await beginOrContinuePairing();
+            return { content: [{ type: "text", text: r.message || (r.ok ? "✅ Авторизован." : "🔒 Не удалось.") }] };
+        }
+        // ==================== CONTEXT_GLOBAL (v3.1) ====================
+        case "auth_status": {
+            const cfg = loadSyncConfig();
+            if (!cfg || !cfg.token)
+                return { content: [{ type: "text", text: "🔓 Не привязан к DedPanel. Используй `auth_login <токен>` для синхронизации памяти между устройствами." }] };
+            let live = "не проверялся";
+            try {
+                const who = await dedPanelCall("api_whoami");
+                live = (who && who.success) ? `✅ жив (${who.username})` : `❌ отклонён (${who?.error || "?"})`;
             }
-            output += `---\n\n`;
-            output += `## 🎯 Что делаем?\n\n`;
-            if (contexts.length > 0) {
-                output += `**Выбери:**\n\n`;
-                output += `**1** — Показать все контексты и выбрать для загрузки\n`;
-                output += `**2** — Начать новый чат (без загрузки контекста)\n\n`;
-                output += `_(просто напиши 1 или 2)_\n`;
+            catch {
+                live = "⚠️ нет связи (оффлайн — работа по локальному кешу)";
             }
-            else {
-                output += `Контекстов пока нет. Начинай работу — потом сохраним контекст.\n`;
+            return { content: [{ type: "text", text: `🔐 Привязка DedPanel\n\n👤 Аккаунт: ${cfg.username || cfg.uid || "?"}\n🌐 Панель: ${cfg.panelUrl}\n🔑 Токен: ${live}\n📅 Последняя проверка: ${cfg.lastValidated || "—"}` }] };
+        }
+        case "auth_logout": {
+            try {
+                const p = getSyncConfigPath();
+                if (fs.existsSync(p))
+                    fs.unlinkSync(p);
             }
-            return { content: [{ type: "text", text: output }] };
+            catch { /* */ }
+            return { content: [{ type: "text", text: "🔓 Аккаунт DedPanel отвязан (локальный токен удалён). Память осталась локально." }] };
         }
-        // ==================== CONTEXT_SAVE ====================
         case "context_save": {
             const taskName = args?.task_name;
             if (!taskName) {
                 return { content: [{ type: "text", text: "❌ Укажи название задачи (task_name)" }] };
             }
-            const statusMap = {
-                completed: "✅ Завершено",
-                in_progress: "⏳ В процессе",
-                blocked: "❌ Заблокировано",
-            };
-            const status = statusMap[args?.status || "in_progress"] || "⏳ В процессе";
+            // v4.4.0 блок J: понятие «выполнено/в процессе/застряло» убрано — по контекстам и так ясно.
+            const status = ""; // нейтрально, в README/коммит/события статус больше не пишем
             // Определяем масштаб сохранения
             const scaleInfo = determineSaveScale({
                 changes: args?.changes,
@@ -2980,41 +3414,43 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 performance: args?.performance,
                 security: args?.security,
             });
-            // Формируем README с информацией о масштабе
-            const readme = `# ${taskName}
-
-**Дата:** ${new Date().toISOString().split("T")[0]}
-**Статус:** ${status}
-**Масштаб:** ${scaleInfo.scale} (${scaleInfo.files.length} файлов)
-
-## Краткое описание
-
-${args?.summary || "Нет описания"}
-
-## Что сделано
-
-${args?.changes?.split("\n").map(l => l.trim() ? `- ${l}` : "").join("\n") || "- Нет данных"}
-`;
+            // v3.1: ЕДИНЫЙ УМНЫЙ SAVE. README без заглушек (sparse), секции пишутся только непустые.
+            let readme = `# ${taskName}\n\n**Дата:** ${new Date().toISOString().split("T")[0]}\n**Масштаб:** ${scaleInfo.scale}\n`;
+            if (args?.summary) {
+                readme += `\n## Краткое описание\n\n${args.summary}\n`;
+            }
+            if (args?.changes) {
+                const bullets = args.changes
+                    .split("\n").map(l => l.trim()).filter(Boolean)
+                    .map(l => (l.startsWith("-") ? l : `- ${l}`)).join("\n");
+                if (bullets)
+                    readme += `\n## Что сделано\n\n${bullets}\n`;
+            }
+            if (state.loadedContext) {
+                readme += `\n## 🔗 Связи\n\n**Parent:** ${state.loadedContext}\n`;
+            }
             const result = saveContext(taskName, {
                 readme,
-                taskOverview: args?.task_overview,
-                analysis: args?.analysis,
-                changes: args?.changes || "Нет изменений",
-                summary: args?.summary || "Нет итогов",
-                sessionLog: args?.session_log,
-                codeSnippets: args?.code_snippets,
-                decisions: args?.decisions,
-                problemsSolutions: args?.problems_solutions,
-                architecture: args?.architecture,
-                testing: args?.testing,
-                apiDocs: args?.api_docs,
-                migration: args?.migration,
-                performance: args?.performance,
-                security: args?.security,
-                fullContext: args?.full_context,
+                taskOverview: args?.task_overview || undefined,
+                analysis: args?.analysis || undefined,
+                changes: args?.changes || "",
+                summary: args?.summary || "",
+                sessionLog: args?.session_log || undefined,
+                codeSnippets: args?.code_snippets || undefined,
+                decisions: args?.decisions || undefined,
+                problemsSolutions: args?.problems_solutions || undefined,
+                architecture: args?.architecture || undefined,
+                testing: args?.testing || undefined,
+                apiDocs: args?.api_docs || undefined,
+                migration: args?.migration || undefined,
+                performance: args?.performance || undefined,
+                security: args?.security || undefined,
+                fullContext: args?.full_context || undefined,
                 // v1.4.10: Готовая сводка для HISTORY.md
                 historySummary: args?.history_summary,
-            }, undefined, scaleInfo.files);
+            }, undefined
+            // filesToCreate опущен → пишутся ВСЕ непустые секции (максимум пользы, без мусора)
+            );
             if (!result.success) {
                 return { content: [{ type: "text", text: `❌ Ошибка: ${result.error}` }] };
             }
@@ -3026,7 +3462,8 @@ ${args?.changes?.split("\n").map(l => l.trim() ? `- ${l}` : "").join("\n") || "-
                 args?.summary,
                 args?.session_log,
             ].filter(Boolean).join("\n");
-            const memoryInfo = addContextToMemory(contextNumber, result.name, taskName, status, fullContent, new Date().toISOString().split("T")[0]);
+            const memoryInfo = addContextToMemory(contextNumber, result.name, taskName, status, fullContent, new Date().toISOString().split("T")[0], result.parentRef // v3.1.2 FIX H: явный родитель, не перезатёртый state
+            );
             // v2.2: Извлекаем решения при сохранении
             let solutionsAdded = 0;
             if (args?.problems_solutions) {
@@ -3056,12 +3493,38 @@ ${args?.changes?.split("\n").map(l => l.trim() ? `- ${l}` : "").join("\n") || "-
                 date: new Date().toISOString().split("T")[0],
                 digestUpdate: args?.digest_update,
             });
+            // v4.5.0: при СОХРАНЕНИИ контекст уходит в DedPanel (ctx_id = имя папки — уникальный ключ,
+            // как в ручной миграции) + обновляются коммиты по авторам. Привязка к аккаунту = изоляция.
+            try {
+                publishToGlobalDigest();
+                logEventInBackground({ type: "context_save", project: digestProject, ctxId: result.name, status: "saved", size: result.filesCount, topic: taskName, tags: memoryInfo.keywords, solutionsCount: solutionsAdded });
+                collectCommitStatsInBackground(); // новые коммиты при сохранении
+                autoPushInBackground();
+            }
+            catch { /* не критично */ }
             let output = `✅ **Контекст сохранён**\n\n`;
             output += `📁 **Папка:** \`${result.name}\`\n`;
             output += `📄 **Файлов:** ${result.filesCount}\n`;
             output += `🎯 **Масштаб:** ${scaleInfo.scale}\n`;
             output += `📊 **Причина:** ${scaleInfo.reason}\n`;
             output += `📍 **Путь:** \`${result.path}\`\n`;
+            // v4.3: МУЛЬТИ-ПРОЕКТ — дублируем сохранённый контекст в присоединённые репо
+            if (state.attachedProjects.length > 0 && result.path) {
+                for (const att of state.attachedProjects) {
+                    try {
+                        const dst = path.join(att.mdHistory, result.name);
+                        if (!fs.existsSync(att.mdHistory))
+                            fs.mkdirSync(att.mdHistory, { recursive: true });
+                        if (!fs.existsSync(dst)) {
+                            fs.cpSync(result.path, dst, { recursive: true });
+                            output += `🔗 **Также сохранено в:** ${att.project} (\`${dst}\`)\n`;
+                        }
+                    }
+                    catch (e) {
+                        output += `⚠️ Не удалось продублировать в ${att.project}: ${String(e).slice(0, 60)}\n`;
+                    }
+                }
+            }
             // v2.0: Показываем Memory info
             if (memoryInfo.project) {
                 output += `\n🧠 **Memory v2.0:**\n`;
@@ -3098,7 +3561,7 @@ ${args?.changes?.split("\n").map(l => l.trim() ? `- ${l}` : "").join("\n") || "-
                     .map(l => l.startsWith("-") ? l : `- ${l}`)
                     .join("\n");
                 const commitTitle = `📝 Context: ${contextShortName}`;
-                const commitBody = `Статус: ${status} | Файлов: ${result.filesCount}\n\nЧто сделано:\n${changeLines}`;
+                const commitBody = `Файлов: ${result.filesCount}\n\nЧто сделано:\n${changeLines}`;
                 output += `\n\n---\n\n`;
                 output += `📋 **Для коммита:**\n\n`;
                 output += `**Title:**\n\`\`\`\n${commitTitle}\n\`\`\`\n\n`;
@@ -3108,172 +3571,139 @@ ${args?.changes?.split("\n").map(l => l.trim() ? `- ${l}` : "").join("\n") || "-
             return { content: [{ type: "text", text: output }] };
         }
         // ==================== CONTEXT_SAVE_DETAILED ====================
-        case "context_save_detailed": {
-            const taskName = args?.task_name;
-            if (!taskName) {
-                // Возвращаем гайд по заполнению
-                return { content: [{ type: "text", text: INSTRUCTIONS.saveDetailedGuide }] };
-            }
-            const statusMap = {
-                completed: "✅ Завершено",
-                in_progress: "⏳ В процессе",
-                blocked: "❌ Заблокировано",
-            };
-            const status = statusMap[args?.status || "completed"] || "✅ Завершено";
-            // Всегда 15 файлов для максимально детального сохранения
-            const detailedFiles = [
-                "README.md",
-                "01-task-overview.md",
-                "02-analysis.md",
-                "03-changes.md",
-                "04-summary.md",
-                "05-session-log.md",
-                "06-code-snippets.md",
-                "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 (15 файлов)
-
-## Краткое описание
-
-${args?.summary || "Нет описания"}
-
-## Что сделано
-
-${args?.changes?.split("\n").map(l => l.trim() ? `- ${l}` : "").join("\n") || "- Нет данных"}
-
-
-## 🔗 Связи
-
-${state.loadedContext ? `**Parent:** ${state.loadedContext}` : "Нет parent контекста"}
-`;
-            const result = saveContext(taskName, {
-                readme,
-                taskOverview: args?.task_overview || "Не указано",
-                analysis: args?.analysis || "Анализ не проводился",
-                changes: args?.changes || "Нет изменений",
-                summary: args?.summary || "Нет итогов",
-                sessionLog: args?.session_log || "Лог сессии не записан",
-                codeSnippets: args?.code_snippets || "Нет кода",
-                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);
-            if (!result.success) {
-                return { content: [{ type: "text", text: `❌ Ошибка: ${result.error}` }] };
+        // v4.3: МУЛЬТИ-ПРОЕКТ — подключить другой репозиторий
+        case "context_attach": {
+            const proj = (args?.project || "").trim();
+            const detach = args.detach === true;
+            const trunc = (t, n) => t.length > n ? t.slice(0, n) + "\n…(обрезано)" : t;
+            if (detach) {
+                if (!proj) {
+                    state.attachedProjects = [];
+                    return { content: [{ type: "text", text: "🔗 Все присоединённые проекты отсоединены." }] };
+                }
+                const before = state.attachedProjects.length;
+                state.attachedProjects = state.attachedProjects.filter(a => a.project !== proj && !a.mdHistory.includes(proj));
+                return { content: [{ type: "text", text: before > state.attachedProjects.length ? `🔗 Проект «${proj}» отсоединён.` : `Проект «${proj}» не был присоединён.` }] };
+            }
+            if (!proj) {
+                if (state.attachedProjects.length === 0)
+                    return { content: [{ type: "text", text: "🔗 Нет присоединённых проектов.\n\nПодключи: `context_attach /путь/к/репо` или `context_attach имя-проекта`.\nОтсоединить: `context_attach <имя> detach`." }] };
+                let o = `## 🔗 Присоединённые проекты (${state.attachedProjects.length})\n\n`;
+                for (const a of state.attachedProjects)
+                    o += `- **${a.project}** — \`${a.mdHistory}\`\n`;
+                o += `\n💾 При сохранении контекст дублируется и в эти проекты.`;
+                return { content: [{ type: "text", text: o }] };
+            }
+            // резолвим путь к MD_HISTORY присоединяемого репо
+            let mdHistory = "";
+            let projectName = "";
+            const tryPaths = [
+                path.join(proj, "MD_HISTORY"), // proj = корень репо
+                proj.endsWith("MD_HISTORY") ? proj : "", // proj = сама MD_HISTORY
+            ].filter(Boolean);
+            for (const p of tryPaths) {
+                if (fs.existsSync(p) && fs.statSync(p).isDirectory()) {
+                    mdHistory = p;
+                    break;
+                }
             }
-            // v2.0: Добавляем в Memory System
-            const contextNumber = parseInt(result.name.split("_")[0]) || 0;
-            const fullContent = [
-                args?.task_overview,
-                args?.analysis,
-                args?.changes,
-                args?.summary,
-                args?.session_log,
-                args?.code_snippets,
-                args?.decisions,
-                args?.problems_solutions,
-                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);
-            // v3.0: Обновляем дайджест (detailed передаёт больше данных)
-            const digestProjectD = detectProjectFromWorkDir() || memoryInfo.project || "unknown";
-            const digestUpdatedD = updateDigestOnSave({
-                project: digestProjectD,
-                contextId,
-                taskName,
-                status,
-                changes: args?.changes,
-                summary: args?.summary,
-                historySummary: args?.history_summary,
-                problemsSolutions: args?.problems_solutions,
-                decisions: args?.decisions,
-                architecture: args?.architecture,
-                date: new Date().toISOString().split("T")[0],
-                digestUpdate: args?.digest_update,
-            });
-            let output = `✅ **Контекст сохранён ПОДРОБНО**\n\n`;
-            output += `📁 **Папка:** \`${result.name}\`\n`;
-            output += `📄 **Файлов:** 15\n`;
-            output += `🎯 **Масштаб:** detailed (максимальная детализация)\n`;
-            output += `📍 **Путь:** \`${result.path}\`\n`;
-            // v2.0: Показываем Memory info
-            if (memoryInfo.project) {
-                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 (!mdHistory) {
+                // поиск по имени в глобальной карте проектов
+                const gd = loadGlobalDigest();
+                for (const [name, sec] of Object.entries(gd.projects)) {
+                    if (name === proj || name.toLowerCase() === proj.toLowerCase()) {
+                        if (sec.mdHistory && fs.existsSync(sec.mdHistory)) {
+                            mdHistory = sec.mdHistory;
+                            projectName = name;
+                            break;
+                        }
+                    }
                 }
             }
-            // v3.0: Дайджест статус
-            if (digestUpdatedD) {
-                output += `\n📦 **Дайджест обновлён** (${digestProjectD})\n`;
+            if (!mdHistory)
+                return { content: [{ type: "text", text: `❌ Не нашёл проект «${proj}».\nУкажи путь к репо (\`context_attach /home/.../repo\`) или имя из карты проектов (см. вкладку MCP / context_quick).` }] };
+            const repoDir = path.dirname(mdHistory);
+            if (!projectName)
+                projectName = readGitOriginName(repoDir) || path.basename(repoDir);
+            const atCtx = listContexts(mdHistory);
+            if (!state.attachedProjects.some(a => a.mdHistory === mdHistory))
+                state.attachedProjects.push({ project: projectName, mdHistory });
+            let out = `# 🔗 Проект присоединён: ${projectName}\n\n`;
+            out += `📍 \`${repoDir}\`\n📊 Контекстов: ${atCtx.length}\n\n`;
+            // дайджест присоединённого репо если есть
+            const adigest = path.join(mdHistory, "_DIGEST", "00-overview.md");
+            if (fs.existsSync(adigest)) {
+                out += `## Обзор проекта\n\n${trunc(fs.readFileSync(adigest, "utf-8"), 3 * 1024)}\n\n---\n\n`;
+            }
+            if (atCtx.length > 0) {
+                out += `## Последние контексты «${projectName}»\n\n| # | Задача | Дата | Статус |\n|---|--------|------|--------|\n`;
+                for (const c of atCtx.slice(0, 8))
+                    out += `| ${contextIdOf(c)} | ${c.title} | ${c.date} | ${c.status} |\n`;
+                // полный README верхнего контекста
+                const top = atCtx[0];
+                const rd = path.join(top.path, "README.md");
+                if (fs.existsSync(rd))
+                    out += `\n### Свежий контекст (#${contextIdOf(top)})\n\n${trunc(fs.readFileSync(rd, "utf-8"), 4 * 1024)}\n`;
+            }
+            out += `\n💡 Теперь работаешь с двумя проектами. При \`сохрани контекст\` запись продублируется и в «${projectName}». Отсоединить: \`context_attach ${projectName} detach\`.`;
+            return { content: [{ type: "text", text: out }] };
+        }
+        case "context_private": {
+            // v4.4.0 блок G: текущий проект → приватный. Локальный флаг + полная зачистка на сервере.
+            const project = detectProjectFromWorkDir() || path.basename(getWorkingDir());
+            if (!project)
+                return { content: [{ type: "text", text: "❌ Не удалось определить текущий проект." }] };
+            const already = isPrivateProject(project);
+            markProjectPrivate(project); // список ~/.dedsession + маркер .dedsession-private в репо
+            // Зачистка на сервере: удалить ВСЁ связанное с проектом (события/индекс/digest/AI-кэш).
+            let serverMsg = "";
+            const cfg = loadSyncConfig();
+            if (cfg && cfg.token) {
+                try {
+                    const r = await dedPanelCall("mcp_project_reset", { project });
+                    if (r && r.success)
+                        serverMsg = `🧹 На сервере удалено событий: ${r.removed ?? 0}.`;
+                    else {
+                        handleRevokeIfNeeded(r);
+                        serverMsg = `⚠️ Сервер: ${r?.error || "не удалось зачистить (попробуй позже)"}.`;
+                    }
+                }
+                catch {
+                    serverMsg = "⚠️ Оффлайн — серверная зачистка не выполнена (повтори команду онлайн).";
+                }
             }
-            if (state.loadedContext && state.loadedContext !== result.name) {
-                output += `\n🔗 **Parent:** ${state.loadedContext}\n`;
+            else {
+                serverMsg = "ℹ️ Аккаунт не привязан — на сервере и так ничего нет.";
             }
-            output += `\n---\n\n`;
-            output += `**Созданные файлы:**\n`;
-            for (const f of detailedFiles) {
-                output += `- ${f}\n`;
+            // также убрать из локального реестра залитых (чтобы не считался синхронизированным)
+            try {
+                const reg = loadSyncedRegistry();
+                if (reg[project]) {
+                    delete reg[project];
+                    fs.writeFileSync(getSyncedRegistryPath(), JSON.stringify(reg), "utf-8");
+                    fs.chmodSync(getSyncedRegistryPath(), 0o600);
+                }
             }
-            output += `\n---\n\n`;
-            output += `💡 **Для продолжения в новой сессии:**\n`;
-            output += `\`\`\`\nзапусти контекст → загрузи #${result.name.split("_")[0]}\n\`\`\``;
-            // v1.4.16: Готовый текст для коммита (копировать вручную)
-            const git = isGitConfigured();
-            if (git.configured) {
-                const contextShortName = result.name.split("_").slice(2).join("_") || result.name;
-                const changeLines = (args?.changes || "")
-                    .split("\n")
-                    .map(l => l.trim())
-                    .filter(l => l.length > 0)
-                    .slice(0, 3)
-                    .map(l => l.startsWith("-") ? l : `- ${l}`)
-                    .join("\n");
-                const commitTitle = `📝 Context: ${contextShortName}`;
-                const commitBody = `Статус: ${status} | Файлов: 15\n\nЧто сделано:\n${changeLines}`;
-                output += `\n\n---\n\n`;
-                output += `📋 **Для коммита:**\n\n`;
-                output += `**Title:**\n\`\`\`\n${commitTitle}\n\`\`\`\n\n`;
-                output += `**Description:**\n\`\`\`\n${commitBody}\n\`\`\``;
-                output += `\n\n<claude-instruction>ОБЯЗАТЕЛЬНО покажи пользователю секцию "Для коммита" с Title и Description ПОЛНОСТЬЮ в своём ответе. Не сокращай вывод.</claude-instruction>`;
+            catch { /* */ }
+            // v4.4.0 блок G/H: вырезать секцию проекта из ЛОКАЛЬНОГО global-digest.json,
+            // иначе autoPush из другого (публичного) проекта заново зальёт её на сервер — утечка.
+            try {
+                const gd = loadGlobalDigest();
+                if (gd.projects && gd.projects[project]) {
+                    delete gd.projects[project];
+                    saveGlobalDigest(gd);
+                }
             }
-            return { content: [{ type: "text", text: output }] };
+            catch { /* */ }
+            let out = `# 🔒 Проект «${project}» теперь ПРИВАТНЫЙ\n\n`;
+            if (already)
+                out += `(он уже был приватным — повторно зачистил сервер)\n\n`;
+            out += `- Контексты этого проекта больше **не уходят никуда** — только локально.\n`;
+            out += `- ${serverMsg}\n`;
+            out += `- В корне проекта создан маркер \`.dedsession-private\`.\n\n`;
+            out += `↩️ Вернуть синхронизацию: удали файл \`.dedsession-private\` в корне проекта.`;
+            return { content: [{ type: "text", text: out }] };
         }
-        // ==================== CONTEXT_LOAD ====================
         case "context_load": {
             const query = args?.query;
             // Если нет запроса - показываем список для выбора
@@ -3319,7 +3749,9 @@ ${state.loadedContext ? `**Parent:** ${state.loadedContext}` : "Нет parent к
                 return { content: [{ type: "text", text: `❌ ${result.error}` }] };
             }
             // v2.0: Обновляем accessCount и temperature
-            const contextId = state.loadedContext?.split("_")[0]?.padStart(3, "0");
+            // v3.1.1: id через normalizeParentRef (как в индексе) — иначе для формата B/дублей
+            // split("_")[0] давал "2025"/неверный ключ → updateContextAccess был no-op, Memory-блок пуст.
+            const contextId = state.loadedContext ? normalizeParentRef(state.loadedContext) : null;
             if (contextId) {
                 updateContextAccess(contextId);
             }
@@ -3383,128 +3815,77 @@ ${state.loadedContext ? `**Parent:** ${state.loadedContext}` : "Нет parent к
             return { content: [{ type: "text", text: output }] };
         }
         // ==================== CONTEXT_LIST ====================
-        case "context_list": {
-            const limit = args?.limit || 10;
-            const search = args?.search;
-            let contexts = search ? searchContexts(search) : listContexts();
-            const total = contexts.length;
-            contexts = contexts.slice(0, limit);
-            if (contexts.length === 0) {
-                if (search) {
-                    return { content: [{ type: "text", text: `🔍 По запросу "${search}" ничего не найдено` }] };
-                }
-                return { content: [{ type: "text", text: "📭 Нет сохранённых контекстов" }] };
-            }
-            const stats = getStatistics();
-            let output = `## 📊 Статистика\n\n`;
-            output += `Всего: **${stats.total}** | За неделю: **${stats.thisWeek}** | `;
-            output += `✅ ${stats.completed} | ⏳ ${stats.inProgress}\n\n`;
-            if (search) {
-                output += `🔍 Результаты поиска "${search}": ${total}\n\n`;
-            }
-            output += `## 📦 Контексты\n\n`;
-            output += `| # | Название | Дата | Статус | Файлов |\n`;
-            output += `|---|----------|------|--------|--------|\n`;
-            for (const ctx of contexts) {
-                const num = ctx.number ? String(ctx.number).padStart(3, "0") : "-";
-                output += `| ${num} | ${ctx.title.slice(0, 30)} | ${ctx.date} | ${ctx.status} | ${ctx.filesCount} |\n`;
-            }
-            if (total > limit) {
-                output += `\n📝 Показано ${limit} из ${total}.\n`;
+        case "context_quick": {
+            state.isInitialized = true;
+            // v3.5: фоновый авто-pull свежих правил + АВТО-PUSH (правила/карта на аккаунт) + событие старта.
+            // v4.5.0: МИГРАЦИЯ старых контекстов УБРАНА (autoBackfill) — историю залили вручную единоразово,
+            // чтобы не было дублей/багов. Теперь работает просто: при СОХРАНЕНИИ контекст уходит в DedPanel.
+            try {
+                autoPullInBackground();
+                autoPushInBackground();
+                collectCommitStatsInBackground(); // коммиты по авторам → DedPanel
+                logEventInBackground({ type: "context_quick", project: detectProjectFromWorkDir() || "", status: "quick" });
             }
-            output += `\n---\n_Dedsession v${CONFIG.VERSION}_\n`;
-            return { content: [{ type: "text", text: output }] };
-        }
-        // ==================== CONTEXT_STATUS ====================
-        case "context_status": {
-            const stats = getStatistics();
-            const uptime = Math.round((Date.now() - state.sessionStartTime.getTime()) / 1000 / 60);
-            const workDir = getWorkingDir();
-            let output = `## 📊 Статус сессии — Dedsession v${CONFIG.VERSION}\n\n`;
-            output += `| Параметр | Значение |\n|----------|----------|\n`;
-            output += `| Версия | ${CONFIG.VERSION} |\n`;
-            output += `| Рабочая директория | \`${workDir}\` |\n`;
-            output += `| Время работы | ${uptime} мин |\n`;
-            output += `| Инициализирована | ${state.isInitialized ? "✅" : "❌"} |\n`;
-            output += `| Загруженный контекст | ${state.loadedContext || "—"} |\n`;
-            output += `| Всего контекстов | ${stats.total} |\n`;
-            output += `| Завершено | ${stats.completed} |\n`;
-            output += `| В процессе | ${stats.inProgress} |\n`;
-            return { content: [{ type: "text", text: output }] };
-        }
-        // ==================== CONTEXT_HELP ====================
-        case "context_help": {
-            const output = `# Dedsession — Справка
-
-## Команды
-
-| Скажи | Что будет |
-|-------|-----------|
-| \`запусти контекст\` | Инициализация + статистика + последний контекст |
-| \`сохрани контекст\` | Сохранить работу в MD_HISTORY/ |
-| \`загрузи контекст\` | Показать список для выбора |
-| \`загрузи контекст 5\` | Загрузить контекст #005 |
-| \`загрузи контекст api\` | Поиск по слову "api" |
-| \`покажи контексты\` | Список всех контекстов |
-| \`статус\` | Текущая сессия |
-
----
-
-## Структура
-
-\`\`\`
-MD_HISTORY/
-├── session.md                    ← актуальный статус
-└── 001_2025-12-16_task-name/
-    ├── README.md                 ← обзор
-    ├── 01-task-overview.md       ← задача
-    ├── 02-analysis.md            ← анализ
-    ├── 03-changes.md             ← изменения
-    ├── 04-summary.md             ← итоги
-    ├── 05-session-log.md         ← лог диалога
-    └── 06-*.md                   ← доп. файлы
-\`\`\`
-
----
-
-## Автоматика
-
-**Напоминания** — Claude напомнит сохранить когда:
-- Изменено 5+ файлов
-- Задача завершена
-- Прошло 30+ минут
-- Сказано "готово", "сделано"
-
-**Parent/Child** — связи создаются автоматически:
-- Загрузил #005 → поработал → сохранил → #006 (child of #005)
-
-**session.md** — обновляется после каждого сохранения
-
----
-
-## Правила
-
-| DO | DON'T |
-|----|-------|
-| Сохраняй перед уходом | Не забывай сохранять |
-| Загружай при возвращении | Не объясняй заново |
-| Давай понятные имена | Не называй "work1" |
-
----
-
-**v${CONFIG.VERSION}** | \`npm: dedsession\`
-`;
-            return { content: [{ type: "text", text: output }] };
-        }
-        // ==================== CONTEXT_QUICK ====================
-        case "context_quick": {
-            state.isInitialized = true;
-            const allContexts = listContexts();
+            catch { /* не критично */ }
+            const allContexts = listContexts();
             const stats = getStatistics();
             const workDir = getWorkingDir();
             if (allContexts.length === 0) {
-                return { content: [{ type: "text", text: "📭 Нет сохранённых контекстов" }] };
+                // v4.0: fallback-старт (бывший context_start) — нет контекстов → показываем систему + правила,
+                // чтобы первый запуск был осмысленным, а не пустым.
+                let out = `## 🚀 dedsession v${CONFIG.VERSION} — система памяти Claude\n\n`;
+                out += `📭 В этом репозитории (\`${path.basename(workDir)}\`) ещё нет сохранённых контекстов.\n\n`;
+                out += `**Как работает (всё в 3 командах):**\n`;
+                out += `- 💾 **сохрани контекст** — записать работу (дайджест, решения, синк — всё автоматом)\n`;
+                out += `- ⚡ **загрузи контекст** — подтянуть последнее (этот вызов)\n`;
+                out += `- 📋 **правила** (rules) — глобальные + локальные, применяются всегда\n\n`;
+                try {
+                    const rb = formatRulesBlock();
+                    if (rb && rb.trim())
+                        out += rb + "\n";
+                }
+                catch { /* */ }
+                out += `\n💡 Начни работу и скажи «сохрани контекст» — система запомнит.`;
+                return { content: [{ type: "text", text: out }] };
+            }
+            // v3.1: АВТОМИГРАЦИЯ СХЕМЫ ПАМЯТИ — вшита прямо в быстрый контекст.
+            // Версионный гейт: если схема свежая → мгновенный skip (одно сравнение, без I/O).
+            // Если устарела → один раз на репо: бэкап → полный reindex из диска → проставить версию.
+            // Гейт сам защищает от повторов (миграция выполнится ровно раз), всё в try/catch — не ломает загрузку.
+            let migrationNote = "";
+            try {
+                const _idx = loadMemoryIndex();
+                if ((_idx.schemaVersion || 0) < CONFIG.SCHEMA_VERSION) {
+                    // Бэкап текущей памяти перед миграцией (безопасность/откат)
+                    try {
+                        const memDir = getMemoryPath();
+                        const backupDir = path.join(memDir, `.backup-schema${_idx.schemaVersion || 0}`);
+                        if (!fs.existsSync(backupDir) && fs.existsSync(memDir)) {
+                            ensureDir(backupDir);
+                            for (const f of fs.readdirSync(memDir).filter(f => f.endsWith(".json"))) {
+                                fs.copyFileSync(path.join(memDir, f), path.join(backupDir, f));
+                            }
+                        }
+                    }
+                    catch { /* бэкап не критичен для продолжения */ }
+                    const mig = migrateToMemorySystem(); // полный reindex из диска (источник истины)
+                    const idx2 = loadMemoryIndex();
+                    idx2.version = CONFIG.VERSION;
+                    idx2.lastMigration = new Date().toISOString();
+                    // v3.1.1 FIX: schemaVersion ставим ТОЛЬКО при успешной миграции.
+                    // Иначе провал на середине «замораживал» недомигрированный legacy навсегда (гейт больше не сработает).
+                    if (mig.success) {
+                        idx2.schemaVersion = CONFIG.SCHEMA_VERSION;
+                        migrationNote = `🔄 **Память обновлена** до схемы v${CONFIG.SCHEMA_VERSION}: проиндексировано ${mig.migrated} контекстов`;
+                        if (mig.errors.length > 0)
+                            migrationNote += ` (пропущено: ${mig.errors.length})`;
+                        migrationNote += `\n\n`;
+                    }
+                    // при неуспехе schemaVersion НЕ трогаем → следующий context_quick повторит миграцию
+                    saveMemoryIndex(idx2);
+                }
             }
+            catch { /* автомиграция никогда не должна ломать context_quick */ }
             // v3.0: Проверяем наличие дайджеста — если нет, создаём автоматически
             let digest = loadDigest();
             if (!digest && allContexts.length > 0) {
@@ -3514,7 +3895,7 @@ MD_HISTORY/
                 const keywordsIdx = loadKeywords();
                 const solutionsIdx = loadSolutions();
                 for (const ctx of allContexts) {
-                    const ctxId = String(ctx.number).padStart(3, "0");
+                    const ctxId = contextIdOf(ctx); // v3.1 LEGACY-FIX
                     let summary = "";
                     const readmePath = path.join(ctx.path, "README.md");
                     if (fs.existsSync(readmePath)) {
@@ -3565,6 +3946,16 @@ MD_HISTORY/
                 digest = autoDigest;
             }
             const hasDigest = digest !== null;
+            // v4.4.0 блок J: перегенерируем MD-файлы дайджеста новыми рендерами (без статусов),
+            // чтобы старые файлы со «завершено/в работе/застряло» сразу обновились до чистого вида.
+            if (hasDigest && digest) {
+                try {
+                    saveDigest(digest);
+                }
+                catch { /* не критично */ }
+            }
+            // v3.1: публикуем выжимку этого репо в глобальный digest (реестр + объединение)
+            publishToGlobalDigest();
             // v2.0: Получаем Memory stats
             const memoryStats = getMemoryStats();
             const hasMemory = memoryStats.totalContexts > 0;
@@ -3583,8 +3974,10 @@ MD_HISTORY/
                 return text.slice(0, maxLen - 20) + "\n\n... [обрезано]";
             };
             let output = `# ⚡ Краткий контекст — Dedsession v${CONFIG.VERSION}\n\n`;
+            if (migrationNote)
+                output += migrationNote;
             output += `📁 **Рабочая директория:** \`${workDir}\`\n`;
-            output += `📊 **Статистика:** Всего ${stats.total} | ✅ ${stats.completed} | ⏳ ${stats.inProgress}\n`;
+            output += `📊 **Статистика:** Всего контекстов ${stats.total}\n`; // v4.4.0 блок J: без статусов
             if (hasDigest) {
                 output += `📦 **Режим:** Дайджест + ${contextCount} контекстов (v3.0)\n\n`;
             }
@@ -3593,9 +3986,29 @@ MD_HISTORY/
             }
             // v2.1: Правила показываются ПЕРВЫМИ
             output += formatRulesBlock();
+            // v4.1 (Ф1): СЕРВЕРНЫЙ AI-обзор проекта (GPT, надёжный — не зависит от парсинга README).
+            // Кэш на сервере → обычно мгновенно. Оффлайн/таймаут → тихий fallback на локальный дайджест.
+            try {
+                const aiProj = detectProjectFromWorkDir() || "";
+                if (aiProj && loadSyncConfig()?.token) {
+                    const ad = await dedPanelCall("mcp_digest", { project: aiProj, scope: "all" });
+                    const d = ad && ad.success ? ad.digest : null;
+                    if (d && d.summary) {
+                        output += `# 🤖 AI-обзор проекта (DedPanel)\n\n${d.summary}\n\n`;
+                        if (d.focus)
+                            output += `**🎯 Сейчас:** ${d.focus}\n\n`;
+                        if (Array.isArray(d.phases) && d.phases.length)
+                            output += `**Этапы:**\n${d.phases.map((p) => `- ${p}`).join("\n")}\n\n`;
+                        if (Array.isArray(d.stack) && d.stack.length)
+                            output += `**Стек:** ${d.stack.join(", ")}\n\n`;
+                        output += `---\n\n`;
+                    }
+                }
+            }
+            catch { /* оффлайн/не сгенерилось — локальный дайджест ниже */ }
             // v3.0: ДАЙДЖЕСТ ПЕРВЫМ когда есть
             if (hasDigest) {
-                output += `<claude-instruction>Дайджест содержит полный контекст проекта. Начинай работу сразу без дополнительных вопросов.</claude-instruction>\n\n`;
+                output += `<claude-instruction>ОБЯЗАТЕЛЬНО: Project Digest загружен! В своём ответе пользователю ты ДОЛЖЕН:\n1. Сказать что загружен Project Digest с полной историей проекта (укажи сколько контекстов в дайджесте и период работы из statistics)\n2. Кратко описать проект на основе 00-overview.md (2-3 предложения о сути проекта)\n3. Показать последние 3-5 задач из 01-timeline.md в виде таблицы (БЕЗ колонки статуса — понятия «выполнено/в работе/застряло» в системе НЕТ)\n4. НЕ упоминай «статусы», «незавершённые/in_progress», «незакрытые хвосты», «застряло» — этого понятия больше нет, не выдумывай его\n5. НЕ задавать вопросов "что делаем?" — вместо этого предложи продолжить по последним задачам\nЭто КРИТИЧЕСКИ важно — пользователь должен ВИДЕТЬ что дайджест работает и Claude знает историю проекта!</claude-instruction>\n\n`;
                 const digestPath = getDigestPath();
                 const digestFiles = ["00-overview.md", "01-timeline.md", "02-architecture.md", "03-decisions.md", "04-solutions.md"];
                 for (const fileName of digestFiles) {
@@ -3687,503 +4100,13 @@ MD_HISTORY/
             return { content: [{ type: "text", text: output }] };
         }
         // ==================== CONTEXT_FULL ====================
-        case "context_full": {
-            state.isInitialized = true;
-            const contexts = listContexts();
-            const stats = getStatistics();
-            const workDir = getWorkingDir();
-            if (contexts.length === 0) {
-                return { content: [{ type: "text", text: "📭 Нет сохранённых контекстов" }] };
-            }
-            let output = `# 📚 Все контексты — Dedsession v${CONFIG.VERSION}\n\n`;
-            output += `📁 **Рабочая директория:** \`${workDir}\`\n`;
-            output += `📊 **Статистика:** Всего ${stats.total} | ✅ ${stats.completed} | ⏳ ${stats.inProgress}\n`;
-            output += `📦 **Загружено контекстов:** ${contexts.length}\n\n`;
-            // v2.1: Правила показываются ПЕРВЫМИ
-            output += formatRulesBlock();
-            output += `---\n\n`;
-            // Загружаем и выводим все файлы каждого контекста
-            for (const ctx of contexts) {
-                const result = loadContext(ctx.name);
-                if (!result.success)
-                    continue;
-                output += `# 📁 Контекст #${String(ctx.number).padStart(3, "0")}: ${ctx.title}\n\n`;
-                output += `📅 **Дата:** ${ctx.date} | **Статус:** ${ctx.status} | **Файлов:** ${ctx.filesCount}\n`;
-                if (ctx.hasParent)
-                    output += `🔗 **Parent:** ${ctx.hasParent}\n`;
-                if (ctx.hasChild)
-                    output += `🔗 **Child:** ${ctx.hasChild}\n`;
-                output += `\n---\n\n`;
-                // Выводим все файлы контекста
-                const fileOrder = ["README.md", "01-task-overview.md", "02-analysis.md", "03-changes.md", "04-summary.md", "05-session-log.md", "06-code-snippets.md", "07-decisions.md", "08-problems-solutions.md"];
-                for (const fileName of fileOrder) {
-                    if (result.files[fileName]) {
-                        output += `## 📄 ${fileName}\n\n${result.files[fileName]}\n\n---\n\n`;
-                    }
-                }
-                // Дополнительные файлы которых нет в списке
-                for (const [fileName, content] of Object.entries(result.files)) {
-                    if (!fileOrder.includes(fileName)) {
-                        output += `## 📄 ${fileName}\n\n${content}\n\n---\n\n`;
-                    }
-                }
-                output += `\n${"=".repeat(80)}\n\n`;
-            }
-            output += `\n💡 Загружено ${contexts.length} контекстов. Продолжаем работу?`;
-            return { content: [{ type: "text", text: output }] };
-        }
-        // ==================== CONTEXT_TO_HISTORY ====================
-        case "context_to_history": {
-            const contexts = listContexts();
-            const historyPath = path.join(getMdHistoryPath(), "HISTORY.md");
-            if (contexts.length === 0) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `⚠️ **Контексты не найдены**\n\nСначала сохрани хотя бы один контекст.`
-                        }]
-                };
-            }
-            // Читаем README.md каждого контекста
-            let output = `# 🔄 Миграция контекстов в HISTORY.md\n\n`;
-            output += `📁 **Найдено контекстов:** ${contexts.length}\n`;
-            output += `📄 **Путь для записи:** \`${historyPath}\`\n\n`;
-            output += `---\n\n`;
-            output += `## 📚 README всех контекстов\n\n`;
-            output += `Claude, проанализируй каждый контекст и сформируй качественную сводку.\n\n`;
-            for (const ctx of contexts) {
-                const readmePath = path.join(ctx.path, "README.md");
-                output += `---\n\n`;
-                output += `### #${String(ctx.number).padStart(3, "0")} | ${ctx.date} | ${ctx.name} | ${ctx.status}\n\n`;
-                if (fs.existsSync(readmePath)) {
-                    try {
-                        const readme = fs.readFileSync(readmePath, "utf-8");
-                        // Ограничиваем размер README чтобы не перегрузить контекст
-                        const truncated = readme.slice(0, 2000);
-                        output += truncated;
-                        if (readme.length > 2000) {
-                            output += `\n\n... (обрезано, полный файл: ${Math.round(readme.length / 1024)}KB)`;
-                        }
-                    }
-                    catch {
-                        output += `*Ошибка чтения README.md*`;
-                    }
-                }
-                else {
-                    output += `*README.md не найден*`;
-                }
-                output += `\n\n`;
-            }
-            output += `---\n\n`;
-            output += `## 🎯 Инструкции для Claude\n\n`;
-            output += `Сформируй HISTORY.md со следующей структурой:\n\n`;
-            output += `\`\`\`markdown\n`;
-            output += `# 📜 Dedsession History\n\n`;
-            output += `> Индекс всех контекстов. Обновлено: YYYY-MM-DD HH:MM\n\n`;
-            output += `---\n`;
-            output += `#001 | дата | название | статус\n`;
-            output += `**Качественная сводка 2-4 предложения:** что делали, какую проблему решали, что получилось.\n`;
-            output += `**Файлы:** список ключевых изменённых файлов\n\n`;
-            output += `---\n`;
-            output += `#002 | ...\n`;
-            output += `\`\`\`\n\n`;
-            output += `**Требования к сводкам:**\n`;
-            output += `- 2-4 предложения с СУТЬЮ задачи (не "Дата: ..." а реальное описание)\n`;
-            output += `- Что конкретно сделано, какой результат\n`;
-            output += `- Ключевые файлы которые менялись\n\n`;
-            output += `После формирования вызови \`context_history_write\` с готовым контентом.`;
-            return { content: [{ type: "text", text: output }] };
-        }
-        // ==================== CONTEXT_HISTORY_WRITE ====================
-        case "context_history_write": {
-            const content = args?.content;
-            if (!content) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `⚠️ **Не передан контент для записи**\n\nСначала вызови \`context_to_history\` и сформируй сводки.`
-                        }]
-                };
-            }
-            const historyPath = path.join(getMdHistoryPath(), "HISTORY.md");
-            try {
-                fs.writeFileSync(historyPath, content, "utf-8");
-                return {
-                    content: [{
-                            type: "text",
-                            text: `✅ **HISTORY.md записан успешно**\n\n📄 Путь: \`${historyPath}\`\n📊 Размер: ${Math.round(content.length / 1024)}KB\n\n💡 Теперь при загрузке контекстов Claude будет видеть этот индекс.`
-                        }]
-                };
-            }
-            catch (err) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `❌ **Ошибка записи HISTORY.md**\n\n${err}`
-                        }]
-                };
-            }
-        }
-        // ==================== CONTEXT_RELATED ====================
-        case "context_related": {
-            const query = args?.query;
-            if (!query) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `⚠️ **Не указан запрос для поиска**
-
-Пример использования:
-- "найди контекст про авторизацию"
-- "подгрузи связанный с iOS подписками"
-- "контекст про рефакторинг API"`
-                        }]
-                };
-            }
-            const history = readHistory();
-            if (!history) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `⚠️ **HISTORY.md не найден**
-
-Для работы умного поиска нужен индекс контекстов.
-
-Выполни команду \`context_to_history\` для создания индекса.`
-                        }]
-                };
-            }
-            // Возвращаем HISTORY.md + инструкции для Claude
-            let output = `# 🔍 Поиск контекстов: "${query}"\n\n`;
-            output += `---\n\n`;
-            output += `## 📜 HISTORY.md — Индекс всех контекстов\n\n`;
-            output += history;
-            output += `\n\n---\n\n`;
-            output += `## 🎯 Инструкции для Claude\n\n`;
-            output += `Проанализируй HISTORY.md и найди **3-5 контекстов**, наиболее релевантных запросу "${query}".\n\n`;
-            output += `После анализа:\n`;
-            output += `1. Объясни какие контексты подходят и почему\n`;
-            output += `2. Вызови \`context_load\` для каждого релевантного контекста\n`;
-            output += `3. Объедини информацию из загруженных контекстов\n`;
-            return { content: [{ type: "text", text: output }] };
-        }
-        // ==================== MEMORY v2.0 HANDLERS ====================
-        // ==================== CONTEXT_PROJECT ====================
-        case "context_project": {
-            const projectName = args?.project?.toLowerCase();
-            if (!projectName) {
-                const projects = loadProjects();
-                const projectList = Object.entries(projects.projects)
-                    .map(([name, p]) => `- **${name}**: ${p.count} контекстов (hot: ${p.hotContexts.length})`)
-                    .join("\n");
-                return {
-                    content: [{
-                            type: "text",
-                            text: `# 📁 Доступные проекты\n\n${projectList || "Проекты не найдены. Выполни `context_migrate` для индексации."}\n\n**Использование:** \`context_project ios\``
-                        }]
-                };
-            }
-            const contexts = getContextsByProject(projectName);
-            if (contexts.length === 0) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `⚠️ Проект "${projectName}" не найден или пуст.\n\nДоступные проекты: ios, windows, android, scripts, dedsession, web\n\nПопробуй выполнить \`context_migrate\` для индексации.`
-                        }]
-                };
-            }
-            const grouped = { hot: [], warm: [], cold: [], archive: [] };
-            for (const ctx of contexts) {
-                grouped[ctx.temperature].push(ctx);
-            }
-            let output = `# 📁 Проект: ${projectName}\n\n`;
-            output += `📊 Всего контекстов: ${contexts.length}\n\n`;
-            const tempEmojis = { hot: "🔥", warm: "♨️", cold: "❄️", archive: "📦" };
-            for (const temp of ["hot", "warm", "cold", "archive"]) {
-                if (grouped[temp].length > 0) {
-                    output += `## ${tempEmojis[temp]} ${temp.toUpperCase()} (${grouped[temp].length})\n\n`;
-                    output += `| # | Название | Дата | Статус |\n|---|----------|------|--------|\n`;
-                    for (const ctx of grouped[temp]) {
-                        output += `| ${ctx.id} | ${ctx.name} | ${ctx.date} | ${ctx.status} |\n`;
-                    }
-                    output += "\n";
-                }
-            }
-            return { content: [{ type: "text", text: output }] };
-        }
-        // ==================== CONTEXT_EPIC ====================
-        case "context_epic": {
-            const epicName = args?.epic;
-            if (!epicName) {
-                const epics = loadEpics();
-                const epicList = Object.entries(epics.epics)
-                    .map(([name, e]) => `- **${name}**: ${e.chain.length} контекстов (${e.status})`)
-                    .join("\n");
-                return {
-                    content: [{
-                            type: "text",
-                            text: `# 🔗 Эпики\n\n${epicList || "Эпики не найдены."}\n\n**Использование:** \`context_epic cloudpayments\``
-                        }]
-                };
-            }
-            const contexts = getContextsByEpic(epicName);
-            const epics = loadEpics();
-            const epic = epics.epics[epicName];
-            if (!epic) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `⚠️ Эпик "${epicName}" не найден.`
-                        }]
-                };
-            }
-            let output = `# 🔗 Эпик: ${epicName}\n\n`;
-            output += `📊 Статус: ${epic.status === "completed" ? "✅ Завершён" : "⏳ В процессе"}\n`;
-            output += `📦 Контекстов в цепочке: ${epic.chain.length}\n\n`;
-            if (epic.description) {
-                output += `📝 ${epic.description}\n\n`;
-            }
-            output += `## 📜 Цепочка контекстов\n\n`;
-            output += `| # | Название | Дата | Статус |\n|---|----------|------|--------|\n`;
-            for (const ctx of contexts) {
-                output += `| ${ctx.id} | ${ctx.name} | ${ctx.date} | ${ctx.status} |\n`;
-            }
-            if (epic.keyDecisions && epic.keyDecisions.length > 0) {
-                output += `\n## 🎯 Ключевые решения\n\n`;
-                for (const decision of epic.keyDecisions) {
-                    output += `- ${decision}\n`;
-                }
-            }
-            if (epic.remaining && epic.remaining.length > 0) {
-                output += `\n## ⏳ Что осталось\n\n`;
-                for (const item of epic.remaining) {
-                    output += `- ${item}\n`;
-                }
-            }
-            return { content: [{ type: "text", text: output }] };
-        }
-        // ==================== CONTEXT_SEARCH ====================
-        case "context_search": {
-            const query = args?.query;
-            if (!query) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `⚠️ Укажи поисковый запрос.\n\n**Примеры:**\n- \`context_search typescript\`\n- \`context_search index.ts\`\n- \`context_search авторизация\``
-                        }]
-                };
-            }
-            const results = searchByKeywords(query);
-            if (results.length === 0) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `🔎 По запросу "${query}" ничего не найдено.\n\nПопробуй другие ключевые слова или выполни \`context_migrate\` для обновления индекса.`
-                        }]
-                };
-            }
-            let output = `# 🔎 Результаты поиска: "${query}"\n\n`;
-            output += `Найдено: ${results.length} контекстов\n\n`;
-            output += `| # | Название | Проект | Дата | Теги |\n|---|----------|--------|------|------|\n`;
-            for (const ctx of results) {
-                const tags = ctx.keywords.slice(0, 3).join(", ");
-                output += `| ${ctx.id} | ${ctx.name} | ${ctx.project || "-"} | ${ctx.date} | ${tags} |\n`;
-            }
-            output += `\n💡 Используй \`context_load <номер>\` для загрузки контекста.`;
-            return { content: [{ type: "text", text: output }] };
-        }
-        // ==================== CONTEXT_SIMILAR ====================
-        case "context_similar": {
-            const contextId = args?.context_id;
-            if (!contextId) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `⚠️ Укажи ID контекста.\n\n**Пример:** \`context_similar 025\``
-                        }]
-                };
-            }
-            const paddedId = contextId.padStart(3, "0");
-            const similar = findSimilarContexts(paddedId);
-            const memoryIndex = loadMemoryIndex();
-            const sourceCtx = memoryIndex.contexts[paddedId];
-            if (!sourceCtx) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `⚠️ Контекст "${contextId}" не найден в индексе.\n\nВыполни \`context_migrate\` для индексации.`
-                        }]
-                };
-            }
-            let output = `# 🔄 Похожие на: ${sourceCtx.name}\n\n`;
-            output += `📁 Проект: ${sourceCtx.project || "-"}\n`;
-            output += `🔗 Эпик: ${sourceCtx.epic || "-"}\n`;
-            output += `🏷️ Теги: ${sourceCtx.keywords.slice(0, 5).join(", ")}\n\n`;
-            if (similar.length === 0) {
-                output += `Похожих контекстов не найдено.`;
-            }
-            else {
-                output += `## 📋 Похожие контексты\n\n`;
-                output += `| # | Название | Проект | Общее |\n|---|----------|--------|-------|\n`;
-                for (const ctx of similar) {
-                    const common = [];
-                    if (ctx.project === sourceCtx.project)
-                        common.push("проект");
-                    if (ctx.epic === sourceCtx.epic)
-                        common.push("эпик");
-                    const commonKw = ctx.keywords.filter(k => sourceCtx.keywords.includes(k)).length;
-                    if (commonKw > 0)
-                        common.push(`${commonKw} тегов`);
-                    output += `| ${ctx.id} | ${ctx.name} | ${ctx.project || "-"} | ${common.join(", ")} |\n`;
-                }
-            }
-            return { content: [{ type: "text", text: output }] };
-        }
-        // ==================== CONTEXT_CONTINUE ====================
-        case "context_continue": {
-            const unfinishedEpics = getUnfinishedEpics();
-            const memoryIndex = loadMemoryIndex();
-            // Ищем контексты в статусе in_progress
-            const inProgressContexts = Object.values(memoryIndex.contexts)
-                .filter(ctx => ctx.status.includes("⏳") || ctx.status === "in_progress")
-                .sort((a, b) => b.date.localeCompare(a.date))
-                .slice(0, 10);
-            let output = `# ▶️ Незавершённые задачи\n\n`;
-            if (unfinishedEpics.length > 0) {
-                output += `## 🔗 Эпики в процессе\n\n`;
-                for (const { name, epic, lastContext } of unfinishedEpics) {
-                    output += `### ${name}\n`;
-                    output += `- Контекстов: ${epic.chain.length}\n`;
-                    if (lastContext) {
-                        output += `- Последний: #${lastContext.id} - ${lastContext.name} (${lastContext.date})\n`;
-                    }
-                    if (epic.remaining && epic.remaining.length > 0) {
-                        output += `- Осталось:\n`;
-                        for (const item of epic.remaining) {
-                            output += `  - ${item}\n`;
-                        }
-                    }
-                    output += "\n";
-                }
-            }
-            if (inProgressContexts.length > 0) {
-                output += `## ⏳ Контексты in_progress\n\n`;
-                output += `| # | Название | Проект | Дата |\n|---|----------|--------|------|\n`;
-                for (const ctx of inProgressContexts) {
-                    output += `| ${ctx.id} | ${ctx.name} | ${ctx.project || "-"} | ${ctx.date} |\n`;
-                }
-                output += "\n";
-            }
-            if (unfinishedEpics.length === 0 && inProgressContexts.length === 0) {
-                output += `✅ Все задачи завершены! Нет незавершённых эпиков или контекстов.`;
-            }
-            else {
-                output += `💡 Используй \`context_load <номер>\` для продолжения работы.`;
-            }
-            return { content: [{ type: "text", text: output }] };
-        }
-        // ==================== CONTEXT_SOLUTIONS ====================
-        case "context_solutions": {
-            const query = args?.query;
-            const solutions = loadSolutions();
-            let filtered = solutions.solutions;
-            if (query) {
-                const lowerQuery = query.toLowerCase();
-                filtered = solutions.solutions.filter(s => s.problem.toLowerCase().includes(lowerQuery) ||
-                    s.solution.some(sol => sol.toLowerCase().includes(lowerQuery)));
-            }
-            if (filtered.length === 0) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `# 💡 Решения\n\n${query ? `По запросу "${query}" ничего не найдено.` : "База решений пуста."}\n\n💡 Решения автоматически извлекаются из контекстов с секцией "problems_solutions".`
-                        }]
-                };
-            }
-            let output = `# 💡 Решения${query ? ` по запросу "${query}"` : ""}\n\n`;
-            output += `Найдено: ${filtered.length} решений\n\n`;
-            for (const sol of filtered.slice(0, 10)) {
-                output += `## 🔧 ${sol.problem}\n\n`;
-                output += `**Решение:**\n`;
-                for (const step of sol.solution) {
-                    output += `- ${step}\n`;
-                }
-                if (sol.codeExample) {
-                    output += `\n\`\`\`\n${sol.codeExample}\n\`\`\`\n`;
-                }
-                output += `\n📚 Источник: ${sol.sourceContexts.join(", ")}\n\n---\n\n`;
-            }
-            return { content: [{ type: "text", text: output }] };
-        }
-        // ==================== CONTEXT_MEMORY ====================
-        case "context_memory": {
-            const stats = getMemoryStats();
-            const memoryIndex = loadMemoryIndex();
-            let output = `# 🧠 Memory System v2.0\n\n`;
-            output += `📊 **Статистика:**\n\n`;
-            output += `| Показатель | Значение |\n|------------|----------|\n`;
-            output += `| Всего контекстов | ${stats.totalContexts} |\n`;
-            output += `| Эпиков в процессе | ${stats.epicsInProgress} |\n`;
-            output += `| Решений в базе | ${stats.solutionsCount} |\n\n`;
-            output += `## 🌡️ Температуры\n\n`;
-            output += `| Статус | Количество |\n|--------|------------|\n`;
-            output += `| 🔥 Hot (3 дня) | ${stats.temperatures.hot} |\n`;
-            output += `| ♨️ Warm (14 дней) | ${stats.temperatures.warm} |\n`;
-            output += `| ❄️ Cold (60 дней) | ${stats.temperatures.cold} |\n`;
-            output += `| 📦 Archive (>60 дней) | ${stats.temperatures.archive} |\n\n`;
-            if (Object.keys(stats.projects).length > 0) {
-                output += `## 📁 Проекты\n\n`;
-                output += `| Проект | Контекстов |\n|--------|------------|\n`;
-                for (const [name, count] of Object.entries(stats.projects).sort((a, b) => b[1] - a[1])) {
-                    output += `| ${name} | ${count} |\n`;
-                }
-                output += "\n";
-            }
-            output += `📅 Последняя миграция: ${memoryIndex.lastMigration || "никогда"}\n`;
-            return { content: [{ type: "text", text: output }] };
-        }
-        // ==================== CONTEXT_MIGRATE ====================
-        case "context_migrate": {
-            const result = migrateToMemorySystem();
-            let output = `# 🔄 Миграция в Memory v2.0\n\n`;
-            if (result.success) {
-                output += `✅ **Миграция успешна!**\n\n`;
-                output += `📊 Результаты:\n`;
-                output += `- Проиндексировано контекстов: ${result.migrated}\n`;
-                output += `- Обнаружено проектов: ${result.projects.length} (${result.projects.join(", ") || "-"})\n`;
-                output += `- Эпиков: ${result.epics.length}\n`;
-                output += `- 💡 Извлечено решений: ${result.solutions}\n\n`;
-                const stats = getMemoryStats();
-                output += `## 🌡️ Распределение по температуре\n\n`;
-                output += `- 🔥 Hot: ${stats.temperatures.hot}\n`;
-                output += `- ♨️ Warm: ${stats.temperatures.warm}\n`;
-                output += `- ❄️ Cold: ${stats.temperatures.cold}\n`;
-                output += `- 📦 Archive: ${stats.temperatures.archive}\n\n`;
-                output += `💡 Теперь доступны команды:\n`;
-                output += `- \`context_project ios\` — контексты по проекту\n`;
-                output += `- \`context_search query\` — полнотекстовый поиск\n`;
-                output += `- \`context_similar 025\` — похожие контексты\n`;
-                output += `- \`context_continue\` — незавершённые задачи\n`;
-            }
-            else {
-                output += `❌ **Ошибка миграции**\n\n`;
-                output += `Проиндексировано: ${result.migrated}\n\n`;
-                if (result.errors.length > 0) {
-                    output += `Ошибки:\n`;
-                    for (const err of result.errors.slice(0, 10)) {
-                        output += `- ${err}\n`;
-                    }
-                }
-            }
-            return { content: [{ type: "text", text: output }] };
-        }
-        // ==================== 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 ruleTitle = (args.title || "").trim().slice(0, 80); // v4.4.0 блок C
             const isGlobal = scope === "global";
             const rulesIndex = isGlobal ? loadGlobalRules() : loadRules();
             const scopeLabel = isGlobal ? "🌍 Глобальное" : "📁 Локальное";
@@ -4206,12 +4129,15 @@ MD_HISTORY/
                     const newRule = {
                         id: newId,
                         rule: ruleText,
-                        created: new Date().toISOString().split("T")[0],
+                        ...(ruleTitle ? { title: ruleTitle } : {}), // v4.4.0 блок C: короткий заголовок
+                        created: new Date().toISOString(), // v4.2: с временем (для merge между устройствами)
                         context: ruleContext,
+                        ...(isGlobal ? { hash: ruleHash(ruleText), device: getDeviceName() } : {}),
                     };
                     rulesIndex.rules.push(newRule);
                     if (isGlobal) {
                         saveGlobalRules(rulesIndex);
+                        pushGlobalRulesInBackground(); // v4.2: merge-синк (union по тексту, без потерь между устройствами)
                     }
                     else {
                         saveRules(rulesIndex);
@@ -4247,11 +4173,18 @@ MD_HISTORY/
                                 }]
                         };
                     }
-                    const removed = rulesIndex.rules.splice(ruleIndex, 1)[0];
+                    const removed = rulesIndex.rules[ruleIndex];
                     if (isGlobal) {
+                        // v4.2: tombstone (не splice) — удаление доезжает на другие устройства через merge, не воскресает
+                        removed.deleted = true;
+                        removed.created = new Date().toISOString(); // обновляем время — tombstone выигрывает при merge
+                        if (!removed.hash)
+                            removed.hash = ruleHash(removed.rule);
                         saveGlobalRules(rulesIndex);
+                        pushGlobalRulesInBackground();
                     }
                     else {
+                        rulesIndex.rules.splice(ruleIndex, 1);
                         saveRules(rulesIndex);
                     }
                     let output = `# ✅ ${scopeLabel} правило удалено\n\n`;
@@ -4286,415 +4219,6 @@ MD_HISTORY/
             }
         }
         // ========== PROJECT DIGEST v3.0 HANDLERS ==========
-        case "context_digest": {
-            const digestPath = getDigestPath();
-            if (!fs.existsSync(path.join(digestPath, "digest.json"))) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `📦 **Дайджест не найден**\n\nПапка \`_DIGEST/\` пуста или не существует.\n\n**Создайте дайджест:**\n- Скажите "миграция дайджеста" или "digest migrate"\n- Или просто сохраните контекст — дайджест создастся автоматически`,
-                        }],
-                };
-            }
-            let output = `# 📦 Project Digest\n\n`;
-            const digestFiles = ["00-overview.md", "01-timeline.md", "02-architecture.md", "03-decisions.md", "04-solutions.md"];
-            for (const fileName of digestFiles) {
-                const filePath = path.join(digestPath, fileName);
-                if (fs.existsSync(filePath)) {
-                    const content = fs.readFileSync(filePath, "utf-8");
-                    output += content + "\n\n---\n\n";
-                }
-            }
-            return { content: [{ type: "text", text: output }] };
-        }
-        case "context_digest_migrate": {
-            const allContexts = listContexts();
-            const memoryIndex = loadMemoryIndex();
-            const solutionsIdx = loadSolutions();
-            const keywordsIdx = loadKeywords();
-            const projectName = detectProjectFromWorkDir() || "unknown";
-            const digest = createEmptyDigest(projectName);
-            // Сканируем все контексты
-            for (const ctx of allContexts) {
-                const contextId = String(ctx.number).padStart(3, "0");
-                // Читаем README
-                let summary = "";
-                const readmePath = path.join(ctx.path, "README.md");
-                if (fs.existsSync(readmePath)) {
-                    const readme = fs.readFileSync(readmePath, "utf-8");
-                    const descMatch = readme.match(/## Краткое описание\n\n([^\n#]+)/);
-                    summary = descMatch ? descMatch[1].trim() : readme.split("\n").slice(0, 3).join(" ").slice(0, 200);
-                }
-                // Читаем 03-changes.md для файлов
-                let keyChanges = [];
-                const changesPath = path.join(ctx.path, "03-changes.md");
-                if (fs.existsSync(changesPath)) {
-                    const changesContent = fs.readFileSync(changesPath, "utf-8");
-                    keyChanges = extractKeyChangesFromText(changesContent);
-                    const files = extractFilesFromChanges(changesContent);
-                    for (const f of files) {
-                        if (!digest.currentState.keyFiles.includes(f)) {
-                            digest.currentState.keyFiles.push(f);
-                        }
-                    }
-                }
-                // Статистика
-                digest.statistics.totalContexts++;
-                if (ctx.status.includes("✅"))
-                    digest.statistics.completed++;
-                else if (ctx.status.includes("⏳"))
-                    digest.statistics.inProgress++;
-                else if (ctx.status.includes("❌"))
-                    digest.statistics.blocked++;
-                if (!digest.statistics.firstDate || ctx.date < digest.statistics.firstDate) {
-                    digest.statistics.firstDate = ctx.date;
-                }
-                if (!digest.statistics.lastDate || ctx.date > digest.statistics.lastDate) {
-                    digest.statistics.lastDate = ctx.date;
-                }
-                // recentTasks (последние 30)
-                digest.recentTasks.push({
-                    contextId,
-                    date: ctx.date,
-                    name: ctx.title,
-                    status: ctx.status,
-                    summary: summary.slice(0, 200),
-                    keyChanges,
-                });
-            }
-            // Сортируем по номеру (новые первые) и обрезаем
-            digest.recentTasks.sort((a, b) => parseInt(b.contextId) - parseInt(a.contextId));
-            digest.recentTasks = digest.recentTasks.slice(0, 30);
-            // Лимит keyFiles
-            digest.currentState.keyFiles = digest.currentState.keyFiles.slice(0, 30);
-            // techStack из keywords
-            const techKeywords = ["typescript", "javascript", "python", "swift", "kotlin", "react", "vue", "node", "mcp", "trello", "obsidian"];
-            for (const [kw] of Object.entries(keywordsIdx.keywords)) {
-                if (techKeywords.includes(kw.toLowerCase())) {
-                    digest.currentState.techStack.push(kw);
-                }
-            }
-            // solutions из solutions.json
-            for (const sol of solutionsIdx.solutions.slice(0, 20)) {
-                digest.solutions.push({
-                    problem: sol.problem,
-                    solution: sol.solution.join("; "),
-                    contextId: sol.sourceContexts[0] || "?",
-                });
-            }
-            // Фазы — группировка по месяцам
-            const monthMap = new Map();
-            for (const task of digest.recentTasks) {
-                const month = task.date.slice(0, 7); // YYYY-MM
-                if (!monthMap.has(month)) {
-                    monthMap.set(month, { count: 0, tasks: [] });
-                }
-                const m = monthMap.get(month);
-                m.count++;
-                if (m.tasks.length < 3)
-                    m.tasks.push(task.name);
-            }
-            for (const [month, data] of monthMap) {
-                digest.phases.push({
-                    name: month,
-                    dateRange: month,
-                    description: `${data.count} задач: ${data.tasks.join(", ")}${data.count > 3 ? " и др." : ""}`,
-                });
-            }
-            // activeEpics из memory
-            const epics = loadEpics();
-            for (const [name, epic] of Object.entries(epics.epics)) {
-                if (epic.status === "in_progress") {
-                    digest.currentState.activeEpics.push(name);
-                }
-            }
-            // Сохраняем
-            saveDigest(digest);
-            let output = `✅ **Дайджест создан!**\n\n`;
-            output += `📦 **Проект:** ${projectName}\n`;
-            output += `📊 **Контекстов обработано:** ${allContexts.length}\n`;
-            output += `📁 **Путь:** \`${getDigestPath()}\`\n\n`;
-            output += `**Создано файлов:**\n`;
-            output += `- 00-overview.md\n- 01-timeline.md\n- 02-architecture.md\n- 03-decisions.md\n- 04-solutions.md\n- digest.json\n\n`;
-            output += `---\n\n`;
-            output += `💡 **Следующий шаг:** скажите "обнови дайджест" (refresh) — Claude проанализирует и добавит качественное описание проекта, фазы эволюции и т.д.\n\n`;
-            output += `📦 Дайджест будет автоматически обновляться при каждом \`context_save\`.`;
-            return { content: [{ type: "text", text: output }] };
-        }
-        case "context_digest_refresh": {
-            const digest = loadDigest();
-            if (!digest) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: `📦 **Дайджест не найден**\n\nСначала создайте дайджест: "миграция дайджеста" или "digest migrate"`,
-                        }],
-                };
-            }
-            // Собираем README последних 10 контекстов
-            const contexts = listContexts().slice(0, 10);
-            let readmes = "";
-            for (const ctx of contexts) {
-                const readmePath = path.join(ctx.path, "README.md");
-                if (fs.existsSync(readmePath)) {
-                    readmes += `\n---\n### #${String(ctx.number).padStart(3, "0")} | ${ctx.date} | ${ctx.title} | ${ctx.status}\n\n`;
-                    const content = fs.readFileSync(readmePath, "utf-8");
-                    readmes += content.slice(0, 1500) + "\n";
-                }
-            }
-            let output = `# 🔄 Refresh дайджеста\n\n`;
-            output += `## Текущий digest.json:\n\n`;
-            output += `\`\`\`json\n${JSON.stringify(digest, null, 2)}\n\`\`\`\n\n`;
-            output += `---\n\n`;
-            output += `## README последних 10 контекстов:\n\n`;
-            output += readmes;
-            output += `\n\n---\n\n`;
-            output += `<claude-instruction>\n`;
-            output += `Проанализируй digest.json и README контекстов выше.\n`;
-            output += `Затем вызови context_digest_write с параметрами:\n`;
-            output += `- description: описание проекта (3-5 предложений)\n`;
-            output += `- tech_stack: стек через запятую\n`;
-            output += `- key_files: ключевые файлы через запятую\n`;
-            output += `- phases: фазы эволюции (Название | даты | описание на каждой строке)\n`;
-            output += `- key_decisions: ключевые решения\n`;
-            output += `- known_issues: текущие проблемы\n`;
-            output += `- active_epics: активные эпики\n`;
-            output += `</claude-instruction>`;
-            return { content: [{ type: "text", text: output }] };
-        }
-        case "context_digest_write": {
-            let digest = loadDigest();
-            if (!digest) {
-                const projectName = detectProjectFromWorkDir() || "unknown";
-                digest = createEmptyDigest(projectName);
-            }
-            // Обновляем currentState
-            if (args?.description) {
-                digest.currentState.description = args.description;
-            }
-            if (args?.tech_stack) {
-                digest.currentState.techStack = args.tech_stack.split(",").map(s => s.trim()).filter(Boolean);
-            }
-            if (args?.key_files) {
-                digest.currentState.keyFiles = args.key_files.split(",").map(s => s.trim()).filter(Boolean);
-            }
-            if (args?.active_epics) {
-                digest.currentState.activeEpics = args.active_epics.split(",").map(s => s.trim()).filter(Boolean);
-            }
-            // Обновляем known_issues
-            if (args?.known_issues) {
-                digest.knownIssues = args.known_issues.split("\n").map(s => s.trim()).filter(Boolean).slice(0, 10);
-            }
-            // Обновляем phases
-            if (args?.phases) {
-                const phaseLines = args.phases.split("\n").filter(l => l.trim());
-                digest.phases = phaseLines.map(line => {
-                    const parts = line.split("|").map(p => p.trim());
-                    return {
-                        name: parts[0] || "Phase",
-                        dateRange: parts[1] || "",
-                        description: parts[2] || "",
-                    };
-                });
-            }
-            // Обновляем key_decisions
-            if (args?.key_decisions) {
-                const decLines = args.key_decisions.split("\n").filter(l => l.trim());
-                const today = new Date().toISOString().split("T")[0];
-                digest.keyDecisions = decLines.map(line => ({
-                    decision: line.trim(),
-                    date: today,
-                    contextId: "refresh",
-                })).slice(0, 20);
-            }
-            digest.lastUpdated = new Date().toISOString().split("T")[0];
-            // Сохраняем и перерендериваем
-            saveDigest(digest);
-            return {
-                content: [{
-                        type: "text",
-                        text: `✅ **Дайджест обновлён!**\n\n📦 Проект: **${digest.project}**\n📝 Описание: ${(digest.currentState.description || "").slice(0, 100)}...\n🔧 Стек: ${digest.currentState.techStack.join(", ") || "-"}\n📁 Файлов: ${digest.currentState.keyFiles.length}\n\nВсе 5 MD файлов перерендерены. Проверьте: "дайджест" или "digest"`,
-                    }],
-            };
-        }
-        // ========== ТЕСТОВЫЕ 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 = formatRulesBlock();
-            output += `# 🧠 Smart Context — Обзор ${entries.length} контекстов\n\n`;
-            // По проектам (основной акцент — задачи с кодом)
-            const projectsWithData = Object.entries(byProject).filter(([p]) => p !== "unknown");
-            if (projectsWithData.length > 0) {
-                output += `## 📁 По проектам:\n`;
-                for (const [project, list] of projectsWithData) {
-                    const ids = list.slice(0, 5).map(e => `#${e.number}`).join(", ");
-                    const more = list.length > 5 ? ` (+${list.length - 5})` : "";
-                    output += `- **${project}** (${list.length}): ${ids}${more}\n`;
-                }
-            }
-            // По людям (если есть контексты связанные с людьми)
-            const personsWithData = Object.keys(byPerson).filter(p => p !== "other");
-            if (personsWithData.length > 0) {
-                output += `\n## 👥 По людям:\n`;
-                for (const [person, list] of Object.entries(byPerson)) {
-                    if (person !== "other") {
-                        const ids = list.slice(0, 5).map(e => `#${e.number}`).join(", ");
-                        const more = list.length > 5 ? ` (+${list.length - 5})` : "";
-                        output += `- **${person}** (${list.length}): ${ids}${more}\n`;
-                    }
-                }
-            }
-            // Последние 10 с краткими сводками
-            output += `\n## 📋 Последние 10:\n`;
-            output += `| # | Название | Проект | Сводка |\n|---|----------|--------|--------|\n`;
-            for (const entry of entries.slice(0, 10)) {
-                const meta = memoryIndex.contexts[entry.number];
-                const project = meta?.project || "-";
-                const shortSummary = entry.summary.slice(0, 50).replace(/\n/g, " ") + "...";
-                output += `| ${entry.number} | ${entry.name} | ${project} | ${shortSummary} |\n`;
-            }
-            // Генерируем динамические примеры на основе реальных данных
-            output += `\n---\n`;
-            output += `💡 **Опиши задачу** в свободном формате, и я подгружу релевантные контексты:\n`;
-            const examples = [];
-            // Пример с проектом/технологией (основной акцент)
-            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(" ")}"`);
-                }
-            }
-            // Пример с человеком (если есть контексты с людьми)
-            if (personsWithData.length > 0) {
-                const person = personsWithData[0];
-                const personEntry = byPerson[person][0];
-                const keyword = personEntry.name.split("-").find(w => w.length > 3 && !w.includes(person)) || "";
-                examples.push(`"${keyword ? keyword + " " : ""}${person}"`);
-            }
-            // Выводим примеры (максимум 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 = formatRulesBlock();
-            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}` }] };
     }