@agfpd/iapeer-memory-core 0.2.8 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer-memory-core",
-  "version": "0.2.8",
+  "version": "0.3.0",
   "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 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/config.ts

@@ -50,15 +50,13 @@ export type CoreConfig = {
     dbPath: string;
     fullScanOnStartup: boolean;
   };
-  /** Конвейерные каденции (директива Артура 10.06 ~15:31): канон-правки и
-   *  human-inbox идут ПАЧКАМИ, не событиями — правки должны устаканиться,
-   *  10 пишущих агентов не дёргают конвейер постоянно. */
+  /** Каденция курации (директива Артура 10.06 ~15:31): канон-правки уходят
+   *  ПАЧКОЙ, не событиями — правки должны устаканиться, 10 пишущих агентов
+   *  не дёргают конвейер постоянно. */
   batch: {
-    /** PERMANENT_BATCH period, ms (default 6h). */
-    permanentMs: number;
-    /** HUMAN_INBOX_BATCH — РАЗ В СУТКИ в этот локальный час (default 04:00,
-     *  как в старом контуре: человек пишет долго, ночная партия). */
-    humanInboxHour: number;
+    /** CURATOR_TICK period, ms (default 6h) — the curation pass over changed
+     *  canon (Scriber/Index links + health). */
+    curatorMs: number;
   };
   /**
    * MCP-http endpoint of memoryd (ADR-012). The default port 8766 is the
@@ -261,8 +259,7 @@ export function configFromEnv(): CoreConfig {
       fullScanOnStartup: envBoolean("IAPEER_MEMORY_FULL_SCAN_ON_STARTUP", true),
     },
     batch: {
-      permanentMs: envNumber("IAPEER_MEMORY_PERMANENT_BATCH_SECS", 6 * 3600) * 1000,
-      humanInboxHour: envNumber("IAPEER_MEMORY_HUMAN_INBOX_HOUR", 4),
+      curatorMs: envNumber("IAPEER_MEMORY_CURATOR_TICK_SECS", 6 * 3600) * 1000,
     },
     mcp: {
       port: envNumber("IAPEER_MEMORY_MCP_PORT", 8766),

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/db.ts

@@ -144,7 +144,7 @@ export function openDatabase(config: CoreConfig, options: OpenDatabaseOptions =
 
     -- Wikilinks that could not be resolved to a real note. Kept first-class
     -- instead of being silently dropped from edges: a missing/ambiguous link
-    -- is a vault health signal (surfaced via vault_map orphan_wikilinks +
+    -- is a vault health signal (surfaced via memory_map orphan_wikilinks +
     -- the Index nightly health-check). reason ∈ 'missing' | 'ambiguous'.
     CREATE TABLE IF NOT EXISTS unresolved_links (
       source_path TEXT NOT NULL,
@@ -536,7 +536,7 @@ export function documentExists(db: CoreDb, docPath: string): boolean {
 
 /**
  * Unresolved wikilinks (missing target / ambiguous basename across folders).
- * First-class health signal — surfaced through vault_map's opt-in
+ * First-class health signal — surfaced through memory_map's opt-in
  * `orphan_wikilinks` part and the Index nightly health-check.
  */
 export function getUnresolvedLinks(

package/src/embedding.ts

@@ -45,7 +45,7 @@ export type EmbeddingConfig = {
 };
 
 /**
- * Status of a single embedding call, surfaced up to the vault_search
+ * Status of a single embedding call, surfaced up to the memory_search
  * response (`pipeline.embedding`).
  *
  * - `ok`           — valid response;

package/src/frontmatter-fill.ts

@@ -1,6 +1,9 @@
 /**
  * Fill a vault note's frontmatter according to its zone
- * (inbox / permanent / memory).
+ * (permanent / memory). The страж is the SHARED fill logic — the same
+ * functions run the agent hook path (processFile) and the human path
+ * (decideUpdate, human-edit-detect.ts). Inbox zones were removed with the
+ * direct-to-canon model: authors write straight into the typed canon folders.
  *
  * TS port of the reference `scripts/mergemind-frontmatter-fill.py`
  * (behavioural parity against `tests/python/test_frontmatter_fill.py`,
@@ -16,20 +19,16 @@
  * - **identity = peer personality** (нюанс 10): `resolveAgentName` prefers
  *   `PEER_PERSONALITY`, falling back to `IAPEER_MEMORY_AGENT_NAME`.
  *
- * Zone behaviour (parity with the reference, one deliberate deviation):
- * - inbox:     idempotent fill of the 4-field draft frontmatter +
- *              needs_review (unless curator) + UPSERT of the stamp pair
- *              (last_edited_by, updated) — a deviation from the reference,
- *              load-bearing for the unstamped detector: its inbox branch
- *              discriminates by «the stamp pair did not move», which is
- *              only a signal when hook edits DO move it (false-positive
- *              incident 11.06, boris's Write+Edit repro).
- * - permanent: upsert of service fields (last_edited_by, updated,
- *              needs_review).
- * - memory:    PERMANENT service-field semantics + idempotent fill of the
- *              constants. `author` is parsed from the subfolder name, NOT
- *              from the caller identity — load-bearing for DreamWeaver
- *              writing into a foreign subfolder on an Index task.
+ * Zone behaviour:
+ * - permanent: FULL canon fill (`fillPermanentFull`) — title ← filename,
+ *              type/status ← the folder's genre (§2.1), created, author for
+ *              non-curators + needs_review, and an UPSERT of the stamp pair
+ *              (last_edited_by, updated). The author now hand-writes only
+ *              body + tags + inline links + title; the rest is deterministic.
+ * - memory:    service-field semantics + idempotent fill of the constants.
+ *              `author` is parsed from the subfolder name, NOT from the caller
+ *              identity — load-bearing for DreamWeaver writing into a foreign
+ *              subfolder on an Index task.
  *
  * The YAML-safe normalisation of `description` is load-bearing: typographic
  * guillemets `«…»` are a display convention, not YAML quotes; any `: ` inside
@@ -42,12 +41,12 @@ 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|$)/;
 
-export const VALID_ZONES = ["inbox", "permanent", "memory"] as const;
+export const VALID_ZONES = ["permanent", "memory"] as const;
 export type Zone = (typeof VALID_ZONES)[number];
 
 /**
@@ -96,6 +95,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);
@@ -138,8 +201,9 @@ export function parseMemoryAuthor(
  * Zone of a file by the first path segment relative to the vault — the
  * single source of truth for zone routing (the reference de-duplicated a
  * bash `case` into exactly this function). Folder whitelist comes from the
- * taxonomy preset (ADR-002): both inboxes, archive and system are NOT in
- * the whitelist → null → caller no-ops.
+ * taxonomy preset (ADR-002): archive and system are NOT in the whitelist →
+ * null → caller no-ops. (Inbox zones removed with the direct-to-canon model:
+ * authors write straight into the typed canon folders, the страж fills.)
  */
 export function resolveZone(
   filePath: string,
@@ -151,7 +215,6 @@ export function resolveZone(
   if (!parts || parts.length === 0) return null;
   const head = parts[0];
   const f = taxonomy.folders;
-  if (head === f.inbox) return "inbox";
   if (
     head === f.knowledge ||
     head === f.decisions ||
@@ -165,46 +228,64 @@ export function resolveZone(
   return null;
 }
 
-export function fillInbox(
+/**
+ * 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: { path: string; agent: string; today: string; nowStamp: string; ctx: FillContext },
+  opts: {
+    path: string;
+    agent: string;
+    vault: string;
+    today: string;
+    nowStamp: string;
+    ctx: FillContext;
+  },
 ): string {
   const { taxonomy } = opts.ctx;
-  // STAMP PAIR (дефект-репро boris 11.06, ложный unstamped): upsert как в
-  // fillPermanent/fillMemory. Без неё у inbox-черновиков пара тождественно
-  // (null, null) — «штамп не двинулся» детектора немых записей выполняется
-  // на ЛЮБОЙ легитимной хук-правке, и inbox-ветка вырождается в «hash
-  // двинулся → unstamped» (7 ложных ре-стампов за день 11.06). Оба поля
-  // сервисные для smart-hash → семантический hash и INBOX_NEW-диффы не
-  // двигаются, эхо невозможно. Побочный выигрыш: source-фильтр кураторов
-  // INBOX_NEW впервые получает живой last_edited_by.
+  // Service stamp (always) — load-bearing for smart-hash echo-safety and the
+  // unstamped detector, symmetric with 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));
-  fmBlock = setIfMissing(fmBlock, "status", taxonomy.statusTokens.draft);
+  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 (инвариант Артура, инверсия 10.06): агент curator-set
-  // НИКОГДА не становится author в inbox-зоне. Курайторы трогают черновики
-  // только как курирование (rename/правки стиля — горячая дорожка
-  // инвертированного конвейера: копирайтер пишет НОВЫЙ файл при ренейме);
-  // бесхозный файл от курайтора остаётся без author до явной атрибуции —
-  // видимая аномалия лучше тихо присвоенного авторства. Существующий
-  // author и без гарда неприкосновенен (setIfMissing).
+  // 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 = setIfMissing(fmBlock, "needs_review", "true");
-  }
-  return fmBlock;
-}
-
-export function fillPermanent(
-  fmBlock: string,
-  opts: { agent: string; nowStamp: string; ctx: FillContext },
-): string {
-  fmBlock = upsert(fmBlock, "last_edited_by", opts.agent);
-  fmBlock = upsert(fmBlock, "updated", opts.nowStamp);
-  if (!isCurator(opts.agent, opts.ctx)) {
     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 +498,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 +655,17 @@ export function processFile(filePath: string, opts: ProcessOptions): boolean {
   const [fmBlock, rest] = splitFrontmatter(content);
 
   let newFm: string | null;
-  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 });
+  let newBody = rest;
+  if (zone === "permanent") {
+    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 +676,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/graph.ts

@@ -54,7 +54,7 @@ function loadGraph(db: CoreDb, agentMemoryMarker: string): { adj: AdjMap; direct
     target_path: string;
   }>;
 
-  // vault_map is the CANONICAL / shared topology — used by the Index nightly
+  // memory_map is the CANONICAL / shared topology — used by the Index nightly
   // health-check (orphans, hubs, bridges). Agent operative notes are personal
   // memory: excluding them here keeps that health picture honest (a
   // canonically-isolated note must read as orphan even if some agent journaled