@agfpd/iapeer-memory-core 0.2.8 → 0.3.0

package/src/memoryd.ts

@@ -4,17 +4,16 @@
  * One process owns everything live:
  * - the WRITER role: sole SQLite owner (openDatabase + indexAll), fs.watch
  *   over the vault with debounce, incremental re-index by content hash;
- * - the detect subsystems (stage 8 cores): human-edit attribution,
- *   tags-dictionary mirror, permanent smart-hash diff with COALESCED
- *   events; INBOX_NEW on new inbox files (baseline at start — pre-existing
- *   files never replay, parity with the reference monitor);
- * - the event stream: signal lines on stdout (`INBOX_NEW: …`,
- *   `PERMANENT_CHANGED: …`) — a notifier watcher forwards each line to the
- *   Index as an IAP signal (docs/06-pipelines-and-events.md);
+ * - the detect subsystems (stage 8 cores): human-edit attribution, the
+ *   silent-edit (unstamped) belt, the tags-dictionary mirror, and the
+ *   permanent smart-hash diff COALESCED into one curation pass;
+ * - the event stream: one signal line per curation pass on stdout
+ *   (`CURATOR_TICK: [<paths…>]`) — a notifier watcher forwards it to the
+ *   curation receiver as an IAP signal (docs/06-pipelines-and-events.md);
  * - the heartbeat state file (consumer: every peer's SessionStart
  *   health-check, ADR-009/010);
  * - the MCP-http endpoint (ADR-012): localhost, port from config, three
- *   read-only tools (vault_search / vault_graph / vault_map — ADR-008,
+ *   read-only tools (memory_search / memory_related / memory_map — ADR-008,
  *   vault_read is NOT on the surface), caller identity from the
  *   `X-IAPeer-Identity` header per request.
  *
@@ -39,12 +38,13 @@ 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,
-  snapshotFlatFolder,
   diffSnapshots,
   type VaultSnapshot,
 } from "./permanent-detect.js";
