dsh-desktop-kit 2.0.0 → 2.1.0

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

@@ -17,6 +17,17 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
+import {
+  SCAN_VERSION,
+  detectProject,
+  gitInfo,
+  scanProject,
+  renderAutoSections,
+  mergeAutoBlock,
+  scanSummary,
+  renderBrief,
+  redactText,
+} from "./scan.js";
 
 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");
@@ -25,6 +36,9 @@ 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 SCAN_FILE = "scan.json";
+const SCAN_TTL_MS = 24 * 3600 * 1000;
+const SCAN_CHECK_MS = 5 * 60 * 1000;
 const SECTION_NAMES = ["PROJECT", "ARCHITECTURE", "CODE-MAP", "INVARIANTS", "GOTCHAS", "RUNBOOK", "JOURNAL"];
 const SECTION_FILES = {
   PROJECT: "PROJECT.md",
@@ -35,7 +49,6 @@ const SECTION_FILES = {
   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;
 
@@ -91,13 +104,15 @@ function readText(filePath) {
 }
 
 function writeText(filePath, text) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  ensurePrivateDir(path.dirname(filePath));
   fs.writeFileSync(filePath, text, "utf8");
+  harden(filePath);
 }
 
 function appendText(filePath, text) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  ensurePrivateDir(path.dirname(filePath));
   fs.appendFileSync(filePath, text, "utf8");
+  harden(filePath);
 }
 
 function exists(filePath) {
@@ -108,21 +123,23 @@ function exists(filePath) {
   }
 }
 
-/** 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;
+/** Keep the local dossier private on POSIX; chmod is best-effort on Windows. */
+function harden(target, mode = 0o600) {
+  try {
+    fs.chmodSync(target, mode);
+  } catch {
+    /* Windows may only support a read-only bit; the file stays local either way */
+  }
+}
+
+function ensurePrivateDir(directory) {
+  fs.mkdirSync(directory, { recursive: true });
+  harden(directory, 0o700);
 }
 
+/** Every dossier/journal write is scrubbed before it reaches disk. */
+const redactSecrets = redactText;
+
 function truncate(text, max) {
   const value = String(text ?? "");
   return value.length <= max ? value : `${value.slice(0, Math.max(0, max - 1))}…`;
@@ -153,7 +170,11 @@ function defaultRegistry() {
       digestBudgetChars: DEFAULT_DIGEST_BUDGET,
       injectSubagents: false,
       autoRegister: true,
-      curator: { enabled: true, idleMs: CURATOR_IDLE_MS },
+      autoScan: true,
+      autoRecall: true,
+      maxProjects: 200,
+      scanTtlHours: 24,
+      curator: { enabled: false, idleMs: CURATOR_IDLE_MS },
     },
     projects: [],
   };
@@ -201,26 +222,6 @@ function saveState(sessions) {
   }
 }
 
-/* ------------------------------------------------------------------ */
-/* 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                            */
 /* ------------------------------------------------------------------ */
@@ -230,14 +231,19 @@ function projectPublic(project) {
     slug: project.slug,
     name: project.name,
     roots: [...project.roots],
+    stack: project.stack,
+    fingerprint: project.fingerprint,
     dossier: path.join(MEMORY_ROOT, project.slug),
     legacyDocs: Array.isArray(project.legacyDocs) ? [...project.legacyDocs] : [],
     createdAt: project.createdAt,
     updatedAt: project.updatedAt,
     lastAnalyzedAt: project.lastAnalyzedAt ?? null,
+    lastScanAt: project.lastScanAt ?? null,
+    lastScanHead: project.lastScanHead ?? null,
     lastJournalAt: project.lastJournalAt ?? null,
     lastGitHead: project.lastGitHead ?? null,
     confidence: project.confidence ?? "auto",
+    autoCreated: project.autoCreated === true,
   };
 }
 
