@agfpd/iapeer-memory-core 0.2.7 → 0.2.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer-memory-core",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "iapeer-memory core — host-neutral TypeScript memory primitive: vault schema/taxonomy config, search engine, memoryd, context renderer, role contracts. Consumed by the @agfpd/iapeer-memory facade; version kept in lockstep by its release flow (docs/10-distribution.md).",
   "license": "MIT",
   "type": "module",

package/src/archive.ts

@@ -0,0 +1,88 @@
+/**
+ * Deterministic archiving — lean §2.2a.
+ *
+ * In lean, archiving leaves the Index overlay and becomes BASE (0 LLM): a
+ * note whose `status` is a FINAL token (`isStale` — устарело/завершён/…; «на
+ * паузе» is PENDING, not stale → a resumable note is never archived) is moved
+ * to the archive folder by memoryd. The decision is taxonomy, not judgement.
+ *
+ * Wikilinks resolve by TITLE, so the graph survives the move (edges are
+ * reindexed); the archive is NOT excluded from search (it stays findable with
+ * the stale boost). The move is flat (`07_Archive/<basename>`), collisions
+ * resolved with a numeric suffix.
+ */
+
+import path from "node:path";
+import { isStale, type TaxonomyPreset } from "./taxonomy.js";
+
+/** First path segment of a vault-relative path. */
+function firstSegment(relPath: string): string {
+  return relPath.split(/[\\/]/)[0] ?? "";
+}
+
+/**
+ * Folders whose notes are subject to archiving — UNIFIED rule, no exceptions
+ * (decision Артур 15.06, §2.2a): the six monitored content folders (five
+ * canonical permanent + agent memory + `03_Projects`). NOT the archive
+ * itself, the inboxes, or the system folder. A completed phase/project
+ * (status `completed`/`cancelled`) is stale like any other note and moves to
+ * the archive; active `03_Projects` then shows only live work. Wikilinks
+ * survive by title; the archive stays searchable.
+ */
+export function isArchivableZone(relPath: string, taxonomy: TaxonomyPreset): boolean {
+  const f = taxonomy.folders;
+  const head = firstSegment(relPath);
+  return (
+    head === f.knowledge ||
+    head === f.decisions ||
+    head === f.projects ||
+    head === f.ideas ||
+    head === f.lists ||
+    head === f.agentMemory
+  );
+}
+
+/** Read `status` from a note's frontmatter (null when absent/no frontmatter). */
+export function statusOf(content: string): string | null {
+  const fm = /^---[^\S\n]*\n([\s\S]*?)\n---/.exec(content);
+  if (!fm) return null;
+  const m = /^status\s*:\s*(.+?)\s*$/m.exec(fm[1]);
+  return m ? m[1].trim() : null;
+}
+
+/**
+ * Should this note be archived? In an archivable content zone AND carrying a
+ * final (stale) status. Notes already in the archive are excluded by
+ * `isArchivableZone` (the archive folder is not in the set).
+ */
+export function shouldArchive(
+  relPath: string,
+  content: string,
+  taxonomy: TaxonomyPreset,
+): boolean {
+  if (!isArchivableZone(relPath, taxonomy)) return false;
+  return isStale(taxonomy, statusOf(content));
+}
+
+/**
+ * Flat archive target (vault-relative): `<archive>/<basename>`, with a numeric
+ * suffix on collision (`<stem>-2.md`, `-3.md`, …). `exists` answers whether a
+ * vault-relative path is already taken.
+ */
+export function archiveTargetRel(
+  basename: string,
+  taxonomy: TaxonomyPreset,
+  exists: (rel: string) => boolean,
+): string {
+  const arch = taxonomy.folders.archive;
+  const isMd = basename.endsWith(".md");
+  const stem = isMd ? basename.slice(0, -3) : basename;
+  const ext = isMd ? ".md" : "";
+  let candidate = `${arch}/${basename}`;
+  let n = 2;
+  while (exists(candidate)) {
+    candidate = `${arch}/${stem}-${n}${ext}`;
+    n += 1;
+  }
+  return candidate;
+}

package/src/context-render.ts

@@ -74,16 +74,20 @@ export type FragmentEnv = {
   };
   /** Rendered author index file (capped variant), absolute path. */
   authorIndexPath: string;