@@ -253,81 +253,129 @@ export function createMcpServer(opts: {
   const server = new McpServer(
     { name: MEMORYD_SERVER_NAME, version: readCoreVersion() },
     {
+      // Server instructions carry the PURPOSE + when-to-use + the behavioural
+      // cautions (Anthropic tool-design canon: tool descriptions must NOT
+      // instruct behaviour — those hints live here, injected once).
       instructions:
-        "iapeer-memory vault — shared team memory. vault_search is the default " +
-        "entry point when you don't have an exact path; read notes with the " +
-        "native Read tool after search. Stale-status notes are score-deboosted " +
-        "but still returned — treat them as history, not current truth.",
+        "iapeer-memory — the team's shared memory: knowledge, decisions, " +
+        "context, ideas, lists, project notes. The tools return ranked paths and " +
+        "snippets from an index SNAPSHOT, not live bodies — open a note with the " +
+        "native Read tool, and re-check it before acting (its status or content " +
+        "may have moved on). Stale-status notes are deboosted but still returned: " +
+        "history, not current truth.",
     },
   );
 
   server.registerTool(
-    "vault_search",
+    "memory_search",
     {
+      title: "Search team memory (by meaning)",
       description:
-        "Search the vault for knowledge, decisions and context when you don't know the exact note path. " +
-        "Hybrid pipeline: BM25 + optional vector/rerank providers → RRF fusion → status boost → 1-hop graph expansion → backlink boost. " +
-        "Returns up to max_results items (title, path, type, status, score, snippet, related). " +
-        "Read the found note with the native Read tool. " +
-        "The `pipeline` object reports per-component status (ok/disabled/skipped/timeout/error/circuit-open).",
+        "Find relevant memory by MEANING — semantic + keyword search, ranked. " +
+        "Returns per item: title, path, type, status, score, snippet, and " +
+        "`related` neighbours; `pipeline` carries per-component status (BM25 / " +
+        "vector / rerank / graph). Does NOT walk a known note's links — use " +
+        "memory_related; for the whole-vault landscape use memory_map.",
       inputSchema: {
-        query: z.string().min(1, "vault_search: query is required"),
-        forCuration: z.boolean().optional(),
+        query: z
+          .string()
+          .min(1, "memory_search: query is required")
+          .describe("What to search for — keywords or a natural-language description. Quoted phrases supported."),
+        forCuration: z
+          .boolean()
+          .optional()
+          .describe("Internal: bias ranking for a curation pass (Index/Scriber). Omit for a normal author search."),
       },
       outputSchema: vaultSearchOutput.shape,
-      annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+      },
     },
     async ({ query, forCuration }) => {
       try {
         return toResult(await runSearch(db, effectiveConfig, { query, forCuration }));
       } catch (err) {
-        return toError("vault_search", err, logger);
+        return toError("memory_search", err, logger);
       }
     },
   );
 
   server.registerTool(
-    "vault_graph",
+    "memory_related",
     {
+      title: "Related notes (link graph)",
       description:
-        "Walk the wikilink graph outward from a note, 1–3 hops in both directions. " +
-        "Returns nodes and edges of the subgraph; agent-memory backlinks of canonical notes are filtered (one-way). " +
-        "Unknown center path → {found:false}.",
+        "Walk the wikilink graph around a note you ALREADY have — 1–3 hops, both " +
+        "directions — surfacing its cross-linked neighbours and backlinks. Returns " +
+        "the subgraph (nodes, edges); agent-memory backlinks of canon are " +
+        "one-way-filtered; an unknown center path → {found:false}. To find notes by " +
+        "meaning use memory_search; for the whole-vault landscape use memory_map.",
       inputSchema: {
-        path: z.string().min(1, "vault_graph: path is required"),
-        depth: z.number().int().min(1).max(3).optional(),
+        path: z
+          .string()
+          .min(1, "memory_related: path is required")
+          .describe("Vault-relative path of the note to center on (e.g. `01_Knowledge/Note.md`) — take it from a memory_search result's `path`."),
+        depth: z
+          .number()
+          .int()
+          .min(1)
+          .max(3)
+          .optional()
+          .describe("Hops outward (1–3). Default 1 — the note's immediate neighbours."),
       },
       outputSchema: vaultGraphOutput.shape,
-      annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
     },
     async ({ path: p, depth }) => {
       try {
         return toResult(runGraph(db, effectiveConfig, { path: p, depth }));
       } catch (err) {
-        return toError("vault_graph", err, logger);
+        return toError("memory_related", err, logger);
       }
     },
   );
 
   server.registerTool(
-    "vault_map",
+    "memory_map",
     {
+      title: "Vault landscape (map)",
       description:
-        "Global topology of the CANONICAL vault graph (agent memory excluded): " +
-        "clusters, hubs, bridges, orphans + orphan_wikilinks (opt-in part). " +
-        "Stats always returned.",
+        "The holistic LANDSCAPE of the canonical graph (agent memory excluded), " +
+        "like the Obsidian graph view: clusters, hubs, bridges, orphans (+ optional " +
+        "orphan_wikilinks). For the BIG PICTURE — themes, structure, gaps — not a " +
+        "single note. For one note's neighbourhood use memory_related; to find notes " +
+        "by meaning use memory_search.",
       inputSchema: {
-        detail: z.enum(["summary", "full"]).optional(),
-        parts: z.array(mapPart).optional(),
+        detail: z
+          .enum(["summary", "full"])
+          .optional()
+          .describe("`summary` (counts + top items) or `full` (every cluster/hub). Default summary."),
+        parts: z
+          .array(mapPart)
+          .optional()
+          .describe("Which parts to include: clusters, hubs, bridges, orphans, orphan_wikilinks. Default: all but orphan_wikilinks (the opt-in heavy part)."),
       },
       outputSchema: vaultMapOutput.shape,
-      annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
     },
     async ({ detail, parts }) => {
       try {
         return toResult(runMap(db, effectiveConfig, { detail, parts }));
       } catch (err) {
-        return toError("vault_map", err, logger);
+        return toError("memory_map", err, logger);
       }
     },
   );
@@ -353,6 +401,41 @@ 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;
+            linkThreshold?: number;
+          };
+          const content = (body.content ?? "").trim();
+          const result = content
+            ? await runDedup(opts.db, opts.config, {
+                content,
+                threshold: body.threshold,
+                limit: body.limit,
+                linkThreshold: body.linkThreshold,
+              })
+            : { 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" }));
@@ -417,17 +500,16 @@ export async function startMcpHttp(opts: {
 // a sync-storm right after a restart could still mis-attribute — so the
 // baseline survives restarts, atomically (same tmp+rename canon).
 
-/** Persisted batch baselines: inbox + permanent + human-inbox snapshots
- *  (rel/name → smart hash) + the silent-edit stamp baseline (rel →
- *  {updated, leb}; the unstamped detector judges stamp movement against
- *  it). Survives restarts — порт паттерна старых мониторов «seen
- *  переживает сбой». Migration is FIRST-SIGHT by construction: an absent
- *  silentStamps key (pre-detector state file) reads as an empty map — one
- *  warm-up pass records, never judges. */
+/** Persisted batch baselines: the permanent-folders snapshot (rel → smart
+ *  hash) + the silent-edit stamp baseline (rel → {updated, leb}; the
+ *  unstamped detector judges stamp movement against it). Survives restarts —
+ *  порт паттерна старых мониторов «seen переживает сбой». Migration is
+ *  FIRST-SIGHT by construction: an absent silentStamps key (pre-detector
+ *  state file) reads as an empty map — one warm-up pass records, never
+ *  judges. Legacy `inbox`/`humanInbox` keys in an old state file are simply
+ *  ignored on load. */
 export type BatchState = {
-  inbox: VaultSnapshot | null;
   permanent: VaultSnapshot | null;
-  humanInbox: VaultSnapshot | null;
   silentStamps: Map<string, StampRecord> | null;
 };
 
@@ -462,22 +544,18 @@ export function loadBatchState(filePath: string): BatchState {
       return m;
     };
     return {
-      inbox: toMap(raw.inbox),
       permanent: toMap(raw.permanent),
-      humanInbox: toMap(raw.humanInbox),
       silentStamps: toStamps(raw.silentStamps),
     };
   } catch {
-    return { inbox: null, permanent: null, humanInbox: null, silentStamps: null };
+    return { permanent: null, silentStamps: null };
   }
 }
 
 export function persistBatchState(
   filePath: string,
   state: {
-    inbox: VaultSnapshot;
     permanent: VaultSnapshot;
-    humanInbox: VaultSnapshot;
     silentStamps: Map<string, StampRecord>;
   },
 ): void {
@@ -486,9 +564,7 @@ export function persistBatchState(
   guardedWriteFileSync(
     tmp,
     JSON.stringify({
-      inbox: Object.fromEntries(state.inbox),
       permanent: Object.fromEntries(state.permanent),
-      humanInbox: Object.fromEntries(state.humanInbox),
       silentStamps: Object.fromEntries(state.silentStamps),
     }),
     "utf-8",
@@ -531,13 +607,16 @@ 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). */
+  /** Persisted batch baselines (the permanent-folders snapshot + silent
+   *  stamps). */
   batchStatePath?: string;
-  /** Cadence overrides (tests); default from config.batch. */
-  permanentBatchMs?: number;
-  humanInboxBatchMs?: number;
+  /** Curator-tick cadence override (tests); default from config.batch. */
+  curatorTickMs?: number;
   /** Periodic hash-persist interval (ms). */
   persistMs?: number;
   /** Human owner name; human-edit detection is OFF when absent (⚖7). */
@@ -583,8 +662,8 @@ export type MemorydHandle = {
   mcpPort: number | null;
   /** Force one detect pass immediately (used by tests and shutdown flush). */
   runDetectPass: () => Promise<void>;
-  /** Force a cadence batch (tests / operator force-tick). */
-  runBatchPass: (kind: "permanent" | "human-inbox") => void;
+  /** Force a curator tick (tests / operator force-tick). */
+  runCuratorTick: () => void;
   close: () => Promise<void>;
 };
 
@@ -597,6 +676,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;
@@ -604,22 +686,15 @@ export async function startMemoryd(opts: MemorydOptions): Promise<MemorydHandle>
   const db = openDatabase(config);
   await indexAll({ db, config, logger });
 
-  // Baselines (каденции — директива Артура 10.06 ~15:31): inbox HASH-diffed
-  // мгновенно (B-приёмка fix: правка существующего черновика = событие, цикл
-  // reject→fix→re-review); канон + оперативка копятся и уходят ПАЧКОЙ раз в
-  // batch.permanentMs (default 6h); human-inbox — пачкой раз в
-  // batch.humanInboxMs (default 4h). Снапшоты ПЕРСИСТЯТСЯ через рестарты
-  // (порт паттерна старых мониторов: «seen переживает сбой») — рестарт не
-  // глотает накопленное и не реплеит обработанное.
+  // Baseline (каденция — директива Артура 10.06 ~15:31): канон + оперативка
+  // копятся и уходят ПАЧКОЙ раз в batch.curatorMs (default 6h, CURATOR_TICK).
+  // Снапшот ПЕРСИСТИТСЯ через рестарты (порт паттерна старых мониторов: «seen
+  // переживает сбой») — рестарт не глотает накопленное и не реплеит
+  // обработанное.
   const batchStatePath = opts.batchStatePath ?? path.join(dbDir, "memoryd.batches.json");
   const persistedBatches = loadBatchState(batchStatePath);
-  let inboxSnapshot: VaultSnapshot =
-    persistedBatches.inbox ?? snapshotInbox(config.vaultPath, taxonomy);
   let permanentBaseline: VaultSnapshot =
     persistedBatches.permanent ?? snapshotVault(config.vaultPath, taxonomy);
-  const humanInboxDir = path.join(config.vaultPath, taxonomy.folders.inboxHuman);
-  let humanInboxBaseline: VaultSnapshot =
-    persistedBatches.humanInbox ?? snapshotFlatFolder(humanInboxDir);
   const lastSeenHashes = loadHashState(hashStatePath);
   /** Silent-edit stamp baseline (rel → {updated, leb}); absent key in an
    *  old state file = empty map = first-sight warm-up (design §4). */
@@ -629,16 +704,14 @@ export async function startMemoryd(opts: MemorydOptions): Promise<MemorydHandle>
   function persistBatches(): void {
     try {
       persistBatchState(batchStatePath, {
-        inbox: inboxSnapshot,
         permanent: permanentBaseline,
-        humanInbox: humanInboxBaseline,
         silentStamps,
       });
     } catch (err) {
       logger.error(`batch-state persist failed: ${String(err)}`);
     }
   }
-  if (!persistedBatches.inbox) persistBatches(); // first run: write baselines
+  if (!persistedBatches.permanent) persistBatches(); // first run: write baseline
 
   /** iCloud-mount guard (порт защиты старых мониторов): корень vault
    *  недоступен → пропускаем проход целиком, baseline не трогаем — после
@@ -745,7 +818,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,23 +861,46 @@ 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 +
-   *  the six permanent folders (five canonical + agent memory — wider than
-   *  humanEditPass's getZone, which has no agent-memory notion). */
+  /** Zone map of the unstamped detector (design §3): the six monitored
+   *  folders (five canonical + agent memory — wider than humanEditPass's
+   *  getZone, which has no agent-memory notion). */
   function silentZoneOf(absPath: string): SilentZone | null {
     const rel = path.relative(config.vaultPath, absPath);
     if (rel.startsWith("..")) return null;
     const first = rel.split(path.sep)[0];
     const f = taxonomy.folders;
-    if (first === f.inbox) return "inbox";
     if (
       first === f.knowledge ||
       first === f.decisions ||
@@ -817,13 +916,13 @@ export async function startMemoryd(opts: MemorydOptions): Promise<MemorydHandle>
 
   /**
    * Unstamped-write detector (design doc, boris-accepted 11.06). Runs
-   * BEFORE the inbox emission loop and BEFORE humanEditPass: a re-stamped
-   * file then reads `last_edited_by: unstamped` — the curator source
-   * filters pass it into the pipeline, and humanEditPass sees a fresh
-   * agent stamp (echo-agent skip, no double stamp — order instead of ifs).
-   * Candidates carry CHANGED files only (fs.watch set ∪ inbox diff) — the
-   * semantic-hash precondition of the rule; service-only echoes never
-   * reach here (smart-hash blindness = echo safety of our own re-stamp).
+   * BEFORE humanEditPass: a re-stamped file then reads `last_edited_by:
+   * unstamped` — the curator source filters pass it into the curation pass,
+   * and humanEditPass sees a fresh agent stamp (echo-agent skip, no double
+   * stamp — order instead of ifs). Candidates carry CHANGED files only (the
+   * fs.watch set) — the semantic-hash precondition of the rule; service-only
+   * echoes never reach here (smart-hash blindness = echo safety of our own
+   * re-stamp).
    */
   function silentEditPass(candidatesAbs: Set<string>): void {
     for (const abs of candidatesAbs) {
@@ -884,11 +983,13 @@ export async function startMemoryd(opts: MemorydOptions): Promise<MemorydHandle>
         continue; // deleted mid-debounce
       }
       // FIRST-SIGHT GUARD (churn-дефект B-приёмки, boris п.3): путь, которого
-      // нет в hash-базе — это mv размещения Индексом (Входящие → канон) или
-      // первое наблюдение после установки, НЕ человеческая правка. Запиши
-      // baseline и не стампь: фантомные last_edited_by на каждом размещении —
-      // системный churn. Цена: первая правка человеком never-seen файла
-      // пройдёт без стампа один раз (поймается следующей).
+      // нет в hash-базе — это ПЕРВОЕ наблюдение (старт демона над уже
+      // населённым vault), НЕ обязательно человеческая правка. Запиши
+      // baseline и не стампь: иначе старт массово штампует все существующие
+      // ноты как «правки человека». (Размещений Индексом больше нет — инбокс
+      // устранён; единственный источник never-seen-путей — старт/новый файл.)
+      // ЦЕНА (§9-край, на живой приёмке): свежая bare-body заметка человека
+      // достраивается со ВТОРОГО fs-события — первое лишь пишет baseline.
       if (!lastSeenHashes.has(filePath)) {
         lastSeenHashes.set(filePath, sha256(content));
         continue;
@@ -901,6 +1002,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 +1029,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;
@@ -937,62 +1078,29 @@ export async function startMemoryd(opts: MemorydOptions): Promise<MemorydHandle>
 
     if (!vaultAvailable()) return;
 
-    // INBOX_NEW — мгновенно: new OR semantically changed drafts (hash-diff
-    // over the WHOLE inbox folder; no dependency on fs.watch filenames).
-    const inboxNext = snapshotInbox(config.vaultPath, taxonomy);
-    const inboxChanged = diffSnapshots(inboxSnapshot, inboxNext);
-
-    // Unstamped detector FIRST (design §3 order): re-stamps land before the
-    // curator suppress below reads leb and before humanEditPass judges.
-    // Candidates: fs.watch set (permanent fresh-window branch) ∪ the inbox
-    // diff (the diff is semantic — a re-stamp does not invalidate it).
-    silentEditPass(
-      new Set([
-        ...changed,
-        ...inboxChanged.map((n) => path.join(config.vaultPath, taxonomy.folders.inbox, n)),
-      ]),
-    );
-
-    for (const name of inboxChanged) {
-      const abs = path.join(config.vaultPath, taxonomy.folders.inbox, name);
-      // Source-фильтр кураторов — ПАРИТЕТ с PERMANENT_BATCH (живое эхо
-      // 10.06: стилистическая правка Scriber'а ВО ВРЕМЯ вычитки породила
-      // повторный INBOX_NEW по тому же черновику — вычитывающая сессия и
-      // есть конвейер). Правки автора (reject→fix→re-review) проходят:
-      // last_edited_by остаётся автором. Цена документирована: черновик,
-      // чья ПОСЛЕДНЯЯ правка до первого анонса — кураторская, не
-      // анонсируется; в конвейере не возникает (кураторы трогают черновики
-      // только по событиям, т.е. после анонса). Baseline обновляется ниже
-      // безусловно — подавленное НЕ реплеится, авторская правка поверх
-      // кураторской диффится от свежего снапшота и проходит.
-      const leb = lastEditedByOf(abs);
-      if (leb && config.curatorSet.includes(leb)) {
-        logger.info(`inbox event suppressed (curator ${leb}): ${name}`);
-        continue;
-      }
-      logger.info(`inbox event: ${name}`);
-      // ABSOLUTE path (B-приёмка 10.06): a consumer must never guess the
-      // vault root — a role peer once `find`-guessed a stale copy.
-      emit(`INBOX_NEW: ${abs}`);
-    }
-    if (inboxNext.size > 0 || inboxSnapshot.size === 0) {
-      inboxSnapshot = inboxNext;
-      persistBatches();
-    }
+    // Unstamped detector FIRST (design §3 order): re-stamps land before
+    // humanEditPass judges (a re-stamped file then reads `last_edited_by:
+    // unstamped` and humanEditPass sees a fresh agent stamp → echo-agent
+    // skip, no double stamp — order instead of ifs). Candidates are the
+    // fs.watch changed set; service-only echoes never reach the rule
+    // (smart-hash blindness = echo safety of our own re-stamp).
+    silentEditPass(changed);
 
     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: свежесть за секунды
-    // PERMANENT правки НЕ эмитятся мгновенно — копятся до batch-прохода
-    // (каденция 6h); см. runPermanentBatch.
+    // Canon edits are NOT emitted instantly — they accumulate to the curator
+    // tick (cadence 6h); see runCuratorTick.
   }
 
-  /** PERMANENT_BATCH — один проход каденции: diff канона+оперативки против
-   *  baseline пачки, кураторские правки отфильтрованы ИСТОЧНИКОМ, остальное
-   *  уходит ОДНОЙ строкой (JSON-массив АБСОЛЮТНЫХ путей → одна доставка →
-   *  одна ephemeral-сессия Scriber'а → один отчёт). */
-  function runPermanentBatch(): void {
+  /** CURATOR_TICK — one cadence pass: diff canon + agent memory against the
+   *  carried baseline, curator-authored edits filtered BY SOURCE, the rest
+   *  goes out as ONE line (a JSON array of ABSOLUTE paths → one delivery →
+   *  one ephemeral curation session → one report). In lean the emit is
+   *  suppressed (no proactive receiver), but the baseline still advances. */
+  function runCuratorTick(): void {
     if (!vaultAvailable()) return;
     const next = snapshotVault(config.vaultPath, taxonomy);
     const changedRel = diffSnapshots(permanentBaseline, next);
@@ -1005,23 +1113,8 @@ export async function startMemoryd(opts: MemorydOptions): Promise<MemorydHandle>
       absPaths.push(abs);
     }
     if (absPaths.length) {
-      logger.info(`permanent batch: ${absPaths.length} path(s)`);
-      emit(`PERMANENT_BATCH: ${JSON.stringify(absPaths)}`);
-    }
-    persistBatches();
-  }
-
-  /** HUMAN_INBOX_BATCH — каденция human-inbox (человек пишет долго,
-   *  мгновенный триггер схватил бы недоделанное). */
-  function runHumanInboxBatch(): void {
-    if (!vaultAvailable()) return;
-    const next = snapshotFlatFolder(humanInboxDir);
-    const names = diffSnapshots(humanInboxBaseline, next);
-    humanInboxBaseline = next;
-    if (names.length) {
-      const absPaths = names.map((n) => path.join(humanInboxDir, n));
-      logger.info(`human-inbox batch: ${absPaths.length} draft(s)`);
-      emit(`HUMAN_INBOX_BATCH: ${JSON.stringify(absPaths)}`);
+      logger.info(`curator tick: ${absPaths.length} path(s)`);
+      emit(`CURATOR_TICK: ${JSON.stringify(absPaths)}`);
     }
     persistBatches();
   }
@@ -1096,42 +1189,16 @@ export async function startMemoryd(opts: MemorydOptions): Promise<MemorydHandle>
   const persistTimer = setInterval(persistQuiet, persistMs);
   persistTimer.unref?.();
 
-  // ── cadence timers (директива ~15:31): первый прогон через полный период
-  const permanentBatchMs = opts.permanentBatchMs ?? config.batch.permanentMs;
-  const permanentTimer = setInterval(() => {
+  // ── cadence timer (директива ~15:31): первый прогон через полный период
+  const curatorTickMs = opts.curatorTickMs ?? config.batch.curatorMs;
+  const curatorTimer = setInterval(() => {
     try {
-      runPermanentBatch();
+      runCuratorTick();
     } catch (err) {
-      logger.error(`permanent batch failed: ${String(err)}`);
-    }
-  }, permanentBatchMs);
-  permanentTimer.unref?.();
-  // HUMAN-INBOX: раз в СУТКИ в config.batch.humanInboxHour локального
-  // (подтверждение Артура ~15:4x: ночная партия, как в старом контуре).
-  // Тестовый override opts.humanInboxBatchMs — простой интервал.
-  let humanInboxTimer: ReturnType<typeof setTimeout> | null = null;
-  function scheduleHumanInbox(): void {
-    let delay: number;
-    if (opts.humanInboxBatchMs !== undefined) {
-      delay = opts.humanInboxBatchMs;
-    } else {
-      const now = new Date();
-      const next = new Date(now);
-      next.setHours(config.batch.humanInboxHour, 0, 0, 0);
-      if (next.getTime() <= now.getTime()) next.setDate(next.getDate() + 1);
-      delay = next.getTime() - now.getTime();
+      logger.error(`curator tick failed: ${String(err)}`);
     }
-    humanInboxTimer = setTimeout(() => {
-      try {
-        runHumanInboxBatch();
-      } catch (err) {
-        logger.error(`human-inbox batch failed: ${String(err)}`);
-      }
-      scheduleHumanInbox();
-    }, delay);
-    humanInboxTimer.unref?.();
-  }
-  scheduleHumanInbox();
+  }, curatorTickMs);
+  curatorTimer.unref?.();
 
   // ── MCP http ──
   let mcp: { port: number; close: () => Promise<void> } | null = null;
@@ -1145,10 +1212,7 @@ export async function startMemoryd(opts: MemorydOptions): Promise<MemorydHandle>
 
   return {
     mcpPort: mcp?.port ?? null,
-    runBatchPass: (kind) => {
-      if (kind === "permanent") runPermanentBatch();
-      else runHumanInboxBatch();
-    },
+    runCuratorTick,
     runDetectPass: async () => {
       if (flushTimer) {
         clearTimeout(flushTimer);
@@ -1161,11 +1225,15 @@ export async function startMemoryd(opts: MemorydOptions): Promise<MemorydHandle>
       watcher?.close();
       if (flushTimer) clearTimeout(flushTimer);
       clearInterval(heartbeatTimer);
-      clearInterval(permanentTimer);
-      if (humanInboxTimer) clearTimeout(humanInboxTimer);
+      clearInterval(curatorTimer);
       clearInterval(persistTimer);
       await flushing;
       persistQuiet();
+      // Batch state (silentStamps + the permanent baseline) also persists on
+      // shutdown — otherwise silentStamps moved since the last curator tick are
+      // lost, breaking the "survives restarts" invariant (first-sight warm-up
+      // would then re-skip a real edit after a graceful restart).
+      persistBatches();
       if (mcp) await mcp.close();
       try {
         guardedUnlinkSync(heartbeatPath);