@agfpd/iapeer-memory 0.2.9 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer-memory",
-  "version": "0.2.9",
+  "version": "0.3.1",
   "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.9"
+    "@agfpd/iapeer-memory-core": "0.3.1"
   },
   "devDependencies": {
     "@types/bun": "^1.2.0",

package/src/cli.ts

@@ -43,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
@@ -72,8 +71,8 @@ Commands:
   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.
-                            03_Projects is excluded; memoryd archives ongoing
-                            staleness incrementally on its own.
+                            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)

package/src/commands/archive-stale.ts

@@ -10,9 +10,10 @@
  *   archive-stale            DRY-RUN — list what would move + a count
  *   archive-stale --commit   actually move them
  *
- * `03_Projects` is excluded (a completed phase is a project record, not
- * displaced knowledge — `isArchivableZone`). memoryd reindexes the moves on
- * its next pass (or on restart); the verb itself only moves files.
+ * 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";
@@ -31,7 +32,7 @@ export function cmdArchiveStale(argv: string[]): number {
   const taxonomy = config.taxonomy;
 
   // Candidates: notes in the monitored content folders carrying a final
-  // status, EXCLUDING 03_Projects (filtered by shouldArchive → isArchivableZone).
+  // 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 }> = [];
@@ -63,7 +64,7 @@ export function cmdArchiveStale(argv: string[]): number {
     );
     for (const m of moves) console.log(`  ${m.from}  →  ${m.to}`);
     console.log(
-      `\nPass --commit to move them. (03_Projects is excluded — completed phases stay project-local.)`,
+      `\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;
   }

package/src/commands/hook.ts

@@ -45,6 +45,8 @@ import {
   parseDictionaryTags,
   tagGateProblems,
   tagsDictionarySourceRel,
+  DEFAULT_DEDUP_THRESHOLD,
+  DEFAULT_LINK_HINT_THRESHOLD,
   type TaxonomyPreset,
 } from "@agfpd/iapeer-memory-core";
 import { memoryPaths, type MemoryPaths } from "../paths.js";
@@ -203,7 +205,7 @@ export function runPostWrite(
  * 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. Operative/inbox zones are not gated (canon only).
+ * every tag. The agent-memory (operative) zone is not gated (canon only).
  */
 export function collectTagProblems(
   files: string[],
@@ -255,25 +257,36 @@ type DedupResponse = {
   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). Fail-open: any error (timeout,
- *  connection refused, bad JSON) → null → the caller stays silent. */
+ *  (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 thr = env.IAPEER_MEMORY_DEDUP_THRESHOLD;
-  const body: { content: string; threshold?: number } = { content };
-  if (thr && !Number.isNaN(Number(thr))) body.threshold = Number(thr);
   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" },
-      body: JSON.stringify(body),
+      // 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;
@@ -286,17 +299,20 @@ async function dedupFetch(
 }
 
 /**
- * Dedup hint lines for a just-written CANON note (lean §3a). Re-parses the
- * event independently of `runPostWrite` (keeps that sync contract intact).
- * Claude-only (Write/Edit → additionalContext); canon-zone only; queries
- * memoryd by the note BODY. Embeddings-off → memoryd returns enabled:false →
- * no hint (silent).
+ * 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 collectDedupHints(
+export async function collectDedupAndLinkHints(
   eventJson: string,
   egress: Egress,
   env: Record<string, string | undefined> = process.env,
-): Promise<string[]> {
+): Promise<WriteHints> {
+  const empty: WriteHints = { dup: [], link: [] };
   let event: {
     tool_name?: string;
     cwd?: string;
@@ -306,27 +322,32 @@ export async function collectDedupHints(
   try {
     event = JSON.parse(eventJson) as typeof event;
   } catch {
-    return [];
+    return empty;
   }
   const tool = event.tool_name ?? "";
-  if (!POST_WRITE_TOOLS.has(tool)) return [];
+  if (!POST_WRITE_TOOLS.has(tool)) return empty;
   const vault = env.IAPEER_MEMORY_VAULT_PATH ?? "";
-  if (!vault) return [];
+  if (!vault) return empty;
   const localeRaw = env.IAPEER_MEMORY_LOCALE || "en";
-  if (!isLocaleId(localeRaw)) return [];
+  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 — codex receives the
-  // additionalContext hint via the same channel).
+  // 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 hints: string[] = [];
+  const dup: string[] = [];
+  const link: string[] = [];
   for (const file of files) {
-    if (resolveZone(file, vault, taxonomy) !== "permanent") continue; // canon only (§3a)
+    if (resolveZone(file, vault, taxonomy) !== "permanent") continue; // canon only
     let body: string;
     try {
       body = splitFrontmatter(fs.readFileSync(file, "utf-8"))[1];
@@ -334,19 +355,21 @@ export async function collectDedupHints(
       continue;
     }
     if (!body.trim()) continue;
-    const result = await dedupFetch(egress, env, body);
+    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)
-      hints.push(`[[${m.title}]] (${Math.round(m.similarity * 100)}%)`);
+      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 hints;
+  return { dup, link };
 }
 
-/** Combine the sync tag-teaching output with async dedup hints into one
- *  additionalContext blob (or null when both are empty). */
-export function mergeHookOutput(tagOutput: string | null, dedupHints: string[]): string | null {
+/** 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 {
@@ -355,12 +378,22 @@ export function mergeHookOutput(tagOutput: string | null, dedupHints: string[]):
       ctx = "";
     }
   }
-  if (dedupHints.length) {
-    const dedupText =
+  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" +
-      dedupHints.map((h) => `- ${h}`).join("\n");
-    ctx = ctx ? `${ctx}\n\n${dedupText}` : dedupText;
+        "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({
@@ -466,8 +499,8 @@ export async function cmdHook(argv: string[], egress: Egress): Promise<number> {
       case "post-write": {
         const text = await Bun.stdin.text();
         const result = runPostWrite(text); // sync: stamp + tag gate
-        const dedupHints = await collectDedupHints(text, egress); // async, fail-open §3a
-        const output = mergeHookOutput(result.output, dedupHints);
+        const hints = await collectDedupAndLinkHints(text, egress); // async, fail-open §3a/§3b
+        const output = mergeHookOutput(result.output, hints);
         if (output) console.log(output);
         return 0;
       }

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

@@ -2,7 +2,7 @@
  * `iapeer-memory status` — read-only diagnostics of the whole chain
  * (ADR-009: the status surface must diagnose a socket without a system).
  * Aggregates: verify checks (NO repair) + slot declaration + a live TCP
- * probe of the MCP endpoint + the inbox load. Never mutates anything;
+ * probe of the MCP endpoint. Never mutates anything;
  * exit 1 when something needs attention.
  */
 
@@ -26,7 +26,7 @@ import { runVerify } from "./verify.js";
  * back must say so here and why.
  *
  * Source of truth ladder: (1) the LIVE pipeline as reported by the running
- * memoryd (a real vault_search call over MCP — per-component statuses, the
+ * memoryd (a real memory_search call over MCP — per-component statuses, the
  * same object every search returns); (2) when memoryd is down — the static
  * configuration view + the sqlite runtime probe. P3c live-smoke fact: in
  * the compiled binary the sqlite-vec dylib does not resolve from /$bunfs —
@@ -50,7 +50,7 @@ export function searchPipelineLine(env: Record<string, string | undefined>): str
 }
 
 /** Live pipeline from the running memoryd — the same per-component statuses
- * every vault_search returns. Null when memoryd is unreachable. */
+ * every memory_search returns. Null when memoryd is unreachable. */
 export async function probeSearchPipeline(
   egress: Egress,
   port: number,
@@ -68,7 +68,7 @@ export async function probeSearchPipeline(
         jsonrpc: "2.0",
         id: 1,
         method: "tools/call",
-        params: { name: "vault_search", arguments: { query: "status probe" } },
+        params: { name: "memory_search", arguments: { query: "status probe" } },
       }),
       signal: AbortSignal.timeout(8000),
     });
@@ -145,23 +145,5 @@ export async function cmdStatus(argv: string[], egress: Egress): Promise<number>
       (livePipeline ?? `${searchPipelineLine(process.env)} (memoryd down — static view)`),
   );
 
-  const vault = process.env.IAPEER_MEMORY_VAULT_PATH ?? "";
-  const localeRaw = process.env.IAPEER_MEMORY_LOCALE || "en";
-  if (vault && isLocaleId(localeRaw)) {
-    const inboxDir = path.join(vault, getTaxonomy(localeRaw).folders.inbox);
-    let count = 0;
-    try {
-      count = fs.readdirSync(inboxDir).filter((f) => f.endsWith(".md")).length;
-    } catch {
-      count = -1;
-    }
-    console.log(
-      `      ${"inbox".padEnd(width)}  ` +
-        (count < 0
-          ? `folder missing (${inboxDir})`
-          : `${count} draft(s) awaiting the pipeline (a growing pile = the scriber thread is stuck; the sweep places stale drafts unvetted)`),
-    );
-  }
-
   return results.some((r) => r.status === "fail") ? 1 : 0;
 }

package/src/commands/uninstall.ts

@@ -27,7 +27,7 @@ import { sweepUnprovision } from "../surfaces/sweep.js";
 import { guardedUnlinkSync } from "@agfpd/iapeer-memory-core";
 import {
   DREAM_TRIGGER_ID,
-  SWEEP_TRIGGER_ID,
+  LEGACY_SWEEP_TRIGGER_ID,
   unregisterTimer,
   unregisterWatcher,
   WATCHER_TRIGGER_ID,
@@ -160,7 +160,7 @@ export function cmdUninstall(argv: string[], egress: Egress): number {
         : `unregister not sent (${unreg.detail}) — remove the trigger manually via the watcher peer`
     }`,
   );
-  for (const id of [SWEEP_TRIGGER_ID, DREAM_TRIGGER_ID]) {
+  for (const id of [LEGACY_SWEEP_TRIGGER_ID, DREAM_TRIGGER_ID]) {
     const t = unregisterTimer(egress, { id, iapeerBin });
     console.log(
       `timer     : ${