@@ -259,16 +265,15 @@ function findProject(registry, cwd) {
   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;
+/** Stable identity across moves: git remote first, normalized path second. */
+function fingerprintFor(root) {
+  const git = gitInfo(root);
+  return git?.remote ? `git:${git.remote}` : `path:${normalizePath(root)}`;
+}
+
+function findProjectByFingerprint(registry, fingerprint) {
+  if (!fingerprint || fingerprint.startsWith("path:")) return undefined;
+  return registry.projects.find((project) => project.fingerprint === fingerprint);
 }
 
 function defaultProjectFiles(project) {
@@ -363,7 +368,7 @@ function defaultProjectFiles(project) {
 function ensureProjectDossier(project, options = {}) {
   const directory = path.join(MEMORY_ROOT, project.slug);
   try {
-    fs.mkdirSync(path.join(directory, "JOURNAL"), { recursive: true });
+    ensurePrivateDir(path.join(directory, "JOURNAL"));
     const files = defaultProjectFiles(project);
     for (const [name, content] of Object.entries(files)) {
       const target = path.join(directory, name);
@@ -396,6 +401,19 @@ function createProject(registry, { name, root, stack, legacyDocs, autoCreated, c
   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);
+  const fingerprint = fingerprintFor(resolvedRoot);
+  const twin = findProjectByFingerprint(registry, fingerprint);
+  if (twin) {
+    if (!twin.roots.some((entry) => normalizePath(entry) === normalizePath(resolvedRoot))) {
+      twin.roots = [resolvedRoot, ...twin.roots].slice(0, 8);
+    }
+    twin.updatedAt = nowIso();
+    twin.fingerprint = fingerprint;
+    saveRegistry(registry);
+    ensureProjectDossier(twin);
+    logAccess(`project-merged slug=${twin.slug} root=${resolvedRoot}`);
+    return projectPublic(twin);
+  }
   let slug = slugify(name);
   let counter = 2;
   while (registry.projects.some((project) => project.slug === slug) || exists(path.join(MEMORY_ROOT, slug))) {
@@ -406,11 +424,15 @@ function createProject(registry, { name, root, stack, legacyDocs, autoCreated, c
     slug,
     name: name.trim(),
     roots: [resolvedRoot],
+    fingerprint,
     legacyDocs: Array.isArray(legacyDocs) ? legacyDocs.slice(0, 20) : [],
     stack: typeof stack === "string" ? stack.slice(0, 200) : undefined,
     createdAt: nowIso(),
     updatedAt: nowIso(),
     lastAnalyzedAt: null,
+    lastScanAt: null,
+    lastScanHead: null,
+    scanVersion: null,
     lastJournalAt: null,
     lastGitHead: null,
     confidence: confidence ?? (autoCreated ? "auto" : "manual"),
@@ -423,17 +445,81 @@ function createProject(registry, { name, root, stack, legacyDocs, autoCreated, c
   return projectPublic(project);
 }
 
+const scanChecked = new Map();
+
+function loadScan(project) {
+  try {
+    const parsed = JSON.parse(readText(path.join(dossierDir(project), SCAN_FILE)));
+    if (!parsed || parsed.version !== SCAN_VERSION) return undefined;
+    return parsed;
+  } catch {
+    return undefined;
+  }
+}
+
+function scanIsFresh(project, settings) {
+  if (!project.lastScanAt) return false;
+  const ttl = Math.max(1, Number(settings.scanTtlHours) || 24) * 3600 * 1000;
+  if (Date.now() - Date.parse(project.lastScanAt) > ttl) return false;
+  const git = project.roots?.[0] ? gitInfo(project.roots[0]) : undefined;
+  return !(git && project.lastScanHead && git.head !== project.lastScanHead);
+}
+
+/** Local scan + auto blocks in the dossier. Never throws into the prompt path. */
+function scanNow(registry, project, reason = "auto") {
+  const record = registry.projects.find((item) => item.slug === project.slug);
+  if (!record) return undefined;
+  const facts = scanProject(record.roots[0]);
+  writeText(path.join(dossierDir(record), SCAN_FILE), `${JSON.stringify(facts, null, 2)}\n`);
+  const blocks = renderAutoSections(facts);
+  for (const [file, block] of Object.entries(blocks)) {
+    const target = path.join(dossierDir(record), SECTION_FILES[file]);
+    writeText(target, mergeAutoBlock(readText(target), block));
+  }
+  record.lastScanAt = facts.scannedAt;
+  record.lastScanHead = facts.git?.head ?? null;
+  record.scanVersion = facts.version;
+  record.stack = (facts.stack?.labels ?? []).join(" · ").slice(0, 200) || record.stack;
+  record.updatedAt = nowIso();
+  saveRegistry(registry);
+  rebuildIndex(record);
+  logAccess(`scan slug=${record.slug} reason=${reason} files=${facts.stats?.files ?? 0} warnings=${facts.warnings?.length ?? 0}`);
+  return facts;
+}
+
+function ensureScanned(registry, project, options = {}) {
+  const record = registry.projects.find((item) => item.slug === project.slug);
+  if (!record || registry.settings.autoScan !== true) return projectPublic(record ?? project);
+  const checked = scanChecked.get(record.slug);
+  if (!options.force && checked && Date.now() - checked < SCAN_CHECK_MS) return projectPublic(record);
+  scanChecked.set(record.slug, Date.now());
+  if (!options.force && scanIsFresh(record, registry.settings)) return projectPublic(record);
+  try {
+    scanNow(registry, record, options.reason ?? "auto");
+  } catch (error) {
+    logAccess(`scan-error slug=${record.slug} ${truncate(String(error), 200)}`);
+  }
+  return projectPublic(record);
+}
+
 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 (known) return ensureScanned(registry, known);
   if (settings.autoRegister !== true) return undefined;
-  const detected = detectProjectRoot(cwd);
+  const detected = detectProject(cwd)?.root;
   if (!detected) return undefined;
   if (isInside(MEMORY_ROOT, detected)) return undefined;
-  const name = path.basename(detected);
-  return createProject(registry, { name, root: detected, autoCreated: true });
+  const home = path.resolve(process.env.USERPROFILE || process.env.HOME || "");
+  if (home && normalizePath(detected) === normalizePath(home)) return undefined;
+  if (path.dirname(detected) === detected) return undefined;
+  if (registry.projects.length >= (Number(settings.maxProjects) || 200)) {
+    logAccess(`auto-register-skipped reason=max-projects cwd=${normalizePath(cwd)}`);
+    return undefined;
+  }
+  const created = createProject(registry, { name: path.basename(detected), root: detected, autoCreated: true });
+  return ensureScanned(registry, created, { reason: "first-seen" });
 }
 
 function sessionCwd(session) {
@@ -555,12 +641,15 @@ function rebuildIndex(project) {
     sections.push({ file: name, bytes: exists(target) ? fs.statSync(target).size : 0 });
   }
   const git = project.roots.length > 0 ? gitInfo(project.roots[0]) : undefined;
+  const scan = loadScan(project);
   const index = {
     slug: project.slug,
     name: project.name,
     roots: project.roots,
+    stack: project.stack ?? null,
     generatedAt: nowIso(),
     sections,
+    scan: scan ? { at: scan.scannedAt, stack: scan.stack?.labels ?? [], warnings: scan.warnings ?? [] } : null,
     lastAnalyzedAt: project.lastAnalyzedAt ?? null,
     lastJournalAt: project.lastJournalAt ?? null,
     lastGitHead: git ? `${git.branch}@${git.head}` : null,
@@ -598,35 +687,91 @@ function bulletLines(text, limit) {
     .map((line) => truncate(line.replace(/^[-*]\s+/u, "- "), 220));
 }
 
+const RECALL_STOP = new Set([
+  "этого", "этот", "этой", "чтобы", "когда", "после", "перед", "можно", "нужно", "надо",
+  "сделай", "сделать", "проект", "проекта", "проекте", "код", "файл", "файлы", "задача",
+  "задачи", "задачу", "есть", "было", "будет", "тоже", "только", "через", "всё", "все",
+  "please", "with", "this", "that", "from", "into", "with", "your", "have", "will", "make",
+]);
+
+function taskKeywords(text) {
+  const words = String(text ?? "").toLowerCase().match(/[a-zа-яё0-9_-]{4,}/gu) ?? [];
+  return [...new Set(words)].filter((word) => !RECALL_STOP.has(word)).slice(0, 6);
+}
+
+/** Top dossier lines that mention the current request; local and bounded. */
+function recallForTask(project, text, limit = 3) {
+  const words = taskKeywords(text);
+  if (words.length === 0) return [];
+  const hits = [];
+  for (const word of words) {
+    for (const hit of searchDossier(project, word, 6)) {
+      const line = String(hit.text ?? "").trim();
+      if (/\.json$/u.test(hit.file)) continue;
+      if (/^- (?:Команды|Сессия|Изменённые файлы|Ошибки\/сбои|Память обновлена)(?=\s|:|$)/u.test(line)) continue;
+      if (line.length < 18 || /^#|AUTO-SCAN|<!--/u.test(line)) continue;
+      if (hits.some((item) => item.text === line)) continue;
+      hits.push({ ...hit, text: line });
+      if (hits.length >= limit) return hits.map((item) => `- ${item.file}:${item.line} — ${truncate(item.text, 180)}`);
+    }
+  }
+  return hits.map((item) => `- ${item.file}:${item.line} — ${truncate(item.text, 180)}`);
+}
+
+function hashText(text) {
+  let hash = 0;
+  const value = String(text ?? "");
+  for (let index = 0; index < value.length; index += 1) hash = (hash * 31 + value.charCodeAt(index)) | 0;
+  return hash;
+}
+
 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 facts = loadScan(project);
+  if (facts) {
+    const summary = scanSummary(facts);
+    if (summary.length > 0) {
+      parts.push("Автоскан проекта:");
+      parts.push(...summary.slice(0, 7));
+    }
+  } else {
+    parts.push("Автоскан ещё не выполнен: project_memory action=scan (локально, без сети).");
+  }
   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);
+  const invariants = bulletLines(readText(path.join(dossierDir(project), "INVARIANTS.md")), 5);
   if (invariants.length > 0) {
     parts.push("Инварианты и запреты:");
     parts.push(...invariants);
   }
-  const gotchas = bulletLines(readText(path.join(dossierDir(project), "GOTCHAS.md")), 6);
+  const gotchas = bulletLines(readText(path.join(dossierDir(project), "GOTCHAS.md")), 4);
   if (gotchas.length > 0) {
     parts.push("Известные грабли:");
     parts.push(...gotchas);
   }
-  const journal = latestJournalExcerpt(project);
+  const sessionState = state[sessionId];
+  const userText = sessionState?.lastUserText || sessionState?.firstUserText || "";
+  if (settings.autoRecall !== false && userText.length > 0) {
+    const recall = recallForTask(project, userText, 3);
+    if (recall.length > 0) {
+      parts.push("Похоже на текущую задачу (из досье, проверь):");
+      parts.push(...recall);
+    }
+  }
+  const journal = latestJournalExcerpt(project, 480);
   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 action=brief (карточка), read file=... или search query=.... Не перечитывай файлы, если факт уже здесь; устаревшее обновляй через update_section. Для глубокого анализа — скилл project-deep-dive.");
   parts.push("</project-memory>");
   let text = parts.join("\n");
   if (text.length > budget) text = `${truncate(text, budget)}\n</project-memory>`;
@@ -641,7 +786,7 @@ class DigestCache {
 
   signature(project) {
     const directory = dossierDir(project);
-    const files = ["PROJECT.md", "ARCHITECTURE.md", "CODE-MAP.md", "INVARIANTS.md", "GOTCHAS.md", "RUNBOOK.md", "INDEX.json"];
+    const files = ["PROJECT.md", "ARCHITECTURE.md", "CODE-MAP.md", "INVARIANTS.md", "GOTCHAS.md", "RUNBOOK.md", "INDEX.json", SCAN_FILE];
     let stamp = "";
     for (const name of files) {
       const target = path.join(directory, name);
@@ -695,6 +840,7 @@ function sessionEntry(state, sessionId) {
       commands: [],
       errors: [],
       firstUserText: "",
+      lastUserText: "",
       memoryUpdatedTurns: [],
       journaledTurns: [],
       pendingReminder: null,
@@ -749,14 +895,17 @@ function trackSessionEvent(ctx, registry, state, session, event) {
     if (entry.errors.length > 8) entry.errors.shift();
     return;
   }
-  if (event.type === "user/message" && entry.firstUserText.length === 0) {
+  if (event.type === "user/message") {
     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);
+    if (!injected && cleaned.length > 0) {
+      entry.lastUserText = truncate(cleaned, 400);
+      if (entry.firstUserText.length === 0) entry.firstUserText = truncate(cleaned, 160);
+    }
     return;
   }
   if (event.type === "workspace/changes") {
@@ -822,7 +971,7 @@ 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 session = agent?.session ?? (agent?.id && typeof deps.getSession === "function" ? deps.getSession(agent.id) : undefined);
   const action = typeof args?.action === "string" ? args.action : "";
   const sessionId = agent?.id ? String(agent.id) : undefined;
   try {
@@ -833,14 +982,35 @@ async function runTool(deps, args, exec) {
         stack: typeof args.stack === "string" ? args.stack : undefined,
         legacyDocs: Array.isArray(args.legacyDocs) ? args.legacyDocs.filter((value) => typeof value === "string") : undefined,
       });
+      let scan;
+      try { scan = scanNow(registry, project, "register"); } catch (error) { logAccess(`scan-error register ${truncate(String(error), 200)}`); }
       markMemoryUpdated(state, sessionId);
-      return jsonResult(`Проект «${project.name}» зарегистрирован. Досье: ${project.dossier}`, { project, created: true });
+      return jsonResult(`Проект «${project.name}» зарегистрирован. Досье: ${project.dossier}${scan ? `\nАвтоскан: ${(scanSummary(scan).slice(0, 5).join("; "))}` : ""}`, { project, created: true, scan: scan ? { stack: scan.stack?.labels ?? [], warnings: scan.warnings ?? [] } : null });
     }
     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 ? "есть" : "нет"}`);
+      const lines = registry.projects.map((project) => `- ${project.slug} — ${project.name} · ${project.roots[0] ?? "?"}${project.stack ? ` · ${project.stack}` : ""} · скан: ${project.lastScanAt ?? "не было"} · анализ: ${project.lastAnalyzedAt ?? "не было"}`);
       return jsonResult(`Проекты (${registry.projects.length}):\n${lines.join("\n")}`, { projects: registry.projects.map(projectPublic) });
     }
+    if (action === "brief") {
+      const project = projectFromArgs(deps, args, session);
+      let facts = loadScan(project);
+      if (!facts && registry.settings.autoScan !== false) {
+        try { facts = scanNow(registry, project, "brief"); } catch (error) { logAccess(`scan-error brief ${truncate(String(error), 200)}`); }
+      }
+      const invariants = bulletLines(readText(path.join(dossierDir(project), "INVARIANTS.md")), 3);
+      const gotchas = bulletLines(readText(path.join(dossierDir(project), "GOTCHAS.md")), 3);
+      const journal = latestJournalExcerpt(project, 300);
+      const text = renderBrief(facts, project, { invariants, gotchas, journal, dossier: projectPublic(project).dossier });
+      return jsonResult(text, { project, scan: facts ? { stack: facts.stack?.labels ?? [], warnings: facts.warnings ?? [] } : null });
+    }
+    if (action === "scan") {
+      const project = projectFromArgs(deps, args, session);
+      const facts = scanNow(registry, project, "tool");
+      const summary = scanSummary(facts).slice(0, 10);
+      markMemoryUpdated(state, sessionId);
+      return jsonResult([`Автоскан «${project.name}» обновлён: ${facts.stats?.files ?? 0} файлов, ${facts.warnings?.length ?? 0} предупреждений.`, ...summary].join("\n"), { project, scan: facts });
+    }
     if (action === "status") {
       const project = projectFromArgs(deps, args, session);
       const fresh = freshness(project);
@@ -849,16 +1019,21 @@ async function runTool(deps, args, exec) {
         const target = path.join(directory, name);
         return `${name}: ${exists(target) ? fs.statSync(target).size : 0} B`;
       });
+      const facts = loadScan(project);
+      const digest = buildDigest(registry, project, sessionId ?? "", registry.settings, state);
       const text = [
         `Проект: «${project.name}» (${project.slug})`,
         `Корень: ${project.roots.join(", ")}`,
         `Досье: ${directory}`,
+        `Стек: ${project.stack ?? facts?.stack?.labels?.join(" · ") ?? "не определён"}`,
         `Свежесть: ${fresh.text}`,
+        `Автоскан: ${project.lastScanAt ?? "не было"}${facts?.warnings?.length ? ` · предупреждений: ${facts.warnings.length}` : ""}`,
+        `Дайджест: ~${Math.round(digest.length / 3.2)} токенов (${digest.length} символов)`,
         `Связанная память: ${(project.legacyDocs ?? []).join("; ") || "нет"}`,
         `Разделы: ${sizes.join("; ")}`,
-        `Настройки: бюджет дайджеста ${settings.digestBudgetChars} символов, авто-регистрация ${settings.autoRegister ? "вкл" : "выкл"}`,
+        `Настройки: бюджет ${settings.digestBudgetChars} символов, авто-регистрация ${settings.autoRegister ? "вкл" : "выкл"}, автоскан ${settings.autoScan ? "вкл" : "выкл"}`,
       ].join("\n");
-      return jsonResult(text, { project, freshness: fresh });
+      return jsonResult(text, { project, freshness: fresh, scan: facts ? { at: facts.scannedAt, warnings: facts.warnings } : null });
     }
     if (action === "read") {
       const project = projectFromArgs(deps, args, session);
@@ -918,8 +1093,8 @@ const TOOL_PARAMETERS = {
   properties: {
     action: {
       type: "string",
-      enum: ["status", "list", "read", "search", "append_journal", "update_section", "register"],
-      description: "status|list|read|search|append_journal|update_section|register",
+      enum: ["status", "brief", "list", "read", "search", "scan", "append_journal", "update_section", "register"],
+      description: "status|brief|list|read|search|scan|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." },
@@ -948,7 +1123,7 @@ 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.",
+      "Local long-term project memory. The plugin auto-detects the project from cwd, scans manifests/docs locally and injects a compact digest. Use brief for a one-screen card, status for freshness, read/search for details, scan to refresh the local recon, update_section/append_journal to record durable facts, register only when auto-detection is wrong. Never store secrets or PII; link to files instead of copying code.",
     parameters: TOOL_PARAMETERS,
     timeoutMs: 20000,
     output: {
@@ -973,7 +1148,7 @@ function makeToolDefinition(deps) {
 export async function apply(ctx) {
   const logger = ctx.logger;
   try {
-    fs.mkdirSync(MEMORY_ROOT, { recursive: true });
+    ensurePrivateDir(MEMORY_ROOT);
   } catch (error) {
     logger?.warn?.(`[project-memory] cannot create ${MEMORY_ROOT}: ${String(error)}`);
   }
@@ -981,7 +1156,12 @@ export async function apply(ctx) {
   const state = loadState();
   const digestCache = new DigestCache();
   const curatorTimers = new Map();
-  const deps = { registry, state, digestCache };
+  const deps = {
+    registry,
+    state,
+    digestCache,
+    getSession: (id) => (typeof id === "string" ? ctx.get("sessions")?.get(id) : undefined),
+  };
 
   /** Effective cwd of a session: projection first, durable header second. */
   const workingDirectory = ctx.get("workingDirectory");
@@ -1019,7 +1199,8 @@ export async function apply(ctx) {
         if (!project) return "";
         const signature = digestCache.signature(project);
         const sessionId = String(session.id);
-        const key = `${sessionId}:${project.slug}`;
+        const userText = state[sessionId]?.lastUserText ?? state[sessionId]?.firstUserText ?? "";
+        const key = `${sessionId}:${project.slug}:${hashText(userText)}`;
         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;
@@ -1228,6 +1409,68 @@ ${summary}
     }
   });
 
+  /* ---------------- user command /memory ---------------- */
+  ctx.inject(["commands"], (commandCtx) => {
+    try {
+      const dispose = commandCtx.commands.register({
+        name: "memory",
+        description: "Локальная память проекта: статус, карточка, автоскан, вкл/выкл",
+        input: { hint: "status | brief | scan | on | off | projects" },
+        recordInput: false,
+        handler: ({ agent, rawInput }) => {
+          const session = agent?.session;
+          const command = String(rawInput ?? "").trim().toLowerCase();
+          try {
+            if (command === "projects") {
+              if (registry.projects.length === 0) return { kind: "success", text: "Пока нет проектов: открой папку проекта — он зарегистрируется автоматически." };
+              return { kind: "success", text: registry.projects.map((project) => `- ${project.slug} — ${project.name}${project.stack ? ` · ${project.stack}` : ""} · скан: ${project.lastScanAt ?? "не было"}`).join("\n") };
+            }
+            if (command === "on" || command === "off") {
+              registry.settings.autoRegister = command === "on";
+              registry.settings.autoScan = command === "on";
+              saveRegistry(registry);
+              return { kind: "success", text: `Память проектов: авто-регистрация и автоскан ${command === "on" ? "включены" : "выключены"}.` };
+            }
+            const project = session ? resolveProjectForSession(registry, session, registry.settings, { cwd: effectiveCwd(session) }) : undefined;
+            if (!project) return { kind: "success", text: "Проект не определён: открой папку с маркером проекта (.git, package.json, composer.json, artisan…)." };
+            if (command === "scan") {
+              const facts = scanNow(registry, project, "command");
+              return { kind: "success", text: `Автоскан «${project.name}» обновлён.\n${scanSummary(facts).slice(0, 8).join("\n")}` };
+            }
+            if (command === "brief") {
+              const facts = loadScan(project);
+              const invariants = bulletLines(readText(path.join(dossierDir(project), "INVARIANTS.md")), 3);
+              const gotchas = bulletLines(readText(path.join(dossierDir(project), "GOTCHAS.md")), 3);
+              return { kind: "success", text: renderBrief(facts, project, { invariants, gotchas, journal: latestJournalExcerpt(project, 260), dossier: projectPublic(project).dossier }) };
+            }
+            const facts = loadScan(project);
+            const fresh = freshness(project);
+            const digest = buildDigest(registry, project, String(session.id), registry.settings, state);
+            return {
+              kind: "success",
+              text: [
+                `Проект: «${project.name}» (${project.slug})`,
+                `Корень: ${project.roots[0] ?? "?"}`,
+                `Досье: ${projectPublic(project).dossier}`,
+                `Свежесть: ${fresh.text}`,
+                `Стек: ${project.stack ?? facts?.stack?.labels?.join(" · ") ?? "не определён"}`,
+                `Автоскан: ${project.lastScanAt ?? "не было"}${facts?.warnings?.length ? ` · предупреждений: ${facts.warnings.length}` : ""}`,
+                `Дайджест: ~${Math.round(digest.length / 3.2)} токенов`,
+                "Команды: /memory brief | scan | on | off | projects",
+              ].join("\n"),
+            };
+          } catch (error) {
+            return { kind: "error", text: `Память проекта: ${error instanceof Error ? error.message : String(error)}` };
+          }
+        },
+      });
+      ctx.effect(() => dispose, "project-memory: /memory command");
+      logAccess("command-registered name=memory");
+    } catch (error) {
+      logger?.warn?.(`[project-memory] /memory registration failed: ${String(error)}`);
+    }
+  });
+
   /* ---------------- cleanup ---------------- */
   ctx.effect(() => () => {
     for (const timer of curatorTimers.values()) clearTimeout(timer);