@agfpd/iapeer-memory 0.2.8 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer-memory",
-  "version": "0.2.8",
+  "version": "0.3.0",
   "description": "iapeer-memory — peer memory for the iapeer ecosystem: vault, memoryd (index/search/MCP-http), layer-5 context fragments, role doctrines. The package IS the system; the claude/codex plugins are thin session sockets (docs/10-distribution.md, ADR-009).",
   "license": "MIT",
   "type": "module",
@@ -27,7 +27,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@agfpd/iapeer-memory-core": "0.2.8"
+    "@agfpd/iapeer-memory-core": "0.3.0"
   },
   "devDependencies": {
     "@types/bun": "^1.2.0",

package/src/cli.ts

@@ -25,6 +25,7 @@ import { cmdInstallBinary } from "./commands/install-binary.js";
 import { cmdMemoryd } from "./commands/memoryd.js";
 import { cmdMigrate } from "./commands/migrate.js";
 import { cmdDreamCollect } from "./commands/dream-collect.js";
+import { cmdArchiveStale } from "./commands/archive-stale.js";
 import { cmdProvisionPeer, cmdUnprovisionPeer } from "./commands/provision-peer.js";
 import { cmdRender } from "./commands/render.js";
 import { cmdStatus } from "./commands/status.js";
@@ -42,7 +43,6 @@ Commands:
   uninstall [--keep-binary] remove the system: slot declaration + binary
                             (vault and config are kept — user-owned)
   status                    read-only diagnostics: verify + slot + MCP probe
-                            + inbox load
   verify [--repair]         check (and repair) the live surfaces: config,
                             memory-provider slot, memoryd heartbeat, role
                             doctrine versions
@@ -68,6 +68,11 @@ Commands:
                             batched tasks, from the LIVE registry (read-only).
                             --gate: no output, exit 0 iff there is work (the
                             notifier check that decides if DreamWeaver wakes)
+  archive-stale [--commit]  deliberate backlog archiver (lean §2.2a): move
+                            pre-existing stale notes to the archive. Dry-run by
+                            default (lists what would move); --commit executes.
+                            ALL content folders incl. 03_Projects (unified rule);
+                            memoryd archives ongoing staleness on its own.
   render index|fragment|doctrine|guide
                             render one artifact explicitly (memoryd does this
                             continuously; render is the manual/scripted path)
@@ -134,6 +139,8 @@ export async function main(argv: string[]): Promise<number> {
       return cmdInstallBinary(rest, egress);
     case "dream-collect":
       return cmdDreamCollect(rest, egress);
+    case "archive-stale":
+      return cmdArchiveStale(rest);
     case "provision-peer":
       return cmdProvisionPeer(rest, egress);
     case "unprovision-peer":

package/src/commands/archive-stale.ts

@@ -0,0 +1,88 @@
+/**
+ * `iapeer-memory archive-stale [--commit]` — the DELIBERATE backlog archiver
+ * (lean §2.2a, decision boris 15.06).
+ *
+ * memoryd archives notes incrementally as they BECOME stale (an edit fires the
+ * change pass). Pre-existing stale notes are NOT swept on startup (that would
+ * be a mass move as a side-effect of a daemon boot — banned by §1: bulk
+ * actions are deliberate and verifiable). This verb is that deliberate path:
+ *
+ *   archive-stale            DRY-RUN — list what would move + a count
+ *   archive-stale --commit   actually move them
+ *
+ * Scope = ALL content folders, INCLUDING `03_Projects` (unified rule, decision
+ * Артур 15.06: a completed phase/project is stale like any note and archives
+ * too — `isArchivableZone`). memoryd reindexes the moves on its next pass (or
+ * on restart); the verb itself only moves files.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import {
+  configFromEnv,
+  snapshotVault,
+  shouldArchive,
+  archiveTargetRel,
+} from "@agfpd/iapeer-memory-core";
+
+export function cmdArchiveStale(argv: string[]): number {
+  const commit = argv.includes("--commit");
+  const config = configFromEnv();
+  const vault = config.vaultPath;
+  const taxonomy = config.taxonomy;
+
+  // Candidates: notes in the monitored content folders carrying a final
+  // status — ALL content folders incl. 03_Projects (shouldArchive → isArchivableZone).
+  const snap = snapshotVault(vault, taxonomy);
+  const reserved = new Set<string>(); // archive targets claimed within this run
+  const moves: Array<{ from: string; to: string }> = [];
+  for (const rel of snap.keys()) {
+    let content: string;
+    try {
+      content = fs.readFileSync(path.join(vault, rel), "utf-8");
+    } catch {
+      continue;
+    }
+    if (!shouldArchive(rel, content, taxonomy)) continue;
+    const to = archiveTargetRel(
+      path.basename(rel),
+      taxonomy,
+      (r) => reserved.has(r) || fs.existsSync(path.join(vault, r)),
+    );
+    reserved.add(to);
+    moves.push({ from: rel, to });
+  }
+
+  if (moves.length === 0) {
+    console.log("archive-stale: no stale notes outside the archive — nothing to do.");
+    return 0;
+  }
+
+  if (!commit) {
+    console.log(
+      `archive-stale (DRY-RUN): ${moves.length} stale note(s) WOULD move to ${taxonomy.folders.archive}/:`,
+    );
+    for (const m of moves) console.log(`  ${m.from}  →  ${m.to}`);
+    console.log(
+      `\nPass --commit to move them. (All content folders incl. 03_Projects — a completed phase/project archives like any stale note; memoryd archives ongoing staleness on its own.)`,
+    );
+    return 0;
+  }
+
+  let moved = 0;
+  for (const m of moves) {
+    const toAbs = path.join(vault, m.to);
+    try {
+      fs.mkdirSync(path.dirname(toAbs), { recursive: true });
+      fs.renameSync(path.join(vault, m.from), toAbs);
+      moved += 1;
+      console.log(`  moved: ${m.from}  →  ${m.to}`);
+    } catch (err) {
+      console.error(`  FAILED: ${m.from} (${String(err)})`);
+    }
+  }
+  console.log(
+    `archive-stale: moved ${moved}/${moves.length}. memoryd reindexes on its next pass (or restart).`,
+  );
+  return 0;
+}

package/src/commands/hook.ts

@@ -39,6 +39,15 @@ import {
   getTaxonomy,
   isLocaleId,
   resolveAgentName,
+  resolveZone,
+  splitFrontmatter,
+  parseNoteTags,
+  parseDictionaryTags,
+  tagGateProblems,
+  tagsDictionarySourceRel,
+  DEFAULT_DEDUP_THRESHOLD,
+  DEFAULT_LINK_HINT_THRESHOLD,
+  type TaxonomyPreset,
 } from "@agfpd/iapeer-memory-core";
 import { memoryPaths, type MemoryPaths } from "../paths.js";
 import { DEFAULT_HEARTBEAT_STALE_MS } from "./verify.js";
@@ -113,15 +122,6 @@ export type PostWriteResult = {
   output: string | null;
 };
 
-export function reminderText(inboxFolder: string): string {
-  return (
-    "[iapeer-memory] New note in your agent memory. Check the guide's " +
-    "canon-vs-memory filter: does any part of it belong to the team's shared " +
-    `knowledge? If yes — also drop a draft into ${inboxFolder}/ and mention ` +
-    "this note inline as [[Title]] in the draft body; the Index will link them."
-  );
-}
-
 export function runPostWrite(
   eventJson: string,
   env: Record<string, string | undefined> = process.env,
@@ -182,26 +182,225 @@ export function runPostWrite(
     stamp: true,
   });
 
-  // Reminder: ONLY on a claude Write (new note) in the author's OWN memory
-  // folder — an Edit-loop must not spam the context (reference semantics).
-  // The codex branch NEVER emits: hookSpecificOutput.additionalContext is a
-  // claude protocol — codex support is unverified (upstream issue #19385
-  // ASKS for it, which reads as «not there»; fact-checked stance, not a gap).
-  const ownMemoryDir =
-    path.join(vault, taxonomy.folders.agentMemory, agent) + path.sep;
-  const output =
-    tool === "Write" && files[0]!.startsWith(ownMemoryDir)
-      ? JSON.stringify({
-          hookSpecificOutput: {
-            hookEventName: "PostToolUse",
-            additionalContext: reminderText(taxonomy.folders.inbox),
-          },
-        })
-      : null;
-
+  // TAG GATE (lean §3): validate the canon note's tags against the dictionary
+  // and teach the author to fix any problem (unknown tag / no tag). The guard
+  // stays SILENT on a clean write (§2.3) — output is non-null ONLY on a
+  // problem. RUNTIME-AGNOSTIC: codex supports PostToolUse `additionalContext`
+  // too (official codex hooks docs — the earlier «claude-only» was wrong), so
+  // the SAME schema reaches both runtimes. `files` already covers claude
+  // Write/Edit and codex apply_patch (multi-file).
+  const problems = collectTagProblems(files, vault, taxonomy);
+  const output = problems.length
+    ? JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "PostToolUse",
+          additionalContext: tagTeaching(problems),
+        },
+      })
+    : null;
   return { stamped: true, output };
 }
 
+/**
+ * Tag-gate problems across the just-written CANON files (lean §3). Reads the
+ * dictionary from the vault; FAIL-OPEN — an unreadable/empty dictionary (e.g.
+ * an evicted iCloud placeholder) yields no problems rather than rejecting
+ * every tag. The agent-memory (operative) zone is not gated (canon only).
+ */
+export function collectTagProblems(
+  files: string[],
+  vault: string,
+  taxonomy: TaxonomyPreset,
+): string[] {
+  const dictRel = tagsDictionarySourceRel(taxonomy);
+  let allow: Set<string> | null = null;
+  try {
+    const dict = fs.readFileSync(path.join(vault, dictRel), "utf-8");
+    if (dict.trim()) allow = new Set(parseDictionaryTags(dict));
+  } catch {
+    // fail-open
+  }
+  if (!allow) return [];
+  const out: string[] = [];
+  for (const f of files) {
+    if (resolveZone(f, vault, taxonomy) !== "permanent") continue;
+    let fm: string;
+    try {
+      fm = splitFrontmatter(fs.readFileSync(f, "utf-8"))[0];
+    } catch {
+      continue;
+    }
+    const problems = tagGateProblems(parseNoteTags(fm), allow, {
+      requireAtLeastOne: true,
+      dictionaryRel: dictRel,
+    });
+    for (const p of problems) out.push(`${path.basename(f)}: ${p}`);
+  }
+  return out;
+}
+
+export function tagTeaching(problems: string[]): string {
+  return (
+    "[iapeer-memory] tag check — fix so this canon note indexes cleanly:\n" +
+    problems.map((p) => `- ${p}`).join("\n")
+  );
+}
+
+// ── dedup hint (lean §3a) ──────────────────────────────────────────────────────
+
+/** Short fail-open budget for the dedup RPC — a slow/down memoryd must never
+ *  hang a write-hook (same posture as the embedding circuit-breaker). */
+export const DEDUP_TIMEOUT_MS = 1500;
+
+type DedupResponse = {
+  enabled: boolean;
+  matches: Array<{ path: string; title: string; similarity: number }>;
+};
+
+/** Dedup band (≥ DEDUP_THRESHOLD → «possible duplicate», §3a) and link-hint
+ *  band ([LINK_HINT_THRESHOLD, DEDUP_THRESHOLD) → «maybe link», §3b) for a
+ *  canon write. One `/dedup` query, classified here. */
+export type WriteHints = { dup: string[]; link: string[] };
+
+function numEnv(v: string | undefined, fallback: number): number {
+  const n = Number(v);
+  return v !== undefined && !Number.isNaN(n) ? n : fallback;
+}
+
+/** POST the note body to memoryd's loopback /dedup RPC through the egress hub
+ *  (loopback allowance — П6 topology), asking for matches ≥ queryThreshold.
+ *  Fail-open: any error (timeout, refused, bad JSON) → null → silent. */
+async function dedupFetch(
+  egress: Egress,
+  env: Record<string, string | undefined>,
+  content: string,
+  dupThreshold: number,
+  linkThreshold: number,
+): Promise<DedupResponse | null> {
+  const port = env.IAPEER_MEMORY_MCP_PORT || "8766";
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), DEDUP_TIMEOUT_MS);
+  try {
+    const res = await egress.fetch(`http://127.0.0.1:${port}/dedup`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      // Send BOTH band bounds so the daemon caps each band independently and
+      // the §3b link band is never starved by a burst of §3a dup matches.
+      body: JSON.stringify({ content, threshold: dupThreshold, linkThreshold }),
+      signal: controller.signal,
+    });
+    if (!res.ok) return null;
+    return (await res.json()) as DedupResponse;
+  } catch {
+    return null; // fail-open
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * Dedup + link hints for a just-written CANON note (lean §3a + §3b). ONE
+ * `/dedup` query (threshold = the lower band bound), classified into two
+ * contiguous bands: cosine ≥ DEDUP_THRESHOLD → «possible duplicate» (§3a);
+ * [LINK_HINT_THRESHOLD, DEDUP_THRESHOLD) → «maybe link» (§3b). Re-parses the
+ * event independently of `runPostWrite` (keeps that sync contract). Runtime-
+ * agnostic (Write/Edit + codex apply_patch). Canon-zone only. Embeddings-off →
+ * memoryd returns enabled:false → both bands empty (silent).
+ */
+export async function collectDedupAndLinkHints(
+  eventJson: string,
+  egress: Egress,
+  env: Record<string, string | undefined> = process.env,
+): Promise<WriteHints> {
+  const empty: WriteHints = { dup: [], link: [] };
+  let event: {
+    tool_name?: string;
+    cwd?: string;
+    tool_input?: { file_path?: string };
+    tool_response?: unknown;
+  };
+  try {
+    event = JSON.parse(eventJson) as typeof event;
+  } catch {
+    return empty;
+  }
+  const tool = event.tool_name ?? "";
+  if (!POST_WRITE_TOOLS.has(tool)) return empty;
+  const vault = env.IAPEER_MEMORY_VAULT_PATH ?? "";
+  if (!vault) return empty;
+  const localeRaw = env.IAPEER_MEMORY_LOCALE || "en";
+  if (!isLocaleId(localeRaw)) return empty;
+  const taxonomy = getTaxonomy(localeRaw);
+
+  const dupThreshold = numEnv(env.IAPEER_MEMORY_DEDUP_THRESHOLD, DEFAULT_DEDUP_THRESHOLD);
+  const linkLow = numEnv(env.IAPEER_MEMORY_LINK_HINT_THRESHOLD, DEFAULT_LINK_HINT_THRESHOLD);
+
+  // Candidate files: claude Write/Edit carry one file_path; codex apply_patch
+  // carries a patch over possibly many (RUNTIME-AGNOSTIC — the additionalContext
+  // hint reaches both runtimes via the same channel).
+  const candidates =
+    tool === "apply_patch" ? applyPatchPaths(event) : [event.tool_input?.file_path ?? ""];
+  const vaultPrefix = vault.endsWith(path.sep) ? vault : vault + path.sep;
+  const files = candidates.filter(
+    (p) => p.endsWith(".md") && p.startsWith(vaultPrefix) && fs.existsSync(p),
+  );
+  const dup: string[] = [];
+  const link: string[] = [];
+  for (const file of files) {
+    if (resolveZone(file, vault, taxonomy) !== "permanent") continue; // canon only
+    let body: string;
+    try {
+      body = splitFrontmatter(fs.readFileSync(file, "utf-8"))[1];
+    } catch {
+      continue;
+    }
+    if (!body.trim()) continue;
+    const result = await dedupFetch(egress, env, body, dupThreshold, linkLow);
+    if (!result?.enabled || !result.matches?.length) continue;
+    for (const m of result.matches) {
+      if (path.basename(m.path) === path.basename(file)) continue; // self-guard (belt + braces)
+      const entry = `[[${m.title}]] (${Math.round(m.similarity * 100)}%)`;
+      if (m.similarity >= dupThreshold) dup.push(entry);
+      else if (m.similarity >= linkLow) link.push(entry);
+    }
+  }
+  return { dup, link };
+}
+
+/** Combine the sync tag-teaching output with the async dedup + link hints into
+ *  one additionalContext blob (or null when all empty). */
+export function mergeHookOutput(tagOutput: string | null, hints: WriteHints): string | null {
+  let ctx = "";
+  if (tagOutput) {
+    try {
+      ctx = (JSON.parse(tagOutput).hookSpecificOutput?.additionalContext as string) ?? "";
+    } catch {
+      ctx = "";
+    }
+  }
+  const add = (section: string) => {
+    ctx = ctx ? `${ctx}\n\n${section}` : section;
+  };
+  if (hints.dup.length) {
+    add(
+      "[iapeer-memory] possible duplicate(s) of this canon note — verify, then extend " +
+        "the existing note or keep only new material:\n" +
+        hints.dup.map((h) => `- ${h}`).join("\n"),
+    );
+  }
+  if (hints.link.length) {
+    add(
+      "[iapeer-memory] semantically close note(s) — consider linking [[…]] in the text " +
+        "if related (you decide; not every close note belongs):\n" +
+        hints.link.map((h) => `- ${h}`).join("\n"),
+    );
+  }
+  if (!ctx) return null;
+  return JSON.stringify({
+    hookSpecificOutput: { hookEventName: "PostToolUse", additionalContext: ctx },
+  });
+}
+
 // ── session-start ────────────────────────────────────────────────────────────
 
 export type SessionStartResult = {
@@ -298,8 +497,11 @@ export async function cmdHook(argv: string[], egress: Egress): Promise<number> {
   try {
     switch (event) {
       case "post-write": {
-        const result = runPostWrite(await Bun.stdin.text());
-        if (result.output) console.log(result.output);
+        const text = await Bun.stdin.text();
+        const result = runPostWrite(text); // sync: stamp + tag gate
+        const hints = await collectDedupAndLinkHints(text, egress); // async, fail-open §3a/§3b
+        const output = mergeHookOutput(result.output, hints);
+        if (output) console.log(output);
         return 0;
       }
       case "session-start": {

package/src/commands/init.ts

@@ -28,8 +28,11 @@ import {
   getTaxonomy,
   isLocaleId,
   renderDoctrine,
+  resolveMode,
+  curationPlan,
   writeHostWideGuideFragment,
   type LocaleId,
+  type MemoryMode,
 } from "@agfpd/iapeer-memory-core";
 import { installBinary } from "../binary.js";
 import { IAPEER_BIN, type Egress } from "../egress.js";
@@ -56,10 +59,8 @@ import {
   patchWakePolicyEphemeral,
   registerTimer,
   registerWatcher,
-  sweepTimerMessage,
   writeDreamGateScript,
   writeLauncherScript,
-  writeStaleCheckScript,
 } from "../watcher.js";
 
 type InitFlags = {
@@ -68,6 +69,8 @@ type InitFlags = {
   human?: string;
   embeddingEndpoint?: string;
   rerankerEndpoint?: string;
+  /** Curation mode (lean §7); default lean for new installs. */
+  mode?: string;
   nonInteractive: boolean;
   skipDeps: boolean;
   skipEcosystem: boolean;
@@ -98,6 +101,7 @@ function parseFlags(argv: string[]): InitFlags | null {
       case "--human": f.human = take(); break;
       case "--embedding-endpoint": f.embeddingEndpoint = take(); break;
       case "--reranker-endpoint": f.rerankerEndpoint = take(); break;
+      case "--mode": f.mode = take(); break;
       case "--non-interactive": f.nonInteractive = true; break;
       case "--skip-deps": f.skipDeps = true; break;
       case "--skip-ecosystem": f.skipEcosystem = true; break;
@@ -195,6 +199,21 @@ export async function cmdInit(argv: string[], egress: Egress): Promise<number> {
     return 2;
   }
   const locale: LocaleId = localeRaw;
+
+  // Curation mode (lean §7). Resolution: an explicit --mode wins; else PRESERVE
+  // the host's existing mode (cli.ts loads config.env into process.env before
+  // dispatch — a re-init of a curated host must NOT silently flip to lean and
+  // mis-wire its triggers, §10.3 / mode.ts); else default lean for a truly NEW
+  // install (cheap by default — the curation overlay is a deliberate opt-in).
+  const envMode = (process.env.IAPEER_MEMORY_MODE ?? "").trim().toLowerCase();
+  const preserved = envMode === "lean" || envMode === "curated" ? envMode : "lean";
+  const modeRaw = (flags.mode ?? preserved).trim().toLowerCase();
+  if (modeRaw !== "lean" && modeRaw !== "curated") {
+    console.error(`iapeer-memory init: --mode must be "lean" or "curated" (got "${flags.mode}")`);
+    return 2;
+  }
+  const mode: MemoryMode = modeRaw;
+  const plan = curationPlan(resolveMode({ ...process.env, IAPEER_MEMORY_MODE: mode }).roles);
   if (!human) {
     human = interactive
       ? ask("Human owner personality (empty = no human role)", humanDefault)
@@ -254,11 +273,12 @@ export async function cmdInit(argv: string[], egress: Egress): Promise<number> {
     configFile: paths.configFile,
     vaultPath: vault,
     locale,
+    mode,
     human: human || null,
     embeddingEndpoint: embeddingEndpoint || null,
     rerankerEndpoint: rerankerEndpoint || null,
   });
-  step("config", `${paths.configFile} (${cfg})`);
+  step("config", `${paths.configFile} (${cfg}) mode=${mode}`);
 
   // 4. stable binary
   if (flags.skipBinary) {
@@ -372,10 +392,12 @@ export async function cmdInit(argv: string[], egress: Egress): Promise<number> {
     );
   }
 
-  // 7. notifier wiring (ADR-015, инверсия): the EVENT trigger targets the
-  // SCRIBER (first receiver); two TIMERS target the index — weekly
-  // DREAM_TICK and the check-gated fail-open sweep. Registrant = index for
-  // all three (one durable profile to verify); same-id re-send = replace.
+  // 7. notifier wiring — GATED by the curation plan (lean §7). The WATCHER
+  // ALWAYS registers: its script LAUNCHES memoryd (the base — детектор/архив/
+  // проекция/dedup — runs in BOTH modes; never gated). Its forward target is
+  // the §7.1 conditional (scriber→index→placeholder), and memoryd SUPPRESSES
+  // curation emits in full-lean so the forward is empty. The SWEEP (→index)
+  // and DREAM (→dreamweaver) timers register ONLY when their role is proactive.
   if (flags.skipEcosystem) {
     step("watcher", "skipped (--skip-ecosystem)");
     step("timers", "skipped (--skip-ecosystem)");
@@ -383,6 +405,7 @@ export async function cmdInit(argv: string[], egress: Egress): Promise<number> {
     writeLauncherScript({ launcherPath: paths.launcherPath, binaryPath: paths.binaryPath });
     const sent = registerWatcher(egress, {
       launcherPath: paths.launcherPath,
+      target: plan.eventTarget ?? undefined, // null (full-lean) → default placeholder; memoryd emits nothing
       iapeerBin: flags.iapeerBin,
     });
     step(
@@ -390,41 +413,35 @@ export async function cmdInit(argv: string[], egress: Egress): Promise<number> {
       sent.suppressed
         ? "skipped (test sandbox — sends suppressed)"
         : sent.ok
-          ? `registration sent (${paths.launcherPath} → target scriber); confirm: iapeer-memory verify`
+          ? `registered (launches memoryd; curation target: ${plan.eventTarget ?? "none — lean: base runs, curation silent"}); confirm: iapeer-memory verify`
           : `registration failed — ${sent.detail}`,
       sent.ok || Boolean(sent.suppressed),
     );
 
-    writeStaleCheckScript({
-      checkScriptPath: paths.checkScriptPath,
-      vaultPath: vault,
-      inboxFolders: [getTaxonomy(locale).folders.inbox, getTaxonomy(locale).folders.inboxHuman],
-    });
-    const sweep = registerTimer(egress, {
-      message: sweepTimerMessage({ checkScriptPath: paths.checkScriptPath }),
-      iapeerBin: flags.iapeerBin,
-    });
-    writeDreamGateScript({
-      dreamGateScriptPath: paths.dreamGateScriptPath,
-      binaryPath: paths.binaryPath,
-    });
-    const dream = registerTimer(egress, {
-      message: dreamTimerMessage({
-        cron: process.env.IAPEER_MEMORY_DREAM_CRON,
+    if (plan.dream) {
+      writeDreamGateScript({
         dreamGateScriptPath: paths.dreamGateScriptPath,
-      }),
-      iapeerBin: flags.iapeerBin,
-    });
-    const timersSandboxed = sweep.suppressed && dream.suppressed;
-    step(
-      "timers",
-      timersSandboxed
-        ? "skipped (test sandbox — sends suppressed)"
-        : sweep.ok && dream.ok
-          ? `sweep (@every 1h, check ${paths.checkScriptPath}) + dream-tick (weekly, gated, → ${DREAM_TARGET})`
-          : `sweep: ${sweep.ok ? "sent" : sweep.detail}; dream: ${dream.ok ? "sent" : dream.detail}`,
-      Boolean(timersSandboxed) || (sweep.ok && dream.ok),
-    );
+        binaryPath: paths.binaryPath,
+      });
+      const dream = registerTimer(egress, {
+        message: dreamTimerMessage({
+          cron: process.env.IAPEER_MEMORY_DREAM_CRON,
+          dreamGateScriptPath: paths.dreamGateScriptPath,
+        }),
+        iapeerBin: flags.iapeerBin,
+      });
+      step(
+        "dream",
+        dream.suppressed
+          ? "skipped (test sandbox)"
+          : dream.ok
+            ? `dream-tick (weekly, gated → ${DREAM_TARGET})`
+            : `dream: ${dream.detail}`,
+        dream.ok || Boolean(dream.suppressed),
+      );
+    } else {
+      step("dream", `not registered (mode ${mode}: dreamweaver not proactive)`);
+    }
   }
 
   // 8. slot + surfaces + v1.1 migration — ORDER MATTERS (ADR-009 v1.2):

package/src/commands/memoryd.ts

@@ -4,8 +4,8 @@
  *   iapeer-memory memoryd [--mcp-port N | --no-mcp] [--human NAME]
  *
  * This IS the watcher script the notifier supervises: stdout carries the
- * event signal lines (INBOX_NEW / PERMANENT_* — core emits them), stderr
- * carries logs, SIGTERM/SIGINT shut down cleanly (flush + close). All state
+ * curation signal line (CURATOR_TICK — core emits it per cadence pass),
+ * stderr carries logs, SIGTERM/SIGINT shut down cleanly (flush + close). All state
  * paths come from the shared `paths.ts` namespace — the heartbeat lands
  * exactly where `verify` reads it, by construction.
  *
@@ -17,7 +17,7 @@
  */
 
 import fs from "node:fs";
-import { configFromEnv, startMemoryd } from "@agfpd/iapeer-memory-core";
+import { configFromEnv, startMemoryd, resolveMode, curationPlan } from "@agfpd/iapeer-memory-core";
 import { authorIndexPath, memoryPaths } from "../paths.js";
 import { guardedWriteFileSync, guardedUnlinkSync } from "@agfpd/iapeer-memory-core";
 
@@ -51,6 +51,17 @@ export async function cmdMemoryd(argv: string[]): Promise<number> {
   }
 
   const config = configFromEnv();
+  // Lean §7 emit-suppression: memoryd ALWAYS runs (the base — детектор/архив/
+  // проекция/dedup), but it EMITS the curation event (CURATOR_TICK) only when
+  // a proactive curation receiver exists (scriber ∥ index). Full-lean → a
+  // no-op emit: the curator tick still runs (the baseline stays current — a
+  // later lean→curated switch is clean), the watcher forwards nothing. The
+  // watcher trigger ITSELF always registers (it launches memoryd; never gated).
+  const { mode, roles } = resolveMode(process.env);
+  const emitCuration = curationPlan(roles).emit;
+  process.stderr.write(
+    `iapeer-memory memoryd: mode=${mode} curation-emit=${emitCuration ? "on" : "off (lean)"}\n`,
+  );
   const paths = memoryPaths();
   for (const dir of [paths.stateDir, paths.cacheDir, paths.logsDir]) {
     fs.mkdirSync(dir, { recursive: true });
@@ -67,6 +78,8 @@ export async function cmdMemoryd(argv: string[]): Promise<number> {
 
   const handle = await startMemoryd({
     config,
+    // full-lean → suppress curation emits (no-op); else core default (stdout).
+    emit: emitCuration ? undefined : () => {},
     heartbeatPath: paths.heartbeatPath,
     hashStatePath: paths.hashStatePath,
     tagsMirrorPath: paths.tagsMirrorPath,

package/src/commands/render.ts

@@ -125,7 +125,10 @@ function renderFragment(argv: string[]): number {
       logs: paths.logsDir,
     },
     authorIndexPath: indexFile,
-    tagsDictionaryPath: agent === indexAgent ? paths.tagsMirrorPath : undefined,
+    // lean §3: the compact projection goes to EVERY peer (memoryd renders the
+    // projection file; a missing file is skipped gracefully by buildLayers).
+    tagsProjectionPath: paths.tagsProjectionPath,
+    tagsTitle: config.taxonomy.systemFiles.tagsDictionary,
   };
   const written = renderPeerFragment({ peerCwd, env });
   console.log(`render fragment: ${written}`);