@agfpd/iapeer-memory-core 0.2.8 → 0.3.0

package/src/mode.ts

@@ -0,0 +1,76 @@
+/**
+ * Lean §7/§7.1 — mode + per-role proactivity resolution.
+ *
+ * The toggle gates the curation OVERLAY's PROACTIVITY (notifier triggers /
+ * memoryd curation emits), NOT the existence of anything: the role peers
+ * (Index/Scriber/DreamWeaver) are ALWAYS provisioned and callable on-demand in
+ * either mode, and memoryd (страж detector + archive + projection render +
+ * /dedup) ALWAYS runs (its watcher trigger launches it — base infra, never
+ * gated). What the mode gates is whether the curation pipeline FIRES by itself.
+ *
+ * Default resolution: `IAPEER_MEMORY_MODE` ABSENT → `curated` — a host
+ * provisioned before this feature ran curated, and must never be silently
+ * flipped to lean (§10.3). A NEW install's `init` WRITES the key (default
+ * `lean`), so new hosts read lean. Per-role env overrides the preset:
+ * `IAPEER_MEMORY_PROACTIVE_{INDEX,SCRIBER,DREAMWEAVER}` = on|off (independent
+ * toggles over the preset, §7).
+ */
+
+export type MemoryMode = "lean" | "curated";
+export type RoleSet = { index: boolean; scriber: boolean; dreamweaver: boolean };
+
+const TRUE_TOKENS = new Set(["1", "on", "true", "yes", "y"]);
+const FALSE_TOKENS = new Set(["0", "off", "false", "no", "n"]);
+
+function toggle(raw: string | undefined, preset: boolean): boolean {
+  const v = (raw ?? "").trim().toLowerCase();
+  if (TRUE_TOKENS.has(v)) return true;
+  if (FALSE_TOKENS.has(v)) return false;
+  return preset; // unset / unrecognised → follow the mode preset
+}
+
+export function resolveMode(env: Record<string, string | undefined> = process.env): {
+  mode: MemoryMode;
+  roles: RoleSet;
+} {
+  const raw = (env.IAPEER_MEMORY_MODE ?? "").trim().toLowerCase();
+  // absent / "curated" / anything-not-"lean" → curated (legacy preservation).
+  const mode: MemoryMode = raw === "lean" ? "lean" : "curated";
+  const preset = mode === "curated";
+  return {
+    mode,
+    roles: {
+      index: toggle(env.IAPEER_MEMORY_PROACTIVE_INDEX, preset),
+      scriber: toggle(env.IAPEER_MEMORY_PROACTIVE_SCRIBER, preset),
+      dreamweaver: toggle(env.IAPEER_MEMORY_PROACTIVE_DREAMWEAVER, preset),
+    },
+  };
+}
+
+/**
+ * Curation proactivity derived from the role set (§7.1 matrix). The memoryd
+ * WATCHER trigger is deliberately NOT here — it ALWAYS registers (it launches
+ * memoryd; the base needs memoryd in both modes). This is exactly what the
+ * toggle gates ON TOP of the always-on watcher.
+ */
+export type CurationPlan = {
+  /** memoryd emits the curation event (CURATOR_TICK) — ONLY when a proactive
+   *  receiver exists (scriber ∥ index). Full-lean → suppressed (the watcher
+   *  then forwards nothing). */
+  emit: boolean;
+  /** The watcher's forward target, §7.1 conditional: scriber → else index →
+   *  else null (no proactive receiver; placeholder, nothing is emitted). */
+  eventTarget: string | null;
+  /** Register the weekly dream-tick timer (→ dreamweaver) — decoupled from
+   *  the Index (§7.1 key #2); only if dreamweaver is proactive. */
+  dream: boolean;
+};
+
+export function curationPlan(roles: RoleSet): CurationPlan {
+  const eventTarget = roles.scriber ? "scriber" : roles.index ? "index" : null;
+  return {
+    emit: eventTarget !== null,
+    eventTarget,
+    dream: roles.dreamweaver,
+  };
+}

package/src/permanent-detect.ts

@@ -75,85 +75,7 @@ export function diffSnapshots(prev: VaultSnapshot, next: VaultSnapshot): string[
   return changed.sort();
 }
 