-  /** Tags-dictionary mirror, absolute path (Index branch only). */
-  tagsDictionaryPath?: string;
+  /** Compact tags-dictionary projection, absolute path — injected to EVERY
+   *  author in lean (§3), not just the Index. */
+  tagsProjectionPath?: string;
+  /** Layer title for the projection (the dictionary file name, e.g. `Теги.md`);
+   *  defaults to the projection file basename. */
+  tagsTitle?: string;
 };
 
 /**
  * Assemble the per-peer fragment layers in the reference build_layers
- * order. Author branch: paths → author index. Index branch: paths → tags
- * dictionary → own index (the curator gets no writer guide — its contract
- * is the role doctrine; the guide arrives host-wide by layer mechanics).
- * Missing/empty sources are skipped gracefully.
+ * order: paths → tags-dictionary projection (lean §3: ALL authors now, not
+ * only the Index) → author index. The curator gets no writer guide — its
+ * contract is the role doctrine; the guide arrives host-wide by layer
+ * mechanics. Missing/empty sources are skipped gracefully.
  */
 export function buildLayers(env: FragmentEnv): ContextLayer[] {
   const layers: ContextLayer[] = [];
@@ -101,11 +105,11 @@ export function buildLayers(env: FragmentEnv): ContextLayer[] {
   ].join("\n");
   layers.push(["iapeer-memory paths", pathsBlock]);
 
-  const isIndex = env.agent === (env.indexAgent ?? "index");
-
-  if (isIndex && env.tagsDictionaryPath) {
-    const tags = readFileOrEmpty(env.tagsDictionaryPath);
-    if (tags.trim()) layers.push([path.basename(env.tagsDictionaryPath), tags]);
+  if (env.tagsProjectionPath) {
+    const tags = readFileOrEmpty(env.tagsProjectionPath);
+    if (tags.trim()) {
+      layers.push([env.tagsTitle || path.basename(env.tagsProjectionPath), tags]);
+    }
   }
 
   const idx = readFileOrEmpty(env.authorIndexPath);

package/src/frontmatter-fill.ts

@@ -42,7 +42,7 @@ import fs from "node:fs";
 import path from "node:path";
 import crypto from "node:crypto";
 import type { TaxonomyPreset } from "./taxonomy.js";
-import { DEFAULT_CURATOR_SET } from "./taxonomy.js";
+import { DEFAULT_CURATOR_SET, genreForFolder, linksSectionPattern } from "./taxonomy.js";
 import { guardedWriteFileSync, guardedUnlinkSync } from "./fs-guard.js";
 
 const FRONTMATTER_RE = /^---[^\S\n]*\n([\s\S]*?\n)---[^\S\n]*(?:\n|$)/;
@@ -96,6 +96,70 @@ export function setIfMissing(block: string, key: string, value: string): string
   return `${block}${key}: ${value}\n`;
 }
 
+/** Read a scalar field value, or null when absent. */
+export function readScalar(block: string, key: string): string | null {
+  const m = new RegExp(`^${escapeRe(key)}\\s*:\\s*(.+?)\\s*$`, "m").exec(block);
+  return m ? m[1].trim() : null;
+}
+
+/** Parse a YAML list field (block-list `  - item` or inline `[a, b]`). */
+export function parseListField(block: string, key: string): string[] {
+  const lines = block.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const m = new RegExp(`^${escapeRe(key)}\\s*:\\s*(.*)$`).exec(lines[i]);
+    if (!m) continue;
+    const inline = m[1].trim();
+    if (inline) {
+      return inline
+        .replace(/^\[/, "")
+        .replace(/\]$/, "")
+        .split(",")
+        .map((s) => s.trim().replace(/^["']|["']$/g, ""))
+        .filter(Boolean);
+    }
+    const out: string[] = [];
+    for (let j = i + 1; j < lines.length; j++) {
+      const item = /^\s+-\s+(.*)$/.exec(lines[j]);
+      if (!item) break;
+      const v = item[1].trim().replace(/^["']|["']$/g, "");
+      if (v) out.push(v);
+    }
+    return out;
+  }
+  return [];
+}
+
+/** Remove a list field entirely (its `key:` line + any `  - item` lines). */
+function removeListField(block: string, key: string): string {
+  const lines = block.split("\n");
+  const out: string[] = [];
+  const head = new RegExp(`^${escapeRe(key)}\\s*:`);
+  for (let i = 0; i < lines.length; i++) {
+    if (head.test(lines[i])) {
+      // skip the key line and the following block-list items
+      while (i + 1 < lines.length && /^\s+-\s/.test(lines[i + 1])) i++;
+      continue;
+    }
+    out.push(lines[i]);
+  }
+  return out.join("\n");
+}
+
+/**
+ * Append `name` to `coauthors` (lean §3a auto-coauthor). No-op if already
+ * present. Rewrites the field as a normalised block-list at the end of the
+ * frontmatter — idempotent once the name is in the list.
+ */
+export function addCoauthor(block: string, name: string): string {
+  const existing = parseListField(block, "coauthors");
+  if (existing.includes(name)) return block;
+  let b = removeListField(block, "coauthors");
+  if (b && !b.endsWith("\n")) b += "\n";
+  const all = [...existing, name];
+  b += "coauthors:\n" + all.map((n) => `  - ${n}`).join("\n") + "\n";
+  return b;
+}
+
 /** Returns [fmBlock, rest]. No frontmatter → ["", content]. */
 export function splitFrontmatter(content: string): [string, string] {
   const m = FRONTMATTER_RE.exec(content);
@@ -197,14 +261,64 @@ export function fillInbox(
   return fmBlock;
 }
 
-export function fillPermanent(
+/**
+ * Full permanent-zone (canon) fill — the lean §2 «страж» core, SHARED between
+ * the post-write hook (`processFile`) and the human-edit detector
+ * (`decideUpdate`), so an agent's write and a human's external write get
+ * identical deterministic frontmatter (mandate §2: «ОБЩАЯ логика из 2 путей»).
+ *
+ * Before lean the permanent branch was a near-empty stamp (canon frontmatter
+ * was supplied by the Index on placement). In lean the author writes only
+ * body + tags + organic inline links + a self-describing title; everything
+ * here is derived deterministically (0 LLM):
+ *   - `title` ← file name; `type`/`status` ← the FOLDER's genre (§2.1);
+ *     `created` ← today; `author` ← the writer (non-curator);
+ *   - `last_edited_by`/`updated` ← the stamp pair (always upserted).
+ */
+export function fillPermanentFull(
   fmBlock: string,
-  opts: { agent: string; nowStamp: string; ctx: FillContext },
+  opts: {
+    path: string;
+    agent: string;
+    vault: string;
+    today: string;
+    nowStamp: string;
+    ctx: FillContext;
+  },
 ): string {
+  const { taxonomy } = opts.ctx;
+  // Service stamp (always) — load-bearing for smart-hash echo-safety and the
+  // unstamped detector, symmetric with fillInbox/fillMemory.
   fmBlock = upsert(fmBlock, "last_edited_by", opts.agent);
   fmBlock = upsert(fmBlock, "updated", opts.nowStamp);
+  // Canon frontmatter the author no longer hand-writes (§2.1). setIfMissing —
+  // an explicit author value is never clobbered; a re-edit of an existing note
+  // is a stamp-only no-op on these.
+  fmBlock = setIfMissing(fmBlock, "title", basenameNoExt(opts.path));
+  const folder = opts.vault ? relParts(opts.path, opts.vault)?.[0] : undefined;
+  const genre = folder ? genreForFolder(taxonomy, folder) : null;
+  if (genre) {
+    fmBlock = setIfMissing(fmBlock, "type", genre.type);
+    fmBlock = setIfMissing(fmBlock, "status", genre.initialStatus);
+  }
+  fmBlock = setIfMissing(fmBlock, "created", opts.today);
+  // AUTHOR GUARD (Артур's invariant; fork-1 decision boris 15.06, §3a): a
+  // curator (Index/Scriber/DreamWeaver) edits canon STRUCTURE, never authors
+  // content — it never becomes `author` (nor, L2, `coauthors`). Same guard as
+  // the inbox branch. A non-curator writing canon IS the author. `needs_review`
+  // is the guard's flag, lifted only by Index/human.
   if (!isCurator(opts.agent, opts.ctx)) {
+    fmBlock = setIfMissing(fmBlock, "author", opts.agent);
     fmBlock = upsert(fmBlock, "needs_review", "true");
+    // §3a auto-coauthor: a non-curator who edits a canon note authored by
+    // SOMEONE ELSE is recorded as a coauthor — content collaboration that
+    // kills duplicates. Curators are excluded (fork-1 boris 15.06: they edit
+    // STRUCTURE, not content — same guard as the author guard). `author` is
+    // immutable; only `coauthors` grows. On a NEW note author===agent → no-op.
+    const author = readScalar(fmBlock, "author");
+    if (author && author !== opts.agent) {
+      fmBlock = addCoauthor(fmBlock, opts.agent);
+    }
   }
   return fmBlock;
 }
@@ -417,6 +531,71 @@ export function normalizeFields(
   return lines.join("\n");
 }
 
+/**
+ * YAML-safe normalisation of EVERY scalar frontmatter field (lean §2.2). Before
+ * lean only `description` was normalised; the «`: ` inside a plain scalar»
+ * failure (incident 49/538 unparseable) applies to ANY field — title, status,
+ * author, etc. Block-list fields (`tags`, `coauthors`) are EXCLUDED: they use
+ * the `  - item` form, and the inline `[..]`/`: ` heuristic would corrupt them.
+ * Idempotent (a clean-quoted value is left untouched).
+ */
+export function normalizeAllScalars(
+  fmBlock: string,
+  excludeKeys: readonly string[] = EMPTY_ARRAY_KEYS,
+): string {
+  const lines = fmBlock.split("\n");
+  for (let idx = 0; idx < lines.length; idx++) {
+    const m = NORMALIZE_LINE_RE.exec(lines[idx]);
+    if (!m || excludeKeys.includes(m[1])) continue;
+    const newVal = normalizeScalarValue(m[2]);
+    if (newVal !== null) lines[idx] = `${m[1]}: ${newVal}`;
+  }
+  return lines.join("\n");
+}
+
+/** Markdown thematic break: `---`, `***`, `___`, optionally spaced. */
+const HR_LINE_RE = /^[ \t]*([-*_])(?:[ \t]*\1){2,}[ \t]*$/;
+
+/**
+ * A line that is a fuzzy match of the links-section heading: any `#` level,
+ * any spacing, any case, but the section text EXACTLY (so `## Связанные…`
+ * never matches `## Связи`).
+ */
+function isFuzzyLinksHeading(line: string, taxonomy: TaxonomyPreset): boolean {
+  const sectionText = taxonomy.linksSection.replace(/^#+\s*/, "");
+  const esc = sectionText.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`^#{1,6}\\s*${esc}\\s*$`, "i").test(line.trim());
+}
+
+/**
+ * Make a leading links-section block recognisable to the parser's
+ * `stripLinksSection` (heading at body start + a `---` divider), so the block
+ * is cut from search/embedding content instead of polluting BM25 with
+ * popular-target false hits (lean §2.2). CONSERVATIVE and mechanical (§10.2):
+ * only the heading line FORM and the block's HR divider are rewritten — never
+ * content, nothing inserted or moved. Body without a leading links heading →
+ * no-op. Idempotent.
+ */
+export function normalizeLinksBlock(body: string, taxonomy: TaxonomyPreset): string {
+  const lines = body.split("\n");
+  let i = 0;
+  while (i < lines.length && lines[i].trim() === "") i++;
+  if (i >= lines.length || !isFuzzyLinksHeading(lines[i], taxonomy)) return body;
+  if (lines[i] !== taxonomy.linksSection) lines[i] = taxonomy.linksSection;
+  // Normalise the block's first HR divider to `---`. Scan only across the link
+  // list (`- …` / `* …` items and blanks); a content line means no divider —
+  // leave it (the heading fix alone is the safe part).
+  for (let j = i + 1; j < lines.length; j++) {
+    if (HR_LINE_RE.test(lines[j])) {
+      if (lines[j].trim() !== "---") lines[j] = "---";
+      break;
+    }
+    const t = lines[j].trim();
+    if (t !== "" && !t.startsWith("-") && !t.startsWith("*")) break;
+  }
+  return lines.join("\n");
+}
+
 /**
  * Assemble the new file. A body not starting with a newline gets one, so the
  * markdown parser sees the frontmatter separately from the first paragraph.
@@ -509,10 +688,19 @@ export function processFile(filePath: string, opts: ProcessOptions): boolean {
   const [fmBlock, rest] = splitFrontmatter(content);
 
   let newFm: string | null;
+  let newBody = rest;
   if (zone === "inbox") {
     newFm = fillInbox(fmBlock, { path: filePath, agent: opts.agent, today, nowStamp, ctx });
   } else if (zone === "permanent") {
-    newFm = fillPermanent(fmBlock, { agent: opts.agent, nowStamp, ctx });
+    newFm = fillPermanentFull(fmBlock, {
+      path: filePath,
+      agent: opts.agent,
+      vault,
+      today,
+      nowStamp,
+      ctx,
+    });
+    newBody = normalizeLinksBlock(rest, opts.taxonomy);
   } else {
     newFm = fillMemory(fmBlock, {
       path: filePath,
@@ -523,11 +711,12 @@ export function processFile(filePath: string, opts: ProcessOptions): boolean {
       ctx,
     });
     if (newFm === null) return false;
+    newBody = normalizeLinksBlock(rest, opts.taxonomy);
   }
 
   newFm = stripEmptyArrays(newFm);
-  newFm = normalizeFields(newFm);
-  const newContent = assemble(newFm, rest);
+  newFm = normalizeAllScalars(newFm);
+  const newContent = assemble(newFm, newBody);
   if (newContent === content) return false;
   atomicWrite(filePath, newContent);
   return true;

package/src/human-edit-detect.ts

@@ -32,6 +32,7 @@
 import crypto from "node:crypto";
 import path from "node:path";
 import type { TaxonomyPreset } from "./taxonomy.js";
+import { fillPermanentFull } from "./frontmatter-fill.js";
 
 export const DEFAULT_FRESH_EDIT_WINDOW_S = 90;
 
@@ -116,6 +117,11 @@ export type DecideUpdateInput = {
   birthtimeMs: number;
   mtimeMs: number;
   basename: string;
+  /** Absolute file path — the permanent branch derives the folder's genre
+   *  (type/status) from it via the shared `fillPermanentFull` (lean §2.1). */
+  path: string;
+  /** Vault root — folder resolution for the genre lookup. */
+  vault: string;
   lastHash: string | null;
   taxonomy: TaxonomyPreset;
   /** Config (default DEFAULT_FRESH_EDIT_WINDOW_S). */
@@ -147,12 +153,14 @@ export function decideUpdate(input: DecideUpdateInput): DecideUpdateResult {
   if (fmMatch) {
     fmBlock = fmMatch[1];
     body = input.content.slice(fmMatch[0].length);
-  } else if (input.zone === "human-inbox") {
+  } else {
+    // Bare body (no frontmatter) — both zones BUILD it now. In lean the guard
+    // must complete a human's bare canon note, not skip it (§2.2: «голое тело
+    // человека страж должен ДОСТРОИТЬ»; the pre-lean «permanent-no-frontmatter
+    // → skip» is removed — canon frontmatter is the guard's job now, not the
+    // Index's on placement).
     fmBlock = "";
     body = input.content;
-  } else {
-    // PERMANENT without frontmatter — not our zone.
-    return { action: "skip", recordHash: null, reason: "permanent-no-frontmatter" };
   }
 
   const lebMatch = /^last_edited_by\s*:\s*(.+?)\s*$/m.exec(fmBlock);
@@ -192,9 +200,21 @@ export function decideUpdate(input: DecideUpdateInput): DecideUpdateResult {
     newFm = setIfMissing(newFm, "author", input.human);
     newFm = setIfMissing(newFm, "needs_review", "true");
   } else {
-    newFm = upsertField(newFm, "last_edited_by", input.human);
-    newFm = upsertField(newFm, "updated", nowStamp);
-    newFm = upsertField(newFm, "needs_review", "true");
+    // PERMANENT (canon) — the SHARED guard fill (mandate §2: identical to the
+    // hook path). Existing notes: stamp-only no-op on the constants; a human's
+    // bare-body canon note: full frontmatter (title/type-from-folder/status/
+    // created/author). `created` ← birthtime (file creation, not edit time).
+    const createdSource =
+      input.birthtimeMs > 0 ? new Date(input.birthtimeMs) : new Date(input.mtimeMs);
+    const createdDate = createdSource.toISOString().slice(0, 10);
+    newFm = fillPermanentFull(newFm, {
+      path: input.path,
+      agent: input.human,
+      vault: input.vault,
+      today: createdDate,
+      nowStamp,
+      ctx: { taxonomy: input.taxonomy },
+    });
   }
 
   if (newFm === fmBlock) {

package/src/index.ts

@@ -20,17 +20,52 @@ export {
   getTaxonomy,
   isLocaleId,
   defaultExcludeFolders,
+  genreForFolder,
+  isStale,
+  statusGroup,
   DEFAULT_CURATOR_SET,
   DEFAULT_RANKING,
   type LocaleId,
   type RankingConfig,
   type TaxonomyPreset,
+  type TaxonomyInitialStatus,
 } from "./taxonomy.js";
 
 // frontmatter: post-write fill + structural fm-update (CLI contract in module header)
-export { processFile, resolveAgentName, type ProcessOptions } from "./frontmatter-fill.js";
+export {
+  processFile,
+  resolveAgentName,
+  splitFrontmatter,
+  resolveZone,
+  type ProcessOptions,
+  type Zone,
+} from "./frontmatter-fill.js";
 export { fmUpdate, collectOps, yamlSafeScalar, type FmUpdateOptions, type Op } from "./fm-update.js";
 
+// deterministic archiving (lean §2.2a)
+export {
+  isArchivableZone,
+  statusOf,
+  shouldArchive,
+  archiveTargetRel,
+} from "./archive.js";
+export { snapshotVault } from "./permanent-detect.js";
+
+// tag gate + injected dictionary projection (lean §3)
+export { tagsDictionarySourceRel } from "./tags-mirror.js";
+export {
+  parseDictionaryEntries,
+  parseDictionaryTags,
+  isTagAllowed,
+  parseNoteTags,
+  tagGateProblems,
+  renderTagsProjection,
+  DEFAULT_TAGS_BOUNDARY_MAXLEN,
+  type DictionaryEntry,
+  type TagGateOptions,
+  type ProjectionOptions,
+} from "./tags-gate.js";
+
 // author index rendering
 export { regenerateVaultIndex, fullIndexPathFor, type RenderContext } from "./index-render.js";
 

package/src/memoryd.ts

@@ -39,8 +39,11 @@ import type { CoreConfig } from "./config.js";
 import { openDatabase, type CoreDb } from "./db.js";
 import { indexAll } from "./indexer.js";
 import { runSearch, runGraph, runMap } from "./mcp-tools.js";
+import { runDedup } from "./search.js";
 import { decideUpdate, getZone, sha256 } from "./human-edit-detect.js";
 import { decideMirror, tagsDictionarySourceRel } from "./tags-mirror.js";
+import { renderTagsProjection, DEFAULT_TAGS_BOUNDARY_MAXLEN } from "./tags-gate.js";
+import { isArchivableZone, shouldArchive, archiveTargetRel } from "./archive.js";
 import {
   snapshotVault,
   snapshotInbox,
@@ -353,6 +356,39 @@ export async function startMcpHttp(opts: {
   const httpServer = http.createServer((req, res) => {
     void (async () => {
       const url = (req.url ?? "").split("?")[0];
+      // Dedup hint (lean §3a) — a memoryd-INTERNAL RPC for the post-write hook,
+      // NOT an MCP tool (the MCP surface stays the three read tools). Loopback
+      // (host is 127.0.0.1) + read-only. The hook calls it fail-open with a
+      // short timeout, so a slow/down memoryd never hangs a write.
+      if (url === "/dedup" && req.method === "POST") {
+        const chunks: Buffer[] = [];
+        req.on("data", (c) => chunks.push(c as Buffer));
+        await new Promise<void>((resolve) => req.on("end", () => resolve()));
+        try {
+          const body = JSON.parse(Buffer.concat(chunks).toString("utf-8")) as {
+            content?: string;
+            threshold?: number;
+            limit?: number;
+          };
+          const content = (body.content ?? "").trim();
+          const result = content
+            ? await runDedup(opts.db, opts.config, {
+                content,
+                threshold: body.threshold,
+                limit: body.limit,
+              })
+            : { enabled: Boolean(opts.config.embedding), matches: [] };
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(result));
+        } catch (err) {
+          logger.error(`dedup request failed: ${String(err)}`);
+          if (!res.headersSent) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ enabled: false, matches: [], error: "internal error" }));
+          }
+        }
+        return;
+      }
       if (url !== "/mcp") {
         res.writeHead(404, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ error: "not found; MCP endpoint is /mcp" }));
@@ -531,6 +567,9 @@ export type MemorydOptions = {
   heartbeatPath?: string;
   /** Tags mirror target; default `<db dir>/tags-dictionary.md`. */
   tagsMirrorPath?: string;
+  /** Compact tags-projection target (injected to all peers, lean §3);
+   *  default `<db dir>/tags-projection.md`. */
+  tagsProjectionPath?: string;
   /** Detect-hash persistence file; default `<db dir>/memoryd.hashes.json`. */
   hashStatePath?: string;
   /** Persisted batch baselines (inbox + permanent + human-inbox snapshots). */
@@ -597,6 +636,9 @@ export async function startMemoryd(opts: MemorydOptions): Promise<MemorydHandle>
   const dbDir = path.dirname(config.index.dbPath);
   const heartbeatPath = opts.heartbeatPath ?? path.join(dbDir, "memoryd.heartbeat");
   const tagsMirrorPath = opts.tagsMirrorPath ?? path.join(dbDir, "tags-dictionary.md");
+  const tagsProjectionPath = opts.tagsProjectionPath ?? path.join(dbDir, "tags-projection.md");
+  const tagsBoundaryMaxLen =
+    Number(process.env.IAPEER_MEMORY_TAGS_BOUNDARY_MAXLEN) || DEFAULT_TAGS_BOUNDARY_MAXLEN;
   const hashStatePath = opts.hashStatePath ?? path.join(dbDir, "memoryd.hashes.json");
   const persistMs = opts.persistMs ?? 60_000;
   const taxonomy = config.taxonomy;
@@ -745,7 +787,10 @@ export async function startMemoryd(opts: MemorydOptions): Promise<MemorydHandle>
             indexAgent,
             paths: fragments.paths,
             authorIndexPath: outFile,
-            tagsDictionaryPath: peer.personality === indexAgent ? tagsMirrorPath : undefined,
+            // lean §3: the compact dictionary projection is injected to EVERY
+            // author now (pre-lean: only the Index got the full mirror).
+            tagsProjectionPath,
+            tagsTitle: taxonomy.systemFiles.tagsDictionary,
           },
         });
         rendered++;
@@ -785,12 +830,36 @@ export async function startMemoryd(opts: MemorydOptions): Promise<MemorydHandle>
       mirrorContent = null;
     }
     const decision = decideMirror({ srcContent, mirrorContent });
-    if (decision.action !== "write") return;
-    fs.mkdirSync(path.dirname(tagsMirrorPath), { recursive: true });
-    const tmp = `${tagsMirrorPath}.tmp`;
-    guardedWriteFileSync(tmp, srcContent!, "utf-8");
-    fs.renameSync(tmp, tagsMirrorPath);
-    logger.info(`tags mirror updated (${decision.reason})`);
+    if (decision.action === "write") {
+      fs.mkdirSync(path.dirname(tagsMirrorPath), { recursive: true });
+      const tmp = `${tagsMirrorPath}.tmp`;
+      guardedWriteFileSync(tmp, srcContent!, "utf-8");
+      fs.renameSync(tmp, tagsMirrorPath);
+      mirrorContent = srcContent;
+      logger.info(`tags mirror updated (${decision.reason})`);
+    }
+    // Refresh the compact projection from the (up-to-date) mirror — even when
+    // the mirror was unchanged, so the projection materialises on first run
+    // after the feature ships (lean §3). Idempotent: writes only on a change.
+    syncTagsProjection(mirrorContent);
+  }
+
+  function syncTagsProjection(mirrorContent: string | null): void {
+    if (!mirrorContent || !mirrorContent.trim()) return; // no dict → keep existing
+    const proj = renderTagsProjection(mirrorContent, { boundaryMaxLen: tagsBoundaryMaxLen });
+    if (!proj.trim()) return;
+    let existing: string | null = null;
+    try {
+      existing = fs.readFileSync(tagsProjectionPath, "utf-8");
+    } catch {
+      existing = null;
+    }
+    if (existing === proj) return;
+    fs.mkdirSync(path.dirname(tagsProjectionPath), { recursive: true });
+    const tmp = `${tagsProjectionPath}.tmp`;
+    guardedWriteFileSync(tmp, proj, "utf-8");
+    fs.renameSync(tmp, tagsProjectionPath);
+    logger.info("tags projection updated");
   }
 
   /** Zone map of the unstamped detector (design §3): the agent inbox +
@@ -901,6 +970,8 @@ export async function startMemoryd(opts: MemorydOptions): Promise<MemorydHandle>
         birthtimeMs: stat.birthtime ? stat.birthtime.getTime() : 0,
         mtimeMs: stat.mtime.getTime(),
         basename: path.basename(filePath),
+        path: filePath,
+        vault: config.vaultPath,
         lastHash: lastSeenHashes.get(filePath) ?? null,
         taxonomy,
         freshEditWindowS: opts.freshEditWindowS,
@@ -926,6 +997,44 @@ export async function startMemoryd(opts: MemorydOptions): Promise<MemorydHandle>
     }
   }
 
+  /**
+   * Deterministic archiving (lean §2.2a): move stale notes among the changed
+   * files to the archive folder. Runs AFTER humanEditPass (a note just marked
+   * stale carries its stamp). The move is invisible to permanent-detect
+   * (deletions are ignored; the archive is outside `monitoredFolders`), and
+   * `indexAll` below reconciles the path change (drops the source, indexes the
+   * archived copy — still searchable with the stale boost). Returns the count.
+   */
+  function archiveStaleNotes(candidatesAbs: Set<string>): number {
+    let moved = 0;
+    for (const abs of candidatesAbs) {
+      const rel = path.relative(config.vaultPath, abs);
+      if (!isArchivableZone(rel, taxonomy)) continue;
+      let content: string;
+      try {
+        content = fs.readFileSync(abs, "utf-8");
+      } catch {
+        continue; // deleted mid-debounce
+      }
+      if (!shouldArchive(rel, content, taxonomy)) continue;
+      const targetRel = archiveTargetRel(path.basename(abs), taxonomy, (r) =>
+        fs.existsSync(path.join(config.vaultPath, r)),
+      );
+      const targetAbs = path.join(config.vaultPath, targetRel);
+      try {
+        fs.mkdirSync(path.dirname(targetAbs), { recursive: true });
+        fs.renameSync(abs, targetAbs);
+        silentStamps.delete(rel); // baselines follow the move
+        lastSeenHashes.delete(abs);
+        moved += 1;
+        logger.info(`archived (stale): ${rel} → ${targetRel}`);
+      } catch (err) {
+        logger.error(`archive failed for ${rel}: ${String(err)}`);
+      }
+    }
+    return moved;
+  }
+
   // ── fs.watch + debounce ──
   const pending = new Set<string>();
   let flushTimer: ReturnType<typeof setTimeout> | null = null;
@@ -981,6 +1090,7 @@ export async function startMemoryd(opts: MemorydOptions): Promise<MemorydHandle>
     }
 
     humanEditPass(changed);
+    archiveStaleNotes(changed); // lean §2.2a — stale → archive before reindex
     syncTagsMirror();
     await indexAll({ db, config, logger }); // incremental by content hash
     renderFleetFragments("vault-change"); // docs/05: свежесть за секунды

package/src/search.ts

@@ -255,6 +255,52 @@ export async function runVaultSearch(params: {
   return { results, pipeline };
 }
 
+export type DedupMatch = { path: string; title: string; similarity: number };
+
+export const DEFAULT_DEDUP_THRESHOLD = 0.82;
+
+/**
+ * Dedup hint (lean §3a): given the content of a CANON note being written,
+ * find existing CANON notes with raw cosine similarity ≥ threshold. SEMANTIC
+ * by design — with embeddings disabled it returns `{enabled:false}` and the
+ * caller stays SILENT (a noisy BM25 overlap is worse than nothing; the author
+ * has memory_search). Read-only; operative/inbox matches are excluded (a
+ * canon note is not a duplicate of someone's operative note). Title = file
+ * basename (the guard sets `title` from the file name), so the caller can
+ * render `[[title]]`.
+ */
+export async function runDedup(
+  db: CoreDb,
+  config: CoreConfig,
+  params: { content: string; threshold?: number; limit?: number },
+): Promise<{ enabled: boolean; matches: DedupMatch[] }> {
+  if (!config.embedding) return { enabled: false, matches: [] };
+  const threshold = params.threshold ?? DEFAULT_DEDUP_THRESHOLD;
+  const limit = Math.max(1, params.limit ?? 5);
+  const q = await embedQuery(params.content, config.embedding);
+  if (!q.vector) return { enabled: true, matches: [] }; // embed failed / circuit-open → silent
+  const raw = vectorSearch(db, q.vector, limit * 3); // headroom for the canon filter
+  const f = config.taxonomy.folders;
+  const canonHeads = new Set([
+    f.knowledge,
+    f.decisions,
+    f.projects,
+    f.ideas,
+    f.lists,
+    f.archive,
+  ]);
+  const matches: DedupMatch[] = [];
+  for (const r of raw) {
+    if (r.score < threshold) continue;
+    const head = r.path.split("/")[0];
+    if (!canonHeads.has(head)) continue; // canon (+archive) only
+    const base = r.path.split("/").pop() ?? r.path;
+    matches.push({ path: r.path, title: base.replace(/\.md$/, ""), similarity: r.score });
+    if (matches.length >= limit) break;
+  }
+  return { enabled: true, matches };
+}
+
 // --- Vector search ---
 //
 // Hot path: `vec_chunks` virtual table from sqlite-vec, MATCH+ORDER BY runs

package/src/tags-gate.ts

@@ -0,0 +1,174 @@
+/**
+ * Tag gate + injected dictionary projection — lean §3.
+ *
+ * In lean the author tags canon notes THEMSELVES from a controlled vocabulary
+ * (`99_System/Tags.md`). Two deterministic jobs (0 LLM) live here:
+ *
+ *  1. GATE (`tagGateProblems`): the guard validates a canon note's tags
+ *     against the dictionary — an unknown tag is NOT accepted; the author is
+ *     told to register it in the dictionary first (a deliberate step that
+ *     kills drift: `security` vs `Безопасность`). ≥1 tag is required on canon;
+ *     operative notes carry none. PostToolUse fires AFTER the write, so the
+ *     «rejection» is: keep `needs_review` + teach the author to fix it next
+ *     step (§2.3 NB).
+ *
+ *  2. PROJECTION (`renderTagsProjection`): the dictionary is now injected to
+ *     EVERY author (pre-lean: only the Index). The injected form is a COMPACT,
+ *     budgeted projection — names always, the boundary ONLY where the
+ *     dictionary author wrote one (overlapping domains needing disambiguation;
+ *     `—` marks self-evident tags → name only). Token cost is ×the whole
+ *     fleet, so the full curator table stays the SOURCE and only this slice is
+ *     injected (§3, §11).
+ *
+ * The dictionary is a markdown table: `| Tag | Boundary (optional) |`. Parsing
+ * is locale-independent (no header label hard-coded): a header row is the one
+ * immediately followed by the `|---|` separator.
+ */
+
+export const DEFAULT_TAGS_BOUNDARY_MAXLEN = 160;
+
+/** A `|---|`-style table separator cell. */
+function isSeparatorCell(cell: string): boolean {
+  return /^:?-{2,}:?$/.test(cell.trim());
+}
+
+/** Split a markdown table row into trimmed cells (outer pipes dropped). */
+function tableCells(line: string): string[] | null {
+  const t = line.trim();
+  if (!t.startsWith("|")) return null;
+  // Drop the leading and (if present) trailing pipe, then split.
+  const inner = t.replace(/^\|/, "").replace(/\|\s*$/, "");
+  return inner.split("|").map((c) => c.trim());
+}
+
+export type DictionaryEntry = { name: string; boundary: string };
+
+/**
+ * Parse the dictionary table into entries (name + boundary). Skips header rows
+ * (a row whose NEXT line is a separator) and separator rows. Generic over any
+ * number of tables/sections. A `—`/`-`/empty boundary means «self-evident».
+ */
+export function parseDictionaryEntries(dictContent: string): DictionaryEntry[] {
+  const lines = dictContent.split("\n");
+  const entries: DictionaryEntry[] = [];
+  for (let i = 0; i < lines.length; i++) {
+    const cells = tableCells(lines[i]);
+    if (!cells || cells.length === 0) continue;
+    const name = cells[0];
+    if (!name || isSeparatorCell(name)) continue;
+    // Header row: the next non-empty line is a separator.
+    const nextCells = i + 1 < lines.length ? tableCells(lines[i + 1]) : null;
+    if (nextCells && nextCells.length && isSeparatorCell(nextCells[0])) continue;
+    const boundaryRaw = (cells[1] ?? "").trim();
+    const boundary = boundaryRaw === "—" || boundaryRaw === "-" ? "" : boundaryRaw;
+    entries.push({ name, boundary });
+  }
+  return entries;
+}
+
+/** Just the valid tag names (the gate's allow-set). */
+export function parseDictionaryTags(dictContent: string): string[] {
+  return parseDictionaryEntries(dictContent).map((e) => e.name);
+}
+
+/**
+ * A note tag is valid when it (or its root before `/`) is in the dictionary —
+ * subtags (`Бизнес/Грузоперевозки`) inherit their root's membership (§3, the
+ * `Бизнес` boundary documents the subtag convention).
+ */
+export function isTagAllowed(tag: string, allow: ReadonlySet<string>): boolean {
+  if (allow.has(tag)) return true;
+  const root = tag.split("/")[0];
+  return root !== tag && allow.has(root);
+}
+
+/** Extract tags from a frontmatter block — block-list and inline-array forms. */
+export function parseNoteTags(fmBlock: string): string[] {
+  const lines = fmBlock.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const m = /^tags\s*:\s*(.*)$/.exec(lines[i]);
+    if (!m) continue;
+    const inline = m[1].trim();
+    if (inline) {
+      // inline array `[A, B]` or a bare scalar.
+      const arr = inline.replace(/^\[/, "").replace(/\]$/, "");
+      return arr
+        .split(",")
+        .map((s) => s.trim().replace(/^["']|["']$/g, ""))
+        .filter(Boolean);
+    }
+    // block-list form: following `  - item` lines.
+    const out: string[] = [];
+    for (let j = i + 1; j < lines.length; j++) {
+      const item = /^\s+-\s+(.*)$/.exec(lines[j]);
+      if (!item) break;
+      const v = item[1].trim().replace(/^["']|["']$/g, "");
+      if (v) out.push(v);
+    }
+    return out;
+  }
+  return [];
+}
+
+export type TagGateOptions = {
+  /** Canon requires ≥1 tag; operative/other zones do not. */
+  requireAtLeastOne: boolean;
+  /** Vault-relative dictionary path, for the teaching message. */
+  dictionaryRel: string;
+};
+
+/**
+ * Validate a note's tags against the dictionary. Returns author-facing problem
+ * lines (empty = clean). The guard stays SILENT when there is nothing to fix
+ * (§2.3); each line names a concrete fix.
+ */
+export function tagGateProblems(
+  noteTags: readonly string[],
+  allow: ReadonlySet<string>,
+  opts: TagGateOptions,
+): string[] {
+  const problems: string[] = [];
+  if (opts.requireAtLeastOne && noteTags.length === 0) {
+    problems.push(
+      `canon note has no tags — add ≥1 from the dictionary (${opts.dictionaryRel}).`,
+    );
+  }
+  for (const tag of noteTags) {
+    if (!isTagAllowed(tag, allow)) {
+      problems.push(
+        `tag "${tag}" is not in the dictionary — register it in ${opts.dictionaryRel} first ` +
+          `(reuse an existing tag if one fits, e.g. by domain), then tag the note.`,
+      );
+    }
+  }
+  return problems;
+}
+
+/** Truncate to `max` chars on a word boundary where possible, adding `…`. */
+function clip(s: string, max: number): string {
+  if (s.length <= max) return s;
+  const cut = s.slice(0, max);
+  const lastSpace = cut.lastIndexOf(" ");
+  return (lastSpace > max * 0.6 ? cut.slice(0, lastSpace) : cut).trimEnd() + "…";
+}
+
+export type ProjectionOptions = {
+  /** Per-tag boundary character budget (×whole fleet, §11). */
+  boundaryMaxLen?: number;
+};
+
+/**
+ * Render the COMPACT injected projection of the dictionary (§3/§11): one tag
+ * per line, `Name` for self-evident tags, `Name — boundary` (clipped to the
+ * budget) for overlapping domains. No table chrome, no frontmatter — the full
+ * curator table stays the source. Returns "" for an empty/unparseable dict.
+ */
+export function renderTagsProjection(dictContent: string, opts: ProjectionOptions = {}): string {
+  const max = opts.boundaryMaxLen ?? DEFAULT_TAGS_BOUNDARY_MAXLEN;
+  const entries = parseDictionaryEntries(dictContent);
+  if (entries.length === 0) return "";
+  const lines = entries.map((e) =>
+    e.boundary ? `${e.name} — ${clip(e.boundary, max)}` : e.name,
+  );
+  return lines.join("\n");
+}

package/src/taxonomy.ts

@@ -59,6 +59,16 @@ export type TaxonomyStatusTokens = {
   current: string;
 };
 
+/**
+ * Initial `status` token a new note of each canonical type carries — the
+ * guard fills `status` on the permanent branch from the FOLDER's type (lean
+ * mode §2.1, «начальный токен типа»). Verified against the live RU vault:
+ * knowledge→актуально, decision→принято, idea→новая, list→актуально,
+ * project→активный, agent_memory→актуально. Every token is a member of
+ * `statuses.active` (parity-tested).
+ */
+export type TaxonomyInitialStatus = Record<keyof TaxonomyTypes, string>;
+
 export type TaxonomyStatuses = {
   /** Current/live lifecycle states — search boost ×activeBoost. */
   active: string[];
@@ -122,6 +132,9 @@ export type TaxonomyPreset = {
   subtypeOrder: string[];
   statuses: TaxonomyStatuses;
   statusTokens: TaxonomyStatusTokens;
+  /** Per-type initial `status` token — the guard fills the permanent branch
+   *  from the folder's type (lean §2.1). */
+  initialStatus: TaxonomyInitialStatus;
   /** Phase status tokens in their project-group render order:
    *  planned → active → paused → completed → cancelled. */
   phaseStatusOrder: string[];
@@ -169,6 +182,14 @@ export const TAXONOMY_EN: TaxonomyPreset = {
     stale: ["outdated", "superseded", "dropped", "completed", "cancelled"],
   },
   statusTokens: { draft: "draft", current: "current" },
+  initialStatus: {
+    knowledge: "current",
+    decision: "accepted",
+    idea: "new",
+    project: "active",
+    list: "current",
+    agentMemory: "current",
+  },
   phaseStatusOrder: ["planned", "active", "paused", "completed", "cancelled"],
   indexStrings: {
     header: "Vault index of notes by",
@@ -246,6 +267,14 @@ export const TAXONOMY_RU: TaxonomyPreset = {
     stale: ["устарело", "заменено", "отброшена", "завершён", "завершена", "отменена"],
   },
   statusTokens: { draft: "черновик", current: "актуально" },
+  initialStatus: {
+    knowledge: "актуально",
+    decision: "принято",
+    idea: "новая",
+    project: "активный",
+    list: "актуально",
+    agentMemory: "актуально",
+  },
   phaseStatusOrder: ["запланирована", "активная", "на паузе", "завершена", "отменена"],
   indexStrings: {
     header: "Vault-индекс заметок автора",
@@ -321,6 +350,51 @@ export function statusGroup(
   return null;
 }
 
+/** True when `status` is a final/closed token — the archiving predicate
+ *  (lean §2.2a: `isStale → move to archive`). Mirrors the search/index
+ *  semantics (`statusGroup === "stale"`); a single source for the memoryd
+ *  archiver and the index renderer. `на паузе`/`paused` are PENDING, not
+ *  stale — a resumable note is never archived. */
+export function isStale(taxonomy: TaxonomyPreset, status: string | null | undefined): boolean {
+  if (!status) return false;
+  return statusGroup(taxonomy, status.trim()) === "stale";
+}
+
+/**
+ * Folder-key → type-key pairing (lean §2.1 «helper выравнивания ключей»):
+ * the two maps are parallel-keyed but differ by plurality
+ * (`decisions`↔`decision`, `ideas`↔`idea`, `lists`↔`list`,
+ * `projects`↔`project`). `agentMemory` is paired too — the memory zone reuses
+ * the same alignment. Inbox/archive/system have no canonical type.
+ */
+const FOLDER_TYPE_PAIRS: ReadonlyArray<[keyof TaxonomyFolders, keyof TaxonomyTypes]> = [
+  ["knowledge", "knowledge"],
+  ["decisions", "decision"],
+  ["projects", "project"],
+  ["ideas", "idea"],
+  ["lists", "list"],
+  ["agentMemory", "agentMemory"],
+];
+
+/**
+ * Genre (type + initial status) declared by a vault FOLDER name — the guard
+ * derives `type` and the starting `status` from the note's position (lean
+ * §2.1: «Папка = объявление жанра»). `folderName` is the first path segment
+ * relative to the vault. Returns null for folders without a canonical type
+ * (both inboxes, archive, system) — the caller fills no type/status there.
+ */
+export function genreForFolder(
+  taxonomy: TaxonomyPreset,
+  folderName: string,
+): { type: string; initialStatus: string } | null {
+  for (const [fKey, tKey] of FOLDER_TYPE_PAIRS) {
+    if (taxonomy.folders[fKey] === folderName) {
+      return { type: taxonomy.types[tKey], initialStatus: taxonomy.initialStatus[tKey] };
+    }
+  }
+  return null;
+}
+
 /**
  * Default search-index exclusions: both inboxes (raw drafts, possibly without
  * frontmatter) and the system folder (templates/dictionary, not content).