@agfpd/iapeer-memory-core 0.2.9 → 0.3.1

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.
  *
@@ -46,8 +45,6 @@ import { renderTagsProjection, DEFAULT_TAGS_BOUNDARY_MAXLEN } from "./tags-gate.
 import { isArchivableZone, shouldArchive, archiveTargetRel } from "./archive.js";
 import {
   snapshotVault,
-  snapshotInbox,
-  snapshotFlatFolder,
   diffSnapshots,
   type VaultSnapshot,
 } from "./permanent-detect.js";
@@ -256,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);
       }
     },
   );
@@ -369,6 +414,7 @@ export async function startMcpHttp(opts: {
             content?: string;
             threshold?: number;
             limit?: number;
+            linkThreshold?: number;
           };
           const content = (body.content ?? "").trim();
           const result = content
@@ -376,6 +422,7 @@ export async function startMcpHttp(opts: {
                 content,
                 threshold: body.threshold,
                 limit: body.limit,
+                linkThreshold: body.linkThreshold,
               })
             : { enabled: Boolean(opts.config.embedding), matches: [] };
           res.writeHead(200, { "Content-Type": "application/json" });
@@ -453,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;
 };
 
@@ -498,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 {
@@ -522,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",
@@ -572,11 +612,11 @@ export type MemorydOptions = {
   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). */
@@ -622,11 +662,24 @@ 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>;
 };
 
+/**
+ * Whether a note's frontmatter already carries a non-empty `author`. The
+ * first-sight guard uses it to tell a SETTLED note (has author — never
+ * re-stamp it at startup) from a genuinely NEW one (a human's bare-body canon
+ * note with no author yet — fill it on its first event, §9). No frontmatter →
+ * bare → not settled.
+ */
+function hasAuthorField(content: string): boolean {
+  const fm = /^---[^\S\n]*\n([\s\S]*?)\n---[^\S\n]*(?:\n|$)/.exec(content);
+  if (!fm) return false;
+  return /^author\s*:\s*\S/m.test(fm[1]);
+}
+
 export async function startMemoryd(opts: MemorydOptions): Promise<MemorydHandle> {
   const { config } = opts;
   const logger = opts.logger ?? makeLogger("memoryd");
@@ -646,22 +699,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). */
@@ -671,16 +717,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 не трогаем — после
@@ -862,15 +906,14 @@ export async function startMemoryd(opts: MemorydOptions): Promise<MemorydHandle>
     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 ||
@@ -886,13 +929,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) {
@@ -952,13 +995,16 @@ export async function startMemoryd(opts: MemorydOptions): Promise<MemorydHandle>
       } catch {
         continue; // deleted mid-debounce
       }
-      // FIRST-SIGHT GUARD (churn-дефект B-приёмки, boris п.3): путь, которого
-      // нет в hash-базе — это mv размещения Индексом (Входящие → канон) или
-      // первое наблюдение после установки, НЕ человеческая правка. Запиши
-      // baseline и не стампь: фантомные last_edited_by на каждом размещении —
-      // системный churn. Цена: первая правка человеком never-seen файла
-      // пройдёт без стампа один раз (поймается следующей).
-      if (!lastSeenHashes.has(filePath)) {
+      // FIRST-SIGHT GUARD (churn-дефект B-приёмки, boris п.3 + §9-фикс 0.3.1):
+      // путь, которого нет в hash-базе — это ПЕРВОЕ наблюдение. Если у ноты
+      // УЖЕ есть author — она SETTLED (старт демона над населённым vault, или
+      // любая атрибутированная нота): запиши baseline и НЕ стампь (load-bearing
+      // инвариант — старт никогда не перештамповывает существующие ноты).
+      // Нота БЕЗ author — генуинно новая: голое тело человека прямо в канон —
+      // проваливается в fill ниже и достраивается на ЭТОМ первом событии (§9:
+      // голое тело человека достраивается, не откладывается до второго).
+      // (Размещений Индексом больше нет — инбокс устранён.)
+      if (!lastSeenHashes.has(filePath) && hasAuthorField(content)) {
         lastSeenHashes.set(filePath, sha256(content));
         continue;
       }
@@ -1046,63 +1092,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);
@@ -1115,23 +1127,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();
   }
@@ -1206,42 +1203,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;
@@ -1255,10 +1226,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);
@@ -1271,11 +1239,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);