-export type PermanentChangedEvent = {
-  kind: "PERMANENT_CHANGED";
-  /** Coalesced list of changed vault-relative paths (ADR-004). */
-  paths: string[];
-};
-
-/**
- * One detection pass: diff the current vault state against the previous
- * snapshot. Returns the coalesced event (or null when nothing changed)
- * plus the snapshot to carry into the next pass.
- */
-export function detectPermanentChanges(opts: {
-  vault: string;
-  taxonomy: TaxonomyPreset;
-  prev: VaultSnapshot;
-}): { event: PermanentChangedEvent | null; next: VaultSnapshot } {
-  const next = snapshotVault(opts.vault, opts.taxonomy);
-  const paths = diffSnapshots(opts.prev, next);
-  return {
-    event: paths.length ? { kind: "PERMANENT_CHANGED", paths } : null,
-    next,
-  };
-}
-
-/**
- * Render the event as memoryd stdout signal lines (one per path — the
- * notifier forwards each line verbatim; the Index batches the visible
- * burst in one turn, and the coalescing above already bounds the burst to
- * one pass).
- */
-export function formatEventLines(event: PermanentChangedEvent): string[] {
-  return event.paths.map((p) => `PERMANENT_CHANGED: ${p}`);
-}
-
-/**
- * Inbox snapshot: draft basename → smart hash (top-level `.md` only —
- * drafts live flat). Same smart-hash mechanics as the permanent snapshot:
- * service-field re-stamps are invisible, content edits are events.
- *
- * WHY hash-diff and not a name baseline (B-приёмка 10.06, boris): the
- * original name-set baseline made a draft INVISIBLE FOREVER once it
- * survived a memoryd restart, and silently broke the reject→fix→re-review
- * cycle (an author's fix never re-entered the pipeline). The reference
- * semantics «the Index catches pre-existing drafts up at its own start»
- * died with the inversion — the Index no longer scans the inbox; the
- * fail-open sweep covers pre-existing UNCHANGED drafts, the hash-diff
- * covers everything else.
- */
-export function snapshotFlatFolder(dir: string): VaultSnapshot {
-  const snapshot: VaultSnapshot = new Map();
-  let entries: fs.Dirent[];
-  try {
-    entries = fs.readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return snapshot;
-  }
-  for (const e of entries) {
-    if (!e.isFile() || !e.name.endsWith(".md")) continue;
-    const h = hashFile(path.join(dir, e.name));
-    if (h) snapshot.set(e.name, h);
-  }
-  return snapshot;
-}
-
-export function snapshotInbox(vault: string, taxonomy: TaxonomyPreset): VaultSnapshot {
-  return snapshotFlatFolder(path.join(vault, taxonomy.folders.inbox));
-}
-
-/**
- * One inbox detection pass: new or semantically changed drafts since the
- * previous snapshot (deletions ignored — a placement move by the Index).
- * Scans the WHOLE inbox folder, independent of which fs.watch path
- * triggered the flush — no dependency on watch filename fidelity.
- */
-export function detectInboxChanges(opts: {
-  vault: string;
-  taxonomy: TaxonomyPreset;
-  prev: VaultSnapshot;
-}): { names: string[]; next: VaultSnapshot } {
-  const next = snapshotInbox(opts.vault, opts.taxonomy);
-  return { names: diffSnapshots(opts.prev, next), next };
-}
+// The daemon coalesces a detection pass into ONE batch event (CURATOR_TICK)
+// by diffing `snapshotVault` against the carried baseline directly — see
+// `runCuratorTick` in memoryd.ts. The earlier per-line event helper was
+// vestigial and removed with the inbox pipeline.

package/src/search.ts

@@ -22,7 +22,7 @@ import { escapeFtsQuery, queryTokens } from "./utils.js";
 import { agentMemoryFolderMarker, statusGroup } from "./taxonomy.js";
 
 /**
- * Per-step pipeline status, прокидывается наверх в response vault_search,
+ * Per-step pipeline status, прокидывается наверх в response memory_search,
  * чтобы агент-вызыватель видел в каком режиме отработал поиск (полный
  * пайплайн / BM25-only из-за деградации эмбеддингов / без reranker).
  *
@@ -62,7 +62,7 @@ const SNIPPET_LEAD_CHARS = 40;
 const EMPTY_NOTE_SNIPPET = "(пустой каркас — в заметке нет содержимого)";
 // How many top-degree related notes to surface per result. Was unbounded —
 // hub notes (e.g. a project Plan note) inflated payload to ~10KB on a 6-result
-// search. Agents can call vault_graph for the full neighborhood.
+// search. Agents can call memory_related for the full neighborhood.
 const RELATED_LIMIT = 3;
 
 // --- Frontmatter status categories & ranking coefficients ---
@@ -255,6 +255,76 @@ export async function runVaultSearch(params: {
   return { results, pipeline };
 }
 
+export type DedupMatch = { path: string; title: string; similarity: number };
+
+/** Dup band lower bound — raw cosine ≥ this ⇒ «possible duplicate» (§3a).
+ *  0.78 confirmed by Артур (15.06) on live TEI calibration: paraphrase
+ *  0.81–0.88 caught, related-but-different ~0.72 excluded; 0.82 clipped heavy
+ *  paraphrase at 0.815. Env-overridable (`IAPEER_MEMORY_DEDUP_THRESHOLD`). */
+export const DEFAULT_DEDUP_THRESHOLD = 0.78;
+
+/** Link-hint band lower bound — cosine in [this, DEDUP_THRESHOLD) ⇒
+ *  «semantically close, maybe link» (§3b, Артур 15.06). HONEST framing: catches
+ *  semantically SIMILAR notes, NOT complementary ones (a real link at cosine
+ *  ~0.54 is missed) — additive to the Index's link saturation (§8), not a
+ *  replacement. Env-overridable. */
+export const DEFAULT_LINK_HINT_THRESHOLD = 0.68;
+
+/**
+ * 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; linkThreshold?: number },
+): Promise<{ enabled: boolean; matches: DedupMatch[] }> {
+  if (!config.embedding) return { enabled: false, matches: [] };
+  const threshold = params.threshold ?? DEFAULT_DEDUP_THRESHOLD;
+  // §3b: when a link-band lower bound is given, `threshold` is the DUP-band
+  // bound and `linkThreshold` the LINK-band bound; each band gets its OWN cap so
+  // a burst of ≥`limit` dup matches never starves the link band (both are
+  // returned, the caller re-classifies by similarity). Without it → legacy
+  // single-band behaviour (identical to before).
+  const linkThreshold = params.linkThreshold;
+  const lower = linkThreshold !== undefined ? Math.min(linkThreshold, threshold) : 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 * 6); // headroom: canon filter + two bands
+  const f = config.taxonomy.folders;
+  const canonHeads = new Set([
+    f.knowledge,
+    f.decisions,
+    f.projects,
+    f.ideas,
+    f.lists,
+    f.archive,
+  ]);
+  const dup: DedupMatch[] = [];
+  const link: DedupMatch[] = [];
+  for (const r of raw) {
+    if (r.score < lower) break; // raw is cosine-descending → below the lowest band, done
+    const head = r.path.split("/")[0];
+    if (!canonHeads.has(head)) continue; // canon (+archive) only
+    const base = r.path.split("/").pop() ?? r.path;
+    const m: DedupMatch = { path: r.path, title: base.replace(/\.md$/, ""), similarity: r.score };
+    if (r.score >= threshold) {
+      if (dup.length < limit) dup.push(m);
+    } else if (linkThreshold !== undefined && r.score >= linkThreshold) {
+      if (link.length < limit) link.push(m);
+    }
+    if (dup.length >= limit && (linkThreshold === undefined || link.length >= limit)) break;
+  }
+  return { enabled: true, matches: [...dup, ...link] };
+}
+
 // --- Vector search ---
 //
 // Hot path: `vec_chunks` virtual table from sqlite-vec, MATCH+ORDER BY runs

package/src/silent-edit-detect.ts

@@ -14,19 +14,11 @@
  * our response re-stamp echo-safe BY CONSTRUCTION: a re-stamp touches only
  * service fields, so it never re-triggers the detector or the batch diffs.
  *
- * ZONED rule (the humanEditPass intersection, §3a of the design):
- *   permanent — ONLY the fresh-window case (stamp ≤ FRESH_EDIT_WINDOW_S):
- *     that is exactly the echo-window swallow; STALE cases stay with
- *     humanEditPass (human attribution — the Obsidian main case; a wider
- *     rule would regress «Артур правит кураторскую заметку»);
- *   inbox — UNCONDITIONAL: humanEditPass does not cover the agent inbox at
- *     all, human edits there are marginal, and the curator-masquerade
- *     (memoryd's 822-suppress) plus the silent author edit are both closed
- *     by one branch. PRECONDITION (the 11.06 false-positive lesson, boris's
- *     Write+Edit repro): the rule is only a discriminator because fillInbox
- *     UPSERTS the stamp pair on every hook edit — before that fix the pair
- *     was identically (null, null) for author drafts, «stamp unmoved» held
- *     vacuously and every second legitimate edit re-stamped as unstamped.
+ * ZONED rule (the humanEditPass intersection, §3a of the design): the canon
+ * folders (five typed + project notes + agent memory) — ONLY the fresh-window
+ * case (stamp ≤ FRESH_EDIT_WINDOW_S): that is exactly the echo-window swallow;
+ * STALE cases stay with humanEditPass (human attribution — the Obsidian main
+ * case; a wider rule would regress «Артур правит кураторскую заметку»).
  *
  * Attribution token: `unstamped` — NEUTRAL on purpose (the mechanism
  * cannot tell a Bash agent from a human outside Obsidian; a false «agent»
@@ -49,7 +41,7 @@ import { smartHash } from "./smart-hash.js";
 
 export const UNSTAMPED_TOKEN = "unstamped";
 
-export type SilentZone = "permanent" | "inbox";
+export type SilentZone = "permanent";
 
 /** The per-file baseline record (design §4): the SEMANTIC hash (the BASE
  *  precondition — without it an iCloud mtime-echo inside the fresh window
@@ -87,18 +79,17 @@ export type DecideSilentInput = {
 };
 
 /**
- * BASE: the semantic hash MOVED ∧ the stamp pair did not move verbatim.
- * Zone branch: permanent → only when the standing stamp is FRESH (the
- * echo-window swallow); inbox → unconditional. A service-only change
- * (hook echo, our own re-stamp) keeps the semantic hash still → never
- * silent; an mtime-only event keeps content identical → never silent.
+ * BASE: the semantic hash MOVED ∧ the stamp pair did not move verbatim,
+ * and only when the standing stamp is FRESH (the echo-window swallow). A
+ * service-only change (hook echo, our own re-stamp) keeps the semantic hash
+ * still → never silent; an mtime-only event keeps content identical → never
+ * silent.
  */
 export function isSilentEdit(input: DecideSilentInput): boolean {
   if (input.prev.hash === input.curr.hash) return false; // BASE: no semantic move
   const stampUnmoved =
     input.prev.updated === input.curr.updated && input.prev.leb === input.curr.leb;
   if (!stampUnmoved) return false;
-  if (input.zone === "inbox") return true;
   const windowS = input.freshEditWindowS ?? DEFAULT_FRESH_EDIT_WINDOW_S;
   const editAt = parseUpdated(input.curr.updated);
   return editAt !== null && (input.nowMs - editAt) / 1000 < windowS;

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

@@ -22,8 +22,6 @@ export type LocaleId = "en" | "ru";
 export type StatusGroup = "active" | "pending" | "stale";
 
 export type TaxonomyFolders = {
-  inbox: string;
-  inboxHuman: string;
   knowledge: string;
   decisions: string;
   projects: string;
@@ -53,12 +51,22 @@ export type TaxonomySubtypes = {
 
 /** Individual status tokens the WRITER side must emit (hook fills). */
 export type TaxonomyStatusTokens = {
-  /** Initial status of a new inbox draft. */
+  /** The draft status token (pending group) — author-settable WIP marker. */
   draft: string;
   /** Initial status of a new agent-memory note. */
   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 +130,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[];
@@ -136,8 +147,6 @@ export type TaxonomyPreset = {
 export const TAXONOMY_EN: TaxonomyPreset = {
   locale: "en",
   folders: {
-    inbox: "00_Inbox",
-    inboxHuman: "00_Inbox_Human",
     knowledge: "01_Knowledge",
     decisions: "02_Decisions",
     projects: "03_Projects",
@@ -169,6 +178,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",
@@ -211,8 +228,6 @@ export const TAXONOMY_EN: TaxonomyPreset = {
 export const TAXONOMY_RU: TaxonomyPreset = {
   locale: "ru",
   folders: {
-    inbox: "00_Входящие",
-    inboxHuman: "00_Входящие_человек",
     knowledge: "01_Знания",
     decisions: "02_Решения",
     projects: "03_Проекты",
@@ -246,6 +261,14 @@ export const TAXONOMY_RU: TaxonomyPreset = {
     stale: ["устарело", "заменено", "отброшена", "завершён", "завершена", "отменена"],
   },
   statusTokens: { draft: "черновик", current: "актуально" },
+  initialStatus: {
+    knowledge: "актуально",
+    decision: "принято",
+    idea: "новая",
+    project: "активный",
+    list: "актуально",
+    agentMemory: "актуально",
+  },
   phaseStatusOrder: ["запланирована", "активная", "на паузе", "завершена", "отменена"],
   indexStrings: {
     header: "Vault-индекс заметок автора",
@@ -321,17 +344,58 @@ 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).
- * The archive is NOT excluded — it stays searchable with the stale boost.
+ * Default search-index exclusions: the system folder (templates/dictionary,
+ * not content). The archive is NOT excluded — it stays searchable with the
+ * stale boost. (Inbox folders are gone — authors write straight into canon.)
  */
 export function defaultExcludeFolders(taxonomy: TaxonomyPreset): string[] {
-  return [
-    taxonomy.folders.inbox,
-    taxonomy.folders.inboxHuman,
-    taxonomy.folders.system,
-  ];
+  return [taxonomy.folders.system];
 }
 
 /**

package/src/utils.ts

@@ -4,7 +4,7 @@ import path from "node:path";
 // Hash the FULL file content. Was a 4096-char prefix hash — that skipped
 // reindexing whenever an append-only note (План / Фаза / Список — a
 // first-class vault genre that grows downward) changed below the prefix
-// window, leaving vault_search / embeddings on the stale tail. Markdown is
+// window, leaving memory_search / embeddings on the stale tail. Markdown is
 // cheap; correctness over the micro-optimisation. If profiling ever demands
 // it, gate a full hash behind size+mtime, never trust a prefix as the source
 // of truth.