dsh-desktop-kit 0.0.0-stage → 2.0.0

package/plugins/dsh-project-memory/index.js

@@ -0,0 +1,1240 @@
+/**
+ * dsh-project-memory — Host half.
+ *
+ * Local, user-only long-term memory per project:
+ *  - resolves the project of a Session from its effective working directory,
+ *  - auto-injects a compact dossier digest as dynamic prompt context,
+ *  - exposes the `project_memory` tool for reading / searching / updating the dossier,
+ *  - appends a deterministic JOURNAL entry after every work turn,
+ *  - keeps a freshness marker (git head / last analysis) in the digest,
+ *  - offers a user command `/remember` that asks the agent to deep-dive the project.
+ *
+ * Everything is stored under <DSH_HOME>/projects-memory. Nothing is sent over the network
+ * except the ordinary model prompt that carries the digest.
+ */
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+
+const MEMORY_ROOT = path.join(process.env.DSH_HOME ?? path.join(os.homedir(), ".dsh"), "projects-memory");
+const REGISTRY_FILE = path.join(MEMORY_ROOT, "registry.json");
+const STATE_FILE = path.join(MEMORY_ROOT, "_state.json");
+const ACCESS_LOG = path.join(MEMORY_ROOT, "_access.log");
+const ACCESS_LOG_MAX_LINES = 300;
+const DEFAULT_DIGEST_BUDGET = 2800;
+const SECTION_MAX_BYTES = 60 * 1024;
+const SECTION_NAMES = ["PROJECT", "ARCHITECTURE", "CODE-MAP", "INVARIANTS", "GOTCHAS", "RUNBOOK", "JOURNAL"];
+const SECTION_FILES = {
+  PROJECT: "PROJECT.md",
+  ARCHITECTURE: "ARCHITECTURE.md",
+  "CODE-MAP": "CODE-MAP.md",
+  INVARIANTS: "INVARIANTS.md",
+  GOTCHAS: "GOTCHAS.md",
+  RUNBOOK: "RUNBOOK.md",
+  JOURNAL: "JOURNAL",
+};
+const PROJECT_MARKERS = [".git", "AGENTS.md", "composer.json", "package.json", "artisan", "wp-config.php", "pyproject.toml", "go.mod", "Cargo.toml", "Gemfile", "bitrix"];
+const CURATOR_IDLE_MS = 4 * 60 * 1000;
+const STATE_TTL_MS = 7 * 24 * 3600 * 1000;
+
+export const inject = ["systemPrompt", "tools", "sessions", "workingDirectory"];
+
+/* ------------------------------------------------------------------ */
+/* Small helpers                                                      */
+/* ------------------------------------------------------------------ */
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function localStamp() {
+  const d = new Date();
+  const pad = (value) => String(value).padStart(2, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+
+function monthKey() {
+  const d = new Date();
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}`;
+}
+
+function normalizePath(value) {
+  if (typeof value !== "string" || value.length === 0) return "";
+  let result = path.resolve(value).replaceAll("\\", "/").replace(/\/+$/u, "");
+  if (process.platform === "win32") result = result.toLowerCase();
+  return result;
+}
+
+function isInside(parent, child) {
+  const a = normalizePath(parent);
+  const b = normalizePath(child);
+  return b === a || b.startsWith(`${a}/`);
+}
+
+function slugify(value) {
+  const base = String(value ?? "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9\u0400-\u04ff]+/gu, "-")
+    .replace(/^-+|-+$/gu, "");
+  return base.length > 0 ? base.slice(0, 48) : "project";
+}
+
+function readText(filePath) {
+  try {
+    return fs.readFileSync(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function writeText(filePath, text) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, text, "utf8");
+}
+
+function appendText(filePath, text) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.appendFileSync(filePath, text, "utf8");
+}
+
+function exists(filePath) {
+  try {
+    return fs.existsSync(filePath);
+  } catch {
+    return false;
+  }
+}
+
+/** Strip obvious secrets before any dossier write. */
+function redactSecrets(text) {
+  let result = String(text ?? "");
+  const patterns = [
+    /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/gu,
+    /\bsk-[A-Za-z0-9_-]{16,}\b/gu,
+    /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{20,}\b/gu,
+    /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/gu,
+    /\bAKIA[0-9A-Z]{16}\b/gu,
+    /\b(api[_-]?key|access[_-]?token|secret|password|passwd|pwd)\s*[:=]\s*["']?[^\s"',;]{6,}/giu,
+  ];
+  for (const pattern of patterns) result = result.replace(pattern, "[REDACTED]");
+  return result;
+}
+
+function truncate(text, max) {
+  const value = String(text ?? "");
+  return value.length <= max ? value : `${value.slice(0, Math.max(0, max - 1))}…`;
+}
+
+function logAccess(line) {
+  try {
+    fs.mkdirSync(MEMORY_ROOT, { recursive: true });
+    appendText(ACCESS_LOG, `${nowIso()} ${line}\n`);
+    const content = readText(ACCESS_LOG);
+    const lines = content.split(/\r?\n/u);
+    if (lines.length > ACCESS_LOG_MAX_LINES) {
+      writeText(ACCESS_LOG, `${lines.slice(-ACCESS_LOG_MAX_LINES).join("\n")}\n`);
+    }
+  } catch {
+    /* diagnostics must never break a request */
+  }
+}
+
+/* ------------------------------------------------------------------ */
+/* Registry and state                                                 */
+/* ------------------------------------------------------------------ */
+
+function defaultRegistry() {
+  return {
+    version: 1,
+    settings: {
+      digestBudgetChars: DEFAULT_DIGEST_BUDGET,
+      injectSubagents: false,
+      autoRegister: true,
+      curator: { enabled: true, idleMs: CURATOR_IDLE_MS },
+    },
+    projects: [],
+  };
+}
+
+function loadRegistry() {
+  const fallback = defaultRegistry();
+  try {
+    const raw = fs.readFileSync(REGISTRY_FILE, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || parsed.version !== 1 || !Array.isArray(parsed.projects)) return fallback;
+    return { ...fallback, ...parsed, settings: { ...fallback.settings, ...(parsed.settings ?? {}) } };
+  } catch {
+    return fallback;
+  }
+}
+
+function saveRegistry(registry) {
+  try {
+    writeText(REGISTRY_FILE, `${JSON.stringify(registry, null, 2)}\n`);
+  } catch {
+    /* keep serving from memory */
+  }
+}
+
+function loadState() {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(STATE_FILE, "utf8"));
+    if (parsed && parsed.version === 1 && parsed.sessions && typeof parsed.sessions === "object") return parsed.sessions;
+  } catch {
+    /* first run */
+  }
+  return {};
+}
+
+function saveState(sessions) {
+  try {
+    const cutoff = Date.now() - STATE_TTL_MS;
+    for (const [sessionId, entry] of Object.entries(sessions)) {
+      if (typeof entry?.updatedAt !== "number" || entry.updatedAt < cutoff) delete sessions[sessionId];
+    }
+    writeText(STATE_FILE, `${JSON.stringify({ version: 1, sessions }, null, 2)}\n`);
+  } catch {
+    /* state is only an optimization */
+  }
+}
+
+/* ------------------------------------------------------------------ */
+/* Git freshness                                                      */
+/* ------------------------------------------------------------------ */
+
+function gitInfo(root) {
+  try {
+    const gitDir = path.join(root, ".git");
+    if (!exists(gitDir)) return undefined;
+    const headRaw = readText(path.join(gitDir, "HEAD")).trim();
+    if (headRaw.startsWith("ref: ")) {
+      const ref = headRaw.slice(5).trim();
+      const head = readText(path.join(gitDir, ...ref.split("/"))).trim();
+      return { branch: ref.replace(/^refs\/heads\//u, ""), head: head.slice(0, 12) || "unknown" };
+    }
+    return { branch: "detached", head: headRaw.slice(0, 12) || "unknown" };
+  } catch {
+    return undefined;
+  }
+}
+
+/* ------------------------------------------------------------------ */
+/* Project resolution and dossier creation                            */
+/* ------------------------------------------------------------------ */
+
+function projectPublic(project) {
+  return {
+    slug: project.slug,
+    name: project.name,
+    roots: [...project.roots],
+    dossier: path.join(MEMORY_ROOT, project.slug),
+    legacyDocs: Array.isArray(project.legacyDocs) ? [...project.legacyDocs] : [],
+    createdAt: project.createdAt,
+    updatedAt: project.updatedAt,
+    lastAnalyzedAt: project.lastAnalyzedAt ?? null,
+    lastJournalAt: project.lastJournalAt ?? null,
+    lastGitHead: project.lastGitHead ?? null,
+    confidence: project.confidence ?? "auto",
+  };
+}
+
+function findProject(registry, cwd) {
+  const target = normalizePath(cwd);
+  if (target.length === 0) return undefined;
+  let best;
+  let bestLength = -1;
+  for (const project of registry.projects) {
+    for (const root of project.roots ?? []) {
+      const normalized = normalizePath(root);
+      if (normalized.length === 0) continue;
+      if (isInside(normalized, target) && normalized.length > bestLength) {
+        best = project;
+        bestLength = normalized.length;
+      }
+    }
+  }
+  return best ? projectPublic(best) : undefined;
+}
+
+function detectProjectRoot(cwd) {
+  let current = path.resolve(cwd);
+  const root = path.parse(current).root;
+  for (let depth = 0; depth < 8; depth += 1) {
+    if (PROJECT_MARKERS.some((marker) => exists(path.join(current, marker)))) return current;
+    const parent = path.dirname(current);
+    if (parent === current || current === root) return undefined;
+    current = parent;
+  }
+  return undefined;
+}
+
+function defaultProjectFiles(project) {
+  const roots = project.roots.map((root) => `\`${root}\``).join(", ");
+  const git = gitInfo(project.roots[0]);
+  return {
+    "PROJECT.md": [
+      `# ${project.name}`,
+      "",
+      `- Slug: \`${project.slug}\``,
+      `- Корни: ${roots}`,
+      `- Создано: ${project.createdAt}`,
+      `- Уверенность памяти: ${project.confidence === "auto" ? "низкая (авто-создание, требуется анализ)" : "средняя"}`,
+      "",
+      "## Паспорт",
+      "- Назначение: (не заполнено)",
+      `- Стек: ${project.stack ?? "(не определён)"}`,
+      "- Прод: (не заполнено)",
+      "- Как запускать локально: (не заполнено)",
+      "",
+      "## Статус памяти",
+      `- Последний глубокий анализ: ${project.lastAnalyzedAt ?? "—"}`,
+      `- Git: ${git ? `${git.branch}@${git.head}` : "не git или неизвестно"}`,
+      "",
+      "## Ссылки",
+      ...(project.legacyDocs ?? []).map((doc) => `- ${doc}`),
+      ...(project.legacyDocs?.length ? [] : ["- (нет)"]),
+      "",
+      "<!-- Разделы ЧТО/ЗАЧЕМ/КАК заполняются скиллом project-deep-dive. Не копируйте секреты. -->",
+      "",
+    ].join("\n"),
+    "ARCHITECTURE.md": `# Архитектура — ${project.name}
+
+## Обзор
+(не заполнено)
+
+## Модули и слои
+(не заполнено)
+
+## Потоки данных и интеграции
+(не заполнено)
+
+## Схема данных
+(не заполнено)
+`,
+    "CODE-MAP.md": `# Карта кода — ${project.name}
+
+> Ссылки на файлы и строки вместо копирования кода. Уверенность помечать [проверено]/[выведено]/[устарело].
+
+## Точки входа
+(не заполнено)
+
+## Важные файлы и маршруты
+(не заполнено)
+
+## Соглашения
+(не заполнено)
+`,
+    "INVARIANTS.md": `# Инварианты и запреты — ${project.name}
+
+- (не заполнено) Например: «боевая БД не трогать без бэкапа», «миграции только вперёд», «не менять .env на проде».
+`,
+    "GOTCHAS.md": `# Грабли и решения — ${project.name}
+
+## Шаблон записи
+Симптом: (что видно)
+Причина: (почему так)
+Решение: (что сделали)
+Как обнаружить заранее: (проверка/тест/лог)
+Уверенность: [проверено]
+
+## Записи
+(не заполнено)
+`,
+    "RUNBOOK.md": `# Runbook — ${project.name}
+
+## Локальный запуск
+(не заполнено)
+
+## Тесты
+(не заполнено)
+
+## Сборка / деплой
+(не заполнено)
+
+## Бэкап / откат
+(не заполнено)
+`,
+  };
+}
+
+function ensureProjectDossier(project, options = {}) {
+  const directory = path.join(MEMORY_ROOT, project.slug);
+  try {
+    fs.mkdirSync(path.join(directory, "JOURNAL"), { recursive: true });
+    const files = defaultProjectFiles(project);
+    for (const [name, content] of Object.entries(files)) {
+      const target = path.join(directory, name);
+      if (!exists(target)) writeText(target, content);
+    }
+    const indexTarget = path.join(directory, "INDEX.json");
+    if (!exists(indexTarget)) {
+      writeText(indexTarget, `${JSON.stringify({
+        slug: project.slug,
+        name: project.name,
+        roots: project.roots,
+        generatedAt: nowIso(),
+        sections: Object.keys(files).map((name) => ({ file: name, bytes: fs.statSync(path.join(directory, name)).size })),
+        lastAnalyzedAt: project.lastAnalyzedAt ?? null,
+        lastGitHead: project.lastGitHead ?? null,
+        confidence: project.confidence ?? "auto",
+      }, null, 2)}\n`);
+    }
+    if (options.legacyNote) appendText(path.join(directory, "PROJECT.md"), `\n- Связь с существующей памятью: ${options.legacyNote}\n`);
+    return directory;
+  } catch (error) {
+    throw new Error(`cannot create project dossier: ${String(error)}`);
+  }
+}
+
+function createProject(registry, { name, root, stack, legacyDocs, autoCreated, confidence }) {
+  if (typeof name !== "string" || name.trim().length === 0) throw new Error("project name is required");
+  if (typeof root !== "string" || root.trim().length === 0) throw new Error("project root is required");
+  const resolvedRoot = path.resolve(root);
+  if (!exists(resolvedRoot) || !fs.statSync(resolvedRoot).isDirectory()) throw new Error(`project root does not exist: ${resolvedRoot}`);
+  const existing = registry.projects.find((project) => project.roots.some((entry) => normalizePath(entry) === normalizePath(resolvedRoot)));
+  if (existing) return projectPublic(existing);
+  let slug = slugify(name);
+  let counter = 2;
+  while (registry.projects.some((project) => project.slug === slug) || exists(path.join(MEMORY_ROOT, slug))) {
+    slug = `${slugify(name)}-${counter}`;
+    counter += 1;
+  }
+  const project = {
+    slug,
+    name: name.trim(),
+    roots: [resolvedRoot],
+    legacyDocs: Array.isArray(legacyDocs) ? legacyDocs.slice(0, 20) : [],
+    stack: typeof stack === "string" ? stack.slice(0, 200) : undefined,
+    createdAt: nowIso(),
+    updatedAt: nowIso(),
+    lastAnalyzedAt: null,
+    lastJournalAt: null,
+    lastGitHead: null,
+    confidence: confidence ?? (autoCreated ? "auto" : "manual"),
+    autoCreated: autoCreated === true,
+  };
+  registry.projects.push(project);
+  saveRegistry(registry);
+  ensureProjectDossier(project);
+  logAccess(`project-created slug=${project.slug} root=${resolvedRoot} auto=${project.autoCreated}`);
+  return projectPublic(project);
+}
+
+function resolveProjectForSession(registry, session, settings, options = {}) {
+  if (!session) return undefined;
+  const cwd = options.cwd ?? sessionCwd(session);
+  const known = findProject(registry, cwd);
+  if (known) return known;
+  if (settings.autoRegister !== true) return undefined;
+  const detected = detectProjectRoot(cwd);
+  if (!detected) return undefined;
+  if (isInside(MEMORY_ROOT, detected)) return undefined;
+  const name = path.basename(detected);
+  return createProject(registry, { name, root: detected, autoCreated: true });
+}
+
+function sessionCwd(session) {
+  // Prefer the effective working directory projection; fall back to the durable header.
+  try {
+    const cwd = session.__pmWorkingDirectory;
+    if (typeof cwd === "string" && cwd.length > 0) return cwd;
+  } catch {
+    /* ignore */
+  }
+  return session?.header?.cwd ?? "";
+}
+
+/* ------------------------------------------------------------------ */
+/* Dossier reading and writing                                        */
+/* ------------------------------------------------------------------ */
+
+function dossierDir(project) {
+  return path.join(MEMORY_ROOT, project.slug);
+}
+
+function sectionPath(project, file) {
+  const directory = dossierDir(project);
+  if (file === "JOURNAL") return path.join(directory, "JOURNAL", `${monthKey()}.md`);
+  return path.join(directory, SECTION_FILES[file] ?? SECTION_FILES.PROJECT);
+}
+
+function readSection(project, file = "PROJECT", maxChars = 12000) {
+  const target = sectionPath(project, file);
+  const content = readText(target);
+  if (content.length === 0) {
+    return `Файл ${path.basename(target)} для проекта «${project.name}» ещё не заполнен.`;
+  }
+  return truncate(content, maxChars);
+}
+
+function appendJournal(project, text) {
+  const target = sectionPath(project, "JOURNAL");
+  const content = redactSecrets(String(text ?? "").trim());
+  if (content.length === 0) throw new Error("journal content is empty");
+  if (!exists(target)) appendText(target, `# Журнал — ${project.name}, ${monthKey()}\n\n`);
+  appendText(target, `${content}\n\n`);
+  return target;
+}
+
+function updateSection(project, file, content, mode = "replace") {
+  if (file === "JOURNAL") throw new Error("use append_journal for JOURNAL");
+  const target = sectionPath(project, file);
+  const redacted = redactSecrets(String(content ?? ""));
+  const bytes = Buffer.byteLength(redacted, "utf8");
+  if (bytes === 0) throw new Error("content is empty");
+  if (bytes > SECTION_MAX_BYTES) throw new Error(`content is too large (${bytes} bytes > ${SECTION_MAX_BYTES}); split it`);
+  if (mode === "append") {
+    if (!exists(target)) writeText(target, `# ${file} — ${project.name}\n\n`);
+    appendText(target, `${redacted.trimEnd()}\n\n`);
+  } else {
+    writeText(target, `${redacted.trimEnd()}\n`);
+  }
+  return { target, bytes };
+}
+
+function searchDossier(project, query, limit = 40) {
+  const needle = String(query ?? "").trim();
+  if (needle.length < 2) throw new Error("search query must contain at least 2 characters");
+  const directory = dossierDir(project);
+  const results = [];
+  const walk = (current) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === "JOURNAL") walk(full);
+        continue;
+      }
+      if (!/\.(md|json)$/u.test(entry.name)) continue;
+      const lines = readText(full).split(/\r?\n/u);
+      lines.forEach((line, index) => {
+        if (results.length >= limit) return;
+        if (line.toLowerCase().includes(needle.toLowerCase())) {
+          results.push({
+            file: path.relative(directory, full).replaceAll("\\", "/"),
+            line: index + 1,
+            text: truncate(line.trim(), 240),
+          });
+        }
+      });
+    }
+  };
+  walk(directory);
+  return results;
+}
+
+function latestJournalExcerpt(project, maxChars = 700) {
+  const directory = path.join(dossierDir(project), "JOURNAL");
+  let months = [];
+  try {
+    months = fs.readdirSync(directory).filter((name) => /^\d{4}-\d{2}\.md$/u.test(name)).sort();
+  } catch {
+    return "";
+  }
+  const last = months.at(-1);
+  if (!last) return "";
+  const content = readText(path.join(directory, last));
+  const blocks = content.split(/\n(?=### )/u).filter((block) => block.trim().length > 0);
+  const tail = blocks.at(-1) ?? "";
+  return truncate(tail.replace(/\s+/gu, " ").trim(), maxChars);
+}
+
+function rebuildIndex(project) {
+  const directory = dossierDir(project);
+  const sections = [];
+  for (const name of ["PROJECT.md", "ARCHITECTURE.md", "CODE-MAP.md", "INVARIANTS.md", "GOTCHAS.md", "RUNBOOK.md"]) {
+    const target = path.join(directory, name);
+    sections.push({ file: name, bytes: exists(target) ? fs.statSync(target).size : 0 });
+  }
+  const git = project.roots.length > 0 ? gitInfo(project.roots[0]) : undefined;
+  const index = {
+    slug: project.slug,
+    name: project.name,
+    roots: project.roots,
+    generatedAt: nowIso(),
+    sections,
+    lastAnalyzedAt: project.lastAnalyzedAt ?? null,
+    lastJournalAt: project.lastJournalAt ?? null,
+    lastGitHead: git ? `${git.branch}@${git.head}` : null,
+    confidence: project.confidence ?? "auto",
+  };
+  try {
+    writeText(path.join(directory, "INDEX.json"), `${JSON.stringify(index, null, 2)}\n`);
+  } catch {
+    /* ignore */
+  }
+  return index;
+}
+
+function freshness(project) {
+  const git = project.roots.length > 0 ? gitInfo(project.roots[0]) : undefined;
+  const analyzed = project.lastAnalyzedAt;
+  if (!analyzed) return { state: "unanalyzed", text: "досье ещё не анализировалось", git };
+  if (git && project.lastGitHead && git.head !== project.lastGitHead) {
+    return { state: "stale", text: `код изменился с последнего анализа (было ${project.lastGitHead}, сейчас ${git.branch}@${git.head})`, git };
+  }
+  return { state: "current", text: `актуально на ${analyzed}`, git };
+}
+
+/* ------------------------------------------------------------------ */
+/* Digest                                                             */
+/* ------------------------------------------------------------------ */
+
+function bulletLines(text, limit) {
+  return text
+    .split(/\r?\n/u)
+    .map((line) => line.trim())
+    .filter((line) => /^[-*]\s+\S/u.test(line) && !/\(не заполнено\)/u.test(line))
+    .filter((line) => !/^[-*]\s+(Симптом|Причина|Решение|Как обнаружить заранее|Уверенность)\s*:/u.test(line))
+    .slice(0, limit)
+    .map((line) => truncate(line.replace(/^[-*]\s+/u, "- "), 220));
+}
+
+function buildDigest(registry, project, sessionId, settings, state) {
+  const budget = Math.max(800, Math.min(6000, settings.digestBudgetChars ?? DEFAULT_DIGEST_BUDGET));
+  const parts = [];
+  const fresh = freshness(project);
+  parts.push(`<project-memory slug="${project.slug}">`);
+  parts.push(`Проект: «${project.name}». Корень: ${truncate(project.roots[0] ?? "", 160)}. Досье: ${truncate(projectPublic(project).dossier, 180)}.`);
+  const projectFile = readText(path.join(dossierDir(project), "PROJECT.md"));
+  const stackLine = projectFile.split(/\r?\n/u).find((line) => /Стек:/u.test(line));
+  if (stackLine && !/\(не определён\)/u.test(stackLine)) parts.push(truncate(stackLine.trim(), 220));
+  parts.push(`Статус памяти: ${fresh.text}${fresh.git ? ` · git ${fresh.git.branch}@${fresh.git.head}` : ""}.`);
+  const invariants = bulletLines(readText(path.join(dossierDir(project), "INVARIANTS.md")), 6);
+  if (invariants.length > 0) {
+    parts.push("Инварианты и запреты:");
+    parts.push(...invariants);
+  }
+  const gotchas = bulletLines(readText(path.join(dossierDir(project), "GOTCHAS.md")), 6);
+  if (gotchas.length > 0) {
+    parts.push("Известные грабли:");
+    parts.push(...gotchas);
+  }
+  const journal = latestJournalExcerpt(project);
+  if (journal.length > 0) parts.push(`Последняя запись журнала: ${journal}`);
+  const legacy = (project.legacyDocs ?? []).slice(0, 4);
+  if (legacy.length > 0) parts.push(`Связанная память: ${legacy.join("; ")}`);
+  const sessionState = state[sessionId];
+  if (sessionState?.pendingReminder && sessionState.pendingReminder.projectSlug === project.slug) {
+    parts.push("НАПОМИНАНИЕ: в прошлом ходе проект менялся, но память не обновлялась. Допиши JOURNAL/разделы через project_memory, если это ещё актуально.");
+  }
+  parts.push("Инструкция: полное досье читай инструментом project_memory (read/search), не пересказывай этот дайджест. Для глубокого анализа или «запомни проект» загрузи скилл project-deep-dive и после работы допиши досье (JOURNAL обязателен).");
+  parts.push("</project-memory>");
+  let text = parts.join("\n");
+  if (text.length > budget) text = `${truncate(text, budget)}\n</project-memory>`;
+  return text;
+}
+
+/** Digest cache: rebuilt only when the dossier files or git head changed. */
+class DigestCache {
+  constructor() {
+    this.entries = new Map();
+  }
+
+  signature(project) {
+    const directory = dossierDir(project);
+    const files = ["PROJECT.md", "ARCHITECTURE.md", "CODE-MAP.md", "INVARIANTS.md", "GOTCHAS.md", "RUNBOOK.md", "INDEX.json"];
+    let stamp = "";
+    for (const name of files) {
+      const target = path.join(directory, name);
+      try {
+        const stat = fs.statSync(target);
+        stamp += `${name}:${stat.mtimeMs}:${stat.size};`;
+      } catch {
+        stamp += `${name}:0;`;
+      }
+    }
+    const journalDir = path.join(directory, "JOURNAL");
+    try {
+      for (const name of fs.readdirSync(journalDir).sort().slice(-2)) {
+        const stat = fs.statSync(path.join(journalDir, name));
+        stamp += `${name}:${stat.mtimeMs};`;
+      }
+    } catch {
+      /* no journal yet */
+    }
+    const git = project.roots.length > 0 ? gitInfo(project.roots[0]) : undefined;
+    stamp += `git:${git?.head ?? "-"}:${git?.branch ?? "-"};`;
+    return stamp;
+  }
+
+  get(key, signature, build) {
+    const cached = this.entries.get(key);
+    if (cached !== undefined && cached.signature === signature) return cached.text;
+    const text = build();
+    this.entries.set(key, { signature, text, at: Date.now() });
+    if (this.entries.size > 200) {
+      for (const [entryKey, entry] of this.entries) {
+        if (Date.now() - entry.at > 3600 * 1000) this.entries.delete(entryKey);
+      }
+    }
+    return text;
+  }
+}
+
+/* ------------------------------------------------------------------ */
+/* Session tracking (auto journal + reminder)                          */
+/* ------------------------------------------------------------------ */
+
+const TOOL_LABELS = { bash: "bash", pwsh: "pwsh", edit: "edit", write: "write", read: "read", grep: "grep", glob: "glob" };
+
+function sessionEntry(state, sessionId) {
+  if (!state[sessionId]) {
+    state[sessionId] = {
+      projectSlug: null,
+      turn: 0,
+      changes: [],
+      commands: [],
+      errors: [],
+      firstUserText: "",
+      memoryUpdatedTurns: [],
+      journaledTurns: [],
+      pendingReminder: null,
+      updatedAt: Date.now(),
+      lastSeq: 0,
+    };
+  }
+  state[sessionId].updatedAt = Date.now();
+  return state[sessionId];
+}
+
+function argumentsObject(raw) {
+  if (typeof raw === "string") {
+    try {
+      const parsed = JSON.parse(raw);
+      return parsed !== null && typeof parsed === "object" ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+  return raw !== null && typeof raw === "object" ? raw : {};
+}
+
+function trackSessionEvent(ctx, registry, state, session, event) {
+  const sessionId = String(session.id);
+  const entry = sessionEntry(state, sessionId);
+  entry.lastSeq = Number(event.seq) || entry.lastSeq;
+  if (event.type === "tool/call") {
+    const name = event.data?.name ?? "tool";
+    const turn = Number(event.data?.turn) || entry.turn;
+    entry.turn = Math.max(entry.turn, turn);
+    if (name === "project_memory") {
+      if (!entry.memoryUpdatedTurns.includes(turn)) entry.memoryUpdatedTurns.push(turn);
+      entry.pendingReminder = null;
+    }
+    const args = argumentsObject(event.data?.arguments);
+    const command = typeof args.command === "string" ? args.command : typeof args.cmd === "string" ? args.cmd : undefined;
+    if (command && (name === "bash" || name === "pwsh")) {
+      entry.commands.push(truncate(command.replace(/\s+/gu, " ").trim(), 120));
+      if (entry.commands.length > 12) entry.commands.shift();
+    }
+    const filePath = typeof args.file_path === "string" ? args.file_path : typeof args.path === "string" ? args.path : undefined;
+    if (filePath && (name === "write" || name === "edit")) {
+      entry.changes.push(filePath);
+      if (entry.changes.length > 40) entry.changes.shift();
+    }
+    return;
+  }
+  if (event.type === "tool/result" && event.data?.error) {
+    const error = event.data.error;
+    entry.errors.push(truncate(`${error.name ?? "tool"}:${error.code ?? "error"} ${error.reason ?? ""}`.trim(), 160));
+    if (entry.errors.length > 8) entry.errors.shift();
+    return;
+  }
+  if (event.type === "user/message" && entry.firstUserText.length === 0) {
+    const content = event.data?.content ?? [];
+    const text = Array.isArray(content)
+      ? content.filter((block) => block?.type === "text").map((block) => block.text).join("\n")
+      : "";
+    const cleaned = text.replace(/\s+/gu, " ").trim();
+    const injected = /^(Current runtime context|Updated instructions from|The user added|### Updated Tool Schemas|Background subagent|Time sampled|You are the Team Lead|Approval prompts are disabled|You are an AI agent|# \u0413\u041b\u041e\u0411\u0410\u041b\u042c\u041d\u042b\u0415|\u0418\u043d\u0441\u0442\u0440\u0443\u043a\u0446\u0438\u0438 from)/u.test(cleaned);
+    if (!injected) entry.firstUserText = truncate(cleaned, 160);
+    return;
+  }
+  if (event.type === "workspace/changes") {
+    const summary = ctx.get("workspaceChanges")?.summary(String(session.id), event.seq);
+    if (summary && Array.isArray(summary.files)) {
+      for (const file of summary.files.slice(0, 40)) {
+        if (!entry.changes.includes(file.path)) entry.changes.push(file.path);
+      }
+      if (entry.changes.length > 40) entry.changes = entry.changes.slice(-40);
+    }
+    return;
+  }
+  if (event.type === "turn/end") {
+    entry.turn = Math.max(entry.turn, Number(event.data?.turn) || entry.turn);
+  }
+}
+
+function composeJournalEntry(entry, session, turn, reason) {
+  const lines = [];
+  lines.push(`### ${localStamp()} · ход ${turn}${reason?.kind === "completed" ? "" : ` (${reason?.kind ?? "unknown"})`}${entry.firstUserText ? ` · ${entry.firstUserText}` : ""}`);
+  lines.push(`- Сессия: \`${String(session.id)}\``);
+  if (entry.changes.length > 0) lines.push(`- Изменённые файлы: ${entry.changes.slice(0, 15).map((file) => `\`${truncate(file, 120)}\``).join(", ")}`);
+  if (entry.commands.length > 0) lines.push(`- Команды: ${entry.commands.slice(0, 8).map((command) => `\`${command}\``).join("; ")}`);
+  if (entry.errors.length > 0) lines.push(`- Ошибки/сбои: ${entry.errors.slice(0, 5).join("; ")}`);
+  const updated = entry.memoryUpdatedTurns.includes(turn);
+  lines.push(`- Память обновлена моделью: ${updated ? "да" : "нет (автозапись; при значимых фактах требуется дополнение)"}`);
+  lines.push("");
+  return lines.join("\n");
+}
+
+/* ------------------------------------------------------------------ */
+/* Tool implementation                                                */
+/* ------------------------------------------------------------------ */
+
+function jsonResult(text, value = {}) {
+  return { text, ...value };
+}
+
+function projectFromArgs(deps, args, session) {
+  const { registry, effectiveCwd } = deps;
+  const settings = registry.settings;
+  const requested = typeof args.project === "string" ? args.project.trim() : "";
+  if (requested.length > 0) {
+    const bySlug = registry.projects.find((project) => project.slug === requested);
+    if (bySlug) return projectPublic(bySlug);
+    const byName = registry.projects.find((project) => project.name.toLowerCase() === requested.toLowerCase());
+    if (byName) return projectPublic(byName);
+    throw new Error(`project not found: ${requested}. Use action=list to see known projects.`);
+  }
+  const resolved = resolveProjectForSession(registry, session, settings, { cwd: typeof effectiveCwd === "function" ? effectiveCwd(session) : undefined });
+  if (!resolved) throw new Error("no project resolved for this Session; pass project= or register one with action=register");
+  return resolved;
+}
+
+function markMemoryUpdated(state, sessionId) {
+  if (!sessionId) return;
+  const entry = sessionEntry(state, sessionId);
+  if (!entry.memoryUpdatedTurns.includes(entry.turn)) entry.memoryUpdatedTurns.push(entry.turn);
+  entry.pendingReminder = null;
+}
+
+async function runTool(deps, args, exec) {
+  const { registry, state } = deps;
+  const settings = registry.settings;
+  const agent = exec?.agent;
+  const session = agent?.session ?? (agent?.id ? ctx.get("sessions")?.get(agent.id) : undefined);
+  const action = typeof args?.action === "string" ? args.action : "";
+  const sessionId = agent?.id ? String(agent.id) : undefined;
+  try {
+    if (action === "register") {
+      const project = createProject(registry, {
+        name: String(args.name ?? "").trim(),
+        root: String(args.root ?? "").trim(),
+        stack: typeof args.stack === "string" ? args.stack : undefined,
+        legacyDocs: Array.isArray(args.legacyDocs) ? args.legacyDocs.filter((value) => typeof value === "string") : undefined,
+      });
+      markMemoryUpdated(state, sessionId);
+      return jsonResult(`Проект «${project.name}» зарегистрирован. Досье: ${project.dossier}`, { project, created: true });
+    }
+    if (action === "list") {
+      if (registry.projects.length === 0) return jsonResult("Пока нет ни одного проекта. Зарегистрируй: project_memory action=register name=... root=...", { projects: [] });
+      const lines = registry.projects.map((project) => `- ${project.slug} — ${project.name} · ${project.roots[0] ?? "?"} · анализ: ${project.lastAnalyzedAt ?? "не было"} · записей журнала: ${project.lastJournalAt ? "есть" : "нет"}`);
+      return jsonResult(`Проекты (${registry.projects.length}):\n${lines.join("\n")}`, { projects: registry.projects.map(projectPublic) });
+    }
+    if (action === "status") {
+      const project = projectFromArgs(deps, args, session);
+      const fresh = freshness(project);
+      const directory = dossierDir(project);
+      const sizes = ["PROJECT.md", "ARCHITECTURE.md", "CODE-MAP.md", "INVARIANTS.md", "GOTCHAS.md", "RUNBOOK.md"].map((name) => {
+        const target = path.join(directory, name);
+        return `${name}: ${exists(target) ? fs.statSync(target).size : 0} B`;
+      });
+      const text = [
+        `Проект: «${project.name}» (${project.slug})`,
+        `Корень: ${project.roots.join(", ")}`,
+        `Досье: ${directory}`,
+        `Свежесть: ${fresh.text}`,
+        `Связанная память: ${(project.legacyDocs ?? []).join("; ") || "нет"}`,
+        `Разделы: ${sizes.join("; ")}`,
+        `Настройки: бюджет дайджеста ${settings.digestBudgetChars} символов, авто-регистрация ${settings.autoRegister ? "вкл" : "выкл"}`,
+      ].join("\n");
+      return jsonResult(text, { project, freshness: fresh });
+    }
+    if (action === "read") {
+      const project = projectFromArgs(deps, args, session);
+      const file = typeof args.file === "string" && SECTION_NAMES.includes(args.file) ? args.file : "PROJECT";
+      const maxChars = Number.isFinite(Number(args.maxChars)) ? Math.max(500, Math.min(30000, Number(args.maxChars))) : 12000;
+      const content = readSection(project, file, maxChars);
+      return jsonResult(`# ${file} — «${project.name}»\n${content}`, { project, file, content: truncate(content, maxChars) });
+    }
+    if (action === "search") {
+      const project = projectFromArgs(deps, args, session);
+      const query = String(args.query ?? "");
+      const results = searchDossier(project, query, 40);
+      const text = results.length === 0
+        ? `Ничего не найдено по «${query}».`
+        : `Найдено ${results.length} совпадений:\n${results.map((hit) => `- ${hit.file}:${hit.line} — ${hit.text}`).join("\n")}`;
+      return jsonResult(text, { project, query, results });
+    }
+    if (action === "append_journal") {
+      const project = projectFromArgs(deps, args, session);
+      const content = String(args.content ?? "");
+      const target = appendJournal(project, content);
+      const record = registry.projects.find((item) => item.slug === project.slug);
+      if (record) {
+        record.updatedAt = nowIso();
+        record.lastJournalAt = nowIso();
+        saveRegistry(registry);
+        rebuildIndex({ ...project, lastJournalAt: record.lastJournalAt });
+      }
+      markMemoryUpdated(state, sessionId);
+      ensureProjectDossier(project);
+      return jsonResult(`Запись добавлена в журнал: ${target}`, { project, file: target });
+    }
+    if (action === "update_section") {
+      const project = projectFromArgs(deps, args, session);
+      const file = typeof args.file === "string" ? args.file : "PROJECT";
+      if (!SECTION_NAMES.includes(file)) throw new Error(`unknown section: ${file}`);
+      const mode = args.mode === "append" ? "append" : "replace";
+      const result = updateSection(project, file, String(args.content ?? ""), mode);
+      const record = registry.projects.find((item) => item.slug === project.slug);
+      if (record) {
+        record.updatedAt = nowIso();
+        saveRegistry(registry);
+      }
+      rebuildIndex({ ...project, lastJournalAt: record?.lastJournalAt ?? project.lastJournalAt });
+      markMemoryUpdated(state, sessionId);
+      return jsonResult(`${file} обновлён (${mode}, ${result.bytes} B): ${result.target}`, { project, file, bytes: result.bytes, mode });
+    }
+    return jsonResult(`Неизвестное действие «${action}». Доступно: status, list, read, search, append_journal, update_section, register.`, { error: "unknown action" });
+  } catch (error) {
+    return { text: `project_memory: ${error instanceof Error ? error.message : String(error)}`, error: String(error instanceof Error ? error.message : error) };
+  }
+}
+
+const TOOL_PARAMETERS = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    action: {
+      type: "string",
+      enum: ["status", "list", "read", "search", "append_journal", "update_section", "register"],
+      description: "status|list|read|search|append_journal|update_section|register",
+    },
+    project: { type: "string", description: "Project slug or name; defaults to the current Session's project." },
+    file: { type: "string", enum: SECTION_NAMES, description: "Dossier section for read/update_section." },
+    content: { type: "string", description: "Markdown content for append_journal/update_section." },
+    query: { type: "string", description: "Case-insensitive substring for search." },
+    root: { type: "string", description: "Absolute project root directory for register." },
+    name: { type: "string", description: "Human project name for register." },
+    stack: { type: "string", description: "Short stack description for register." },
+    mode: { type: "string", enum: ["replace", "append"], description: "update_section mode; default replace." },
+    maxChars: { type: "integer", description: "read cap, 500..30000 (default 12000)." },
+  },
+  required: ["action"],
+};
+
+/** Strip undefined values so the tool result is lossless JSON. */
+function lossless(value) {
+  if (value === undefined) return null;
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    return { text: String(value) };
+  }
+}
+
+function makeToolDefinition(deps) {
+  return {
+    name: "project_memory",
+    description:
+      "Local long-term project memory. Read/search the project dossier, append a journal entry, update a dossier section, or register a project. The dossier lives under <DSH_HOME>/projects-memory/<slug>. Use status first when unsure. Never store secrets or PII; link to files instead of copying code.",
+    parameters: TOOL_PARAMETERS,
+    timeoutMs: 20000,
+    output: {
+      schema: { type: "object", additionalProperties: true },
+      render(_args, value) {
+        const text = value !== null && typeof value === "object" && typeof value.text === "string"
+          ? value.text
+          : JSON.stringify(value);
+        return [{ type: "text", text: truncate(text, 40000) }];
+      },
+    },
+    async execute(args, exec) {
+      return lossless(await runTool(deps, args, exec));
+    },
+  };
+}
+
+/* ------------------------------------------------------------------ */
+/* Plugin entry                                                       */
+/* ------------------------------------------------------------------ */
+
+export async function apply(ctx) {
+  const logger = ctx.logger;
+  try {
+    fs.mkdirSync(MEMORY_ROOT, { recursive: true });
+  } catch (error) {
+    logger?.warn?.(`[project-memory] cannot create ${MEMORY_ROOT}: ${String(error)}`);
+  }
+  const registry = loadRegistry();
+  const state = loadState();
+  const digestCache = new DigestCache();
+  const curatorTimers = new Map();
+  const deps = { registry, state, digestCache };
+
+  /** Effective cwd of a session: projection first, durable header second. */
+  const workingDirectory = ctx.get("workingDirectory");
+  const sessionCwdCache = new WeakMap();
+  function effectiveCwd(session) {
+    if (!session) return "";
+    if (sessionCwdCache.has(session)) return sessionCwdCache.get(session);
+    let cwd = "";
+    try {
+      cwd = workingDirectory?.get(session) ?? "";
+    } catch {
+      cwd = "";
+    }
+    if (typeof cwd !== "string" || cwd.length === 0) cwd = session?.header?.cwd ?? "";
+    sessionCwdCache.set(session, cwd);
+    return cwd;
+  }
+  deps.effectiveCwd = effectiveCwd;
+
+  /* ---------------- dynamic prompt context ---------------- */
+  ctx.systemPrompt.context({
+    name: "project-memory:digest",
+    order: 130,
+    interpolate: false,
+    required: false,
+    text: (assemblyContext) => {
+      try {
+        const agent = assemblyContext?.agent;
+        const session = agent?.session ?? (agent?.id ? ctx.get("sessions")?.get(agent.id) : undefined);
+        if (!session) return "";
+        if (session.header?.origin === "subagent") return "";
+        const cwd = effectiveCwd(session);
+        if (!cwd) return "";
+        const project = resolveProjectForSession(registry, session, registry.settings, { cwd });
+        if (!project) return "";
+        const signature = digestCache.signature(project);
+        const sessionId = String(session.id);
+        const key = `${sessionId}:${project.slug}`;
+        const text = digestCache.get(key, signature, () => buildDigest(registry, project, sessionId, registry.settings, state));
+        logAccess(`digest session=${sessionId} project=${project.slug} chars=${text.length}`);
+        return text;
+      } catch (error) {
+        logger?.warn?.(`[project-memory] digest failed: ${String(error)}`);
+        return "";
+      }
+    },
+  });
+
+  /* ---------------- tool ---------------- */
+  try {
+    ctx.effect(() => ctx.tools.register(makeToolDefinition(deps)), "project-memory: tool");
+  } catch (error) {
+    logger?.warn?.(`[project-memory] tool registration failed: ${String(error)}`);
+  }
+
+  /* ---------------- session tracking ---------------- */
+  function resolveSessionProject(session) {
+    return resolveProjectForSession(registry, session, registry.settings, { cwd: effectiveCwd(session) });
+  }
+
+  function scheduleCurator(session, reason) {
+    const settings = registry.settings.curator ?? {};
+    if (settings.enabled !== true) return;
+    const sessionId = String(session.id);
+    const previous = curatorTimers.get(sessionId);
+    if (previous !== undefined) clearTimeout(previous);
+    const delay = Math.max(15000, Number(settings.idleMs) || CURATOR_IDLE_MS);
+    const timer = setTimeout(() => {
+      curatorTimers.delete(sessionId);
+      void runCurator(sessionId, reason).catch((error) => logger?.warn?.(`[project-memory] curator failed: ${String(error)}`));
+    }, delay);
+    timer.unref?.();
+    curatorTimers.set(sessionId, timer);
+  }
+
+  function buildCuratorPrompt(project, session, entry, reason) {
+    const summary = [
+      `Проект: ${project.name} (${project.slug}); корень: ${project.roots[0] ?? "?"}; досье: ${path.join(MEMORY_ROOT, project.slug)}`,
+      `Сессия: ${String(session.id)}; ход: ${entry.turn}; причина завершения: ${reason?.kind ?? "unknown"}`,
+      entry.firstUserText ? `Запрос пользователя (начало): ${entry.firstUserText}` : "",
+      entry.changes.length > 0 ? `Изменённые файлы:\n${entry.changes.slice(0, 10).map((file) => `- ${file}`).join("\n")}` : "",
+      entry.commands.length > 0 ? `Команды:\n${entry.commands.slice(0, 6).map((command) => `- ${command}`).join("\n")}` : "",
+      entry.errors.length > 0 ? `Ошибки/сбои:\n${entry.errors.slice(0, 5).map((error) => `- ${error}`).join("\n")}` : "",
+    ].filter((line) => line.length > 0).join("\n");
+    return `Ты фоновый куратор локальной памяти проекта. Родительская сессия только что завершила рабочий ход; автоматическая запись-факт в JOURNAL уже добавлена.
+
+${summary}
+
+Задачи:
+1. project_memory action=status — проверь досье и свежесть.
+2. project_memory action=read file=JOURNAL — пойми, что уже записано (последняя запись).
+3. Если нужно, прочитай 1-3 изменённых файла (read/grep), чтобы понять суть.
+4. Обнови ТОЛЬКО реальные долговременные факты через project_memory action=update_section: GOTCHAS (новые грабли/решения), INVARIANTS (новые запреты/инварианты), CODE-MAP (новые/удалённые важные файлы), ARCHITECTURE (структурные изменения), RUNBOOK (изменившиеся команды). Не дублируй уже записанное; если новых durable-фактов нет — ничего не пиши.
+5. Верни короткий отчёт (3-6 строк): какие файлы/секции обновлены или «без изменений».
+
+Правила: не храни секреты и PII; ссылайся на файлы path:line вместо копирования кода; работай только с этим проектом.`;
+  }
+
+  const curatorInFlight = new Map();
+
+  async function runCurator(sessionId, reason) {
+    const entry = state[sessionId];
+    if (!entry || !entry.pendingReminder) return;
+    if (curatorInFlight.has(sessionId)) return;
+    const agents = ctx.get("agents");
+    const subagents = ctx.get("subagents");
+    if (agents === undefined || subagents === undefined) {
+      logAccess(`curator-skipped session=${sessionId} (agents/subagents service unavailable)`);
+      return;
+    }
+    const agent = agents.get(sessionId);
+    if (agent === undefined) {
+      logAccess(`curator-skipped session=${sessionId} (agent no longer live)`);
+      return;
+    }
+    if (agent.status === "running") return;
+    const session = agent.session;
+    const project = resolveSessionProject(session);
+    if (!project) return;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(new Error("curator timeout")), 4 * 60 * 1000);
+    timeout.unref?.();
+    curatorInFlight.set(sessionId, true);
+    let activation;
+    try {
+      const prompt = buildCuratorPrompt(project, session, entry, reason);
+      activation = subagents.startActivation({
+        provider: "spawn",
+        label: "project-memory curator",
+        delivery: "caller",
+        signal: controller.signal,
+        request: {
+          parent: agent,
+          prompt: [{ type: "text", text: prompt }],
+          cwd: project.roots[0],
+          agentPreset: "standard",
+          maxDepth: 1,
+        },
+      });
+      logAccess(`curator-start session=${sessionId} child=${String(activation.childId)} project=${project.slug}`);
+      const result = await activation.result;
+      const output = typeof result?.output === "string" ? result.output.replace(/\s+/gu, " ").trim() : "";
+      logAccess(`curator-done session=${sessionId} project=${project.slug} stop=${String(result?.stopReason ?? "?")} out=${truncate(output, 200)}`);
+      markMemoryUpdated(state, sessionId);
+      saveState(state);
+    } catch (error) {
+      logAccess(`curator-error session=${sessionId} ${truncate(String(error), 300)}`);
+    } finally {
+      clearTimeout(timeout);
+      curatorInFlight.delete(sessionId);
+      try {
+        await activation?.dispose?.();
+      } catch {
+        /* already settled */
+      }
+    }
+  }
+
+  ctx.on("session/event", (session, event) => {
+    try {
+      if (session.header?.origin === "subagent") return;
+      trackSessionEvent(ctx, registry, state, session, event);
+      if (event.type === "turn/end") {
+        const entry = state[String(session.id)];
+        if (!entry) return;
+        const turn = Number(event.data?.turn) || entry.turn;
+        const hasWork = entry.changes.length > 0 || entry.commands.length > 0 || entry.errors.length > 0;
+        const already = entry.journaledTurns.includes(turn);
+        if (hasWork && !already) {
+          const project = resolveSessionProject(session);
+          if (project) {
+            const reason = event.data?.reason;
+            const journalText = composeJournalEntry(entry, session, turn, reason);
+            appendJournal(project, journalText);
+            const record = registry.projects.find((item) => item.slug === project.slug);
+            if (record) {
+              record.lastJournalAt = nowIso();
+              record.updatedAt = nowIso();
+              saveRegistry(registry);
+            }
+            rebuildIndex({ ...project, lastJournalAt: nowIso() });
+            entry.journaledTurns.push(turn);
+            if (!entry.memoryUpdatedTurns.includes(turn)) {
+              entry.pendingReminder = { projectSlug: project.slug, turn, at: Date.now() };
+              scheduleCurator(session, reason);
+            } else {
+              entry.pendingReminder = null;
+            }
+            logAccess(`journal session=${String(session.id)} project=${project.slug} turn=${turn} files=${entry.changes.length} cmds=${entry.commands.length}`);
+          }
+        }
+        entry.changes = [];
+        entry.commands = [];
+        entry.errors = [];
+        entry.firstUserText = "";
+        entry.turn = turn;
+        saveState(state);
+      }
+    } catch (error) {
+      logger?.warn?.(`[project-memory] session tracking failed: ${String(error)}`);
+    }
+  });
+
+  /* ---------------- user command /remember ---------------- */
+  ctx.inject(["commands"], (commandCtx) => {
+    try {
+      const dispose = commandCtx.commands.register({
+        name: "remember",
+        description: "Глубоко проанализировать текущий проект и обновить локальное досье памяти",
+        input: { hint: "[фокус анализа]" },
+        recordInput: false,
+        handler: ({ agent, rawInput }) => {
+          const session = agent?.session;
+          const project = session ? resolveProjectForSession(registry, session, registry.settings, { cwd: effectiveCwd(session) }) : undefined;
+          const focus = String(rawInput ?? "").trim();
+          const target = project ? `проект «${project.name}» (${project.slug}), досье ${projectPublic(project).dossier}` : "текущий проект (сначала зарегистрируй его через project_memory action=register)";
+          const message = {
+            id: randomUUID(),
+            role: "user",
+            source: { kind: "user" },
+            content: [{
+              type: "text",
+              text: [
+                "ПАМЯТЬ ПРОЕКТА (/remember).",
+                `Цель: глубоко проанализировать ${target} и обновить локальное досье памяти.`,
+                focus ? `Фокус: ${focus}.` : "",
+                "Порядок: 1) загрузи скилл project-deep-dive; 2) project_memory action=status; 3) разведка структуры/архитектуры/инвариантов; 4) project_memory update_section для ARCHITECTURE, CODE-MAP, INVARIANTS, GOTCHAS, RUNBOOK и PROJECT; 5) project_memory action=append_journal с итогом (что проверено, что осталось). Не храни секреты и PII, ссылайся на файлы вместо копирования кода. В ответе перечисли, что записано и что осталось неизвестным.",
+              ].filter(Boolean).join("\n"),
+            }],
+          };
+          try {
+            if (typeof agent.followup === "function") agent.followup(message);
+            else if (typeof agent.inject === "function") agent.inject(message);
+          } catch (error) {
+            logger?.warn?.(`[project-memory] /remember could not wake the agent: ${String(error)}`);
+          }
+          return { kind: "success", text: project ? `Запрос на анализ «${project.name}» отправлен в чат.` : "Запрос отправлен; проект будет зарегистрирован после первого изменения." };
+        },
+      });
+      ctx.effect(() => dispose, "project-memory: /remember command");
+      logAccess("command-registered name=remember");
+    } catch (error) {
+      logger?.warn?.(`[project-memory] command registration failed: ${String(error)}`);
+    }
+  });
+
+  /* ---------------- cleanup ---------------- */
+  ctx.effect(() => () => {
+    for (const timer of curatorTimers.values()) clearTimeout(timer);
+    curatorTimers.clear();
+    saveState(state);
+  }, "project-memory: cleanup");
+
+  logAccess(`started pid=${process.pid} registryProjects=${registry.projects.length}`);
+  logger?.info?.(`[project-memory] ready: ${registry.projects.length} project(s), root ${MEMORY_ROOT}`);
+}