@modusensus/dsh-mneme 0.4.1 → 0.4.2

package/src/{sleep.js → dream/sleep.js}

@@ -1,22 +1,30 @@
-// System-level sleep (v0.4.1): an idle-triggered, LLM-assisted deep pass over
-// the memory store. Three independent, fail-safe phases:
+// System-level sleep (v0.4.0): an idle-triggered, LLM-assisted deep pass over
+// the memory store. Four independent, fail-safe phases:
 //   1. conflict resolution — high-similarity same-type pairs are either parked
 //      for review (freeze mode) or adjudicated by the LLM (winner kept / loser
-//      archived), reusing the dream conflict machinery.
+//      archived), reusing the dream conflict machinery. Strictness-graded.
 //   2. archival demotion — memories unreferenced past sleepArchiveDays shrink
 //      to a one-line summary with the full body moved to _full_content; past
-//      sleepDeepArchiveDays they are archived outright.
+//      sleepCompressDays they are archived outright.
 //   3. pattern discovery — the LLM scans the most recent memories and mints
 //      type=pattern entries carrying evidence id references.
+//   4. relation completion — orphan entities (zero relations) get implied
+//      relations completed from memory co-occurrence.
 // Each phase is wrapped so one failure never aborts the others, and a missing
-// LLM route / semantic embedder only skips the phases that need it.
+// LLM route / semantic embedder only skips the phases that need it. A run is
+// abortable via an AbortController signal (user activity) — phases check the
+// signal between batches so a running cycle yields promptly.
 import { randomUUID, createHash } from "node:crypto";
-import { validateDecisions, applyDecisions } from "./dream/decisions.js";
-import { findPotentialConflicts } from "./dream/clustering.js";
-import { buildReceipt } from "./dream.js";
+import { validateDecisions, applyDecisions } from "./decisions.js";
+import { findPotentialConflicts } from "./clustering.js";
+import { buildReceipt } from "../dream.js";
 
 const SUMMARY_MAX = 120;
-const CONFLICT_THRESHOLD = 0.85;
+// Conflict similarity threshold per strictness level (v0.4.0):
+//   gentle     only high-confidence pairs (0.92) — first-time users
+//   normal     standard dream-level (0.85) — default
+//   aggressive low-confidence pairs too (0.75) — bloated stores
+const CONFLICT_THRESHOLDS = { gentle: 0.92, normal: 0.85, aggressive: 0.75 };
 
 const CONFLICT_PROMPT = `你是记忆库冲突仲裁助手。下面是检测到的高相似度记忆对，可能内容矛盾或重复。
 对每一对输出一个 decision 对象：
@@ -92,14 +100,17 @@ function makeSummary(m) {
  * conflict_pending for human review (no LLM). Otherwise the LLM adjudicates:
  * each pair → winner kept / loser archived. Returns a per-run summary.
  */
-async function phaseConflicts(ctx, service, config, logger, runId, semantic = null) {
+async function phaseConflicts(ctx, service, config, logger, runId, semantic = null, signal = null) {
   const embedder = semantic?.embedder;
   const vectorIndex = semantic?.vectorIndex;
   if (!embedder || !vectorIndex || typeof embedder.embed !== "function") {
     return { status: "skipped", reason: "no semantic embedder" };
   }
+  const strictness = config.sleepConflictStrictness ?? "normal";
+  const threshold = CONFLICT_THRESHOLDS[strictness] ?? CONFLICT_THRESHOLDS.normal;
   const memories = service.all().filter((m) => !m.archived && !m.forgotten && m.type !== "summary");
   if (memories.length < 2) return { status: "skipped", reason: "too few memories" };
+  if (signal?.aborted) return { status: "aborted", reason: "user activity" };
 
   // Backfill + collect vectors for every eligible memory (best effort).
   const vectors = new Array(memories.length);
@@ -131,7 +142,7 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
   const usableMemories = usable.map((i) => memories[i]);
   const usableVectors = usable.map((i) => vectors[i]);
 
-  const pairs = findPotentialConflicts(usableMemories, usableVectors, CONFLICT_THRESHOLD);
+  const pairs = findPotentialConflicts(usableMemories, usableVectors, threshold);
   if (pairs.length === 0) return { status: "skipped", reason: "no conflicts found" };
 
   // Dedupe: each memory participates in at most one pair, highest similarity
@@ -218,20 +229,21 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
  * truncations, and the full body is preserved in _full_content so nothing is
  * lost. Deterministic and cheap, so it runs even with no LLM route.
  */
-function phaseDemotion(service, config, logger, runId) {
+function phaseDemotion(service, config, logger, runId, signal = null) {
   const archiveDays = config.sleepArchiveDays ?? 30;
-  const deepArchiveDays = config.sleepDeepArchiveDays ?? 90;
+  const compressDays = config.sleepCompressDays ?? 90;
   const archiveCut = Date.now() - archiveDays * 86400000;
-  const deepCut = Date.now() - deepArchiveDays * 86400000;
+  const compressCut = Date.now() - compressDays * 86400000;
   const demoted = [];
   const archived = [];
   for (const m of service.all()) {
+    if (signal?.aborted) break;
     if (m.archived || m.forgotten) continue;
     const ref = m.last_accessed_at ?? m.updated_at ?? m.created_at;
     if (!ref) continue;
     const t = new Date(ref).getTime();
     if (Number.isNaN(t)) continue;
-    if (t < deepCut) {
+    if (t < compressCut) {
       service.setArchived(m.id, true);
       archived.push(m.id);
     } else if (t < archiveCut) {
@@ -254,20 +266,21 @@ function phaseDemotion(service, config, logger, runId) {
  * The empty snapshot is intentional: create claims no existing id, so the
  * "every id claimed" invariant is trivially satisfied for pure-create lists.
  */
-async function phasePatterns(ctx, service, config, logger, runId) {
+async function phasePatterns(ctx, service, config, logger, runId, signal = null) {
   const route = resolveSleepRoute(ctx, config, logger);
   if (!route) return { status: "skipped", reason: "no llm route" };
-  const limit = config.sleepPatternScanCount ?? 100;
+  const limit = config.sleepPatternMinMemories ?? 100;
   const memories = service
     .list({ limit: 200, includeForgotten: false })
     .filter((m) => !m.archived && m.type !== "summary" && m.type !== "pattern")
     .sort((a, b) => (a.updated_at < b.updated_at ? 1 : -1))
     .slice(0, limit);
   if (memories.length === 0) return { status: "skipped", reason: "no memories to scan" };
+  if (signal?.aborted) return { status: "aborted", reason: "user activity" };
   const listText = memories
     .map((m) => `id=${m.id} | type=${m.type} | importance=${m.importance} | updated=${m.updated_at} | title=${m.title} | content=${m.content}`)
     .join("\n");
-  const maxPatterns = config.sleepMaxPatterns ?? 5;
+  const maxPatterns = config.sleepMaxPatternPerRun ?? 3;
   const text = await streamText(ctx, {
     provider: route.provider,
     model: route.model,
@@ -305,6 +318,61 @@ async function phasePatterns(ctx, service, config, logger, runId) {
   };
 }
 
+/**
+ * Phase 4 — entity relation completion. Detects orphan entities (zero
+ * relations) and completes implied relations from memory co-occurrence:
+ * entities named in the same memory → related_to; container kinds
+ * (project/module) → part_of; tech-ish pairs → depends_on. Deterministic,
+ * no LLM — cheap, so it runs even without a route. saveRelation is
+ * bookkeeping (no write hook), so it never re-triggers the scheduler.
+ */
+function inferRelationType(a, b) {
+  if ((a.type === "project" || a.type === "module") && a.type !== b.type) return "part_of";
+  if ((b.type === "project" || b.type === "module") && b.type !== a.type) return "part_of";
+  if (/npm|plugin|api|sdk|lib|framework|package|deps?|build/i.test(`${a.name} ${b.name}`)) return "depends_on";
+  return "related_to";
+}
+
+function phaseRelations(service, config, logger, runId, signal = null) {
+  const entities = service.listEntities({ limit: 1000 }) ?? [];
+  if (entities.length < 2) return { status: "skipped", reason: "too few entities" };
+  const orphans = entities.filter((e) => (service.getRelations(e.id) ?? []).length === 0);
+  if (orphans.length === 0) return { status: "skipped", reason: "no orphan entities" };
+  const memories = service.all().filter((m) => !m.archived && !m.forgotten);
+  const seen = new Set();
+  const related = [];
+  const MAX_RELATIONS_PER_ORPHAN = 3;
+  for (const o of orphans) {
+    if (signal?.aborted) break;
+    let made = 0;
+    for (const m of memories) {
+      if (signal?.aborted || made >= MAX_RELATIONS_PER_ORPHAN) break;
+      const text = `${m.title ?? ""} ${m.content ?? ""}`;
+      if (!text.includes(o.name)) continue;
+      for (const other of entities) {
+        if (other.id === o.id || other.name === o.name) continue;
+        const key = [o.id, other.id].sort().join("|");
+        if (seen.has(key)) continue;
+        if (!text.includes(other.name)) continue;
+        const relationType = inferRelationType(o, other);
+        try {
+          service.saveRelation({ from_entity: o.id, to_entity: other.id, relation_type: relationType, memory_id: m.id, metadata: { source: "sleep_relation_completion" } });
+          seen.add(key);
+          related.push({ from: o.id, to: other.id, type: relationType });
+          made++;
+        } catch (error) {
+          logger?.warn?.(`dsh-mneme sleep: relation ${o.id}/${other.id} failed: ${String(error)}`);
+        }
+      }
+    }
+  }
+  return {
+    status: related.length > 0 ? "ok" : "noop",
+    orphanCount: orphans.length,
+    related
+  };
+}
+
 // ---------------------------------------------------------------- run
 
 function deriveStatus(phases) {
@@ -323,10 +391,11 @@ function deriveStatus(phases) {
  * run_type='sleep' audit row (same dream_runs table) so sleep activity is
  * observable alongside consolidation runs.
  */
-export async function runSleep(ctx, service, config, logger, semantic = null) {
+export async function runSleep(ctx, service, config, logger, semantic = null, signal = null) {
   const runId = randomUUID();
   const phases = {};
   const attempt = async (name, fn) => {
+    if (signal?.aborted) return; // user resumed activity — stop before next phase
     try {
       phases[name] = await fn();
     } catch (error) {
@@ -334,9 +403,10 @@ export async function runSleep(ctx, service, config, logger, semantic = null) {
       logger?.warn?.(`dsh-mneme sleep: ${name} phase failed: ${error?.message ?? error}`);
     }
   };
-  await attempt("conflicts", () => phaseConflicts(ctx, service, config, logger, runId, semantic));
-  await attempt("demotion", () => phaseDemotion(service, config, logger, runId));
-  await attempt("patterns", () => phasePatterns(ctx, service, config, logger, runId));
+  await attempt("conflicts", () => phaseConflicts(ctx, service, config, logger, runId, semantic, signal));
+  await attempt("demotion", () => phaseDemotion(service, config, logger, runId, signal));
+  await attempt("patterns", () => phasePatterns(ctx, service, config, logger, runId, signal));
+  await attempt("relations", () => phaseRelations(service, config, logger, runId, signal));
 
   const status = deriveStatus(phases);
   const route = resolveSleepRoute(ctx, config, logger);
@@ -398,11 +468,12 @@ export function createSleepScheduler({
   let running = false;
   let disposed = false;
   let idleTimer = null;
+  let sleepAbort = null;
 
   function armIdleTimer() {
     if (disposed || idleTimer) return;
-    if (config.sleepEnabled !== true) return;
-    const idleMs = (config.sleepIdleMinutes ?? 30) * 60000;
+    if (config.sleepModeEnabled !== true) return;
+    const idleMs = (config.sleepIdleMinutes ?? 5) * 60000;
     const delay = Math.max(0, idleMs - (now() - lastWriteAt)) + 1000;
     idleTimer = setTimeoutFn(async () => {
       idleTimer = null;
@@ -413,18 +484,29 @@ export function createSleepScheduler({
 
   function shouldRun(at = now()) {
     if (disposed || running) return false;
-    if (config.sleepEnabled !== true) return false;
-    if (at - lastWriteAt < (config.sleepIdleMinutes ?? 30) * 60000) return false;
-    if (at - lastRunAt < (config.sleepMinIntervalHours ?? 8) * 3600000) return false;
+    if (config.sleepModeEnabled !== true) return false;
+    if (at - lastWriteAt < (config.sleepIdleMinutes ?? 5) * 60000) return false;
+    // lastRunAt === 0 means never ran — the min-interval check must not block
+    // the very first cycle (a real run stamps a nonzero timestamp).
+    if (lastRunAt > 0 && at - lastRunAt < (config.sleepMinIntervalHours ?? 8) * 3600000) return false;
     return true;
   }
 
   /** Called on writes: resets the idle clock and re-arms the fire timer. The
    *  pending timer is cleared first — a stale timer armed against the old idle
    *  window would otherwise fire early, fail shouldRun, and leave nothing armed
-   *  for the next window (a missed trigger until the next write). */
+   *  for the next window (a missed trigger until the next write).
+   *
+   *  While a sleep run is executing (running=true) the in-flight AbortController
+   *  is NOT aborted: the run's own writes (demoteToSummary / setArchived ride
+   *  the normal write-hook path) would otherwise self-abort the cycle. External
+   *  activity during the run still resets the idle clock here, so no new cycle
+   *  fires until the store is quiet again. */
   function noteWrite() {
     lastWriteAt = now();
+    if (!running && sleepAbort) {
+      sleepAbort.abort(); // user resumed activity — interrupt an idle run
+    }
     if (idleTimer) {
       clearTimeoutFn(idleTimer);
       idleTimer = null;
@@ -435,16 +517,19 @@ export function createSleepScheduler({
   async function maybeSchedule() {
     if (!shouldRun()) return false;
     running = true;
+    const abort = new AbortController();
+    sleepAbort = abort;
     try {
       lastRunAt = now();
       const result = await service.enqueue(() =>
-        onRun ? onRun() : Promise.resolve({ ok: true, skipped: true })
+        onRun ? onRun(abort.signal) : Promise.resolve({ ok: true, skipped: true })
       );
       return !!(result && result.ok);
     } catch (error) {
       logger?.warn?.(`dsh-mneme sleep: run failed: ${error?.message ?? error}`);
       return false;
     } finally {
+      sleepAbort = null;
       running = false;
     }
   }
@@ -455,6 +540,10 @@ export function createSleepScheduler({
       clearTimeoutFn(idleTimer);
       idleTimer = null;
     }
+    if (sleepAbort) {
+      sleepAbort.abort();
+      sleepAbort = null;
+    }
   }
 
   return { noteWrite, maybeSchedule, shouldRun, dispose };

package/src/index.js

@@ -5,7 +5,7 @@ import { createTools } from "./tools.js";
 import { createInjector } from "./inject.js";
 import { createSummarizer } from "./summarize.js";
 import { createDreamScheduler } from "./dream.js";
-import { createSleepScheduler, runSleep } from "./sleep.js";
+import { createSleepScheduler, runSleep } from "./dream/sleep.js";
 import { createApi } from "./api.js";
 import { createSettings } from "./settings.js";
 import { createCommandManager } from "./commands.js";
@@ -182,21 +182,18 @@ export const apply = (ctx, config) => {
     service.setDreamHook(() => dream.maybeSchedule(service));
   }
 
-  // Sleep scheduler (v0.4.1): idle-triggered deep pass (conflict resolution +
-  // archival demotion + pattern discovery). opt-in via sleepEnabled; writes
-  // through the service reset the idle clock (setSleepHook), and when the store
-  // stays quiet for sleepIdleMinutes past the sleepMinIntervalHours gate, the
-  // scheduler fires one cycle. The onRun closure reuses the same semantic
-  // pipeline as dream for the conflict phase.
+  // Sleep scheduler (v0.4.0): idle-triggered deep maintenance. Fires when the
+  // store has been quiet for sleepIdleMinutes and re-arms on every write via
+  // noteWrite (hooked to the service's write path). Runs go through
+  // service.enqueue so they serialize with autoDream — the two never overlap.
+  // Abortable on user activity; audited into dream_runs with run_type='sleep'.
   let sleep = null;
-  if (cfg.sleepEnabled) {
+  if (cfg.sleepModeEnabled) {
     sleep = createSleepScheduler({
       service,
       config: cfg,
       logger: ctx.logger,
-      onRun: () => (sleep
-        ? runSleep(ctx, service, cfg, ctx.logger, { embedder, vectorIndex })
-        : Promise.resolve({ ok: true, skipped: true }))
+      onRun: (signal) => (sleep ? runSleep(ctx, service, cfg, ctx.logger, { embedder, vectorIndex }, signal) : Promise.resolve({ ok: true, skipped: true }))
     });
     service.setSleepHook(() => sleep.noteWrite());
   }
@@ -271,7 +268,7 @@ export const apply = (ctx, config) => {
     }
     commands?.dispose();
     if (dream) await dream.dispose();
-    if (sleep) await sleep.dispose();
+    if (sleep) sleep.dispose();
     store.close();
   };
 };

package/src/mirror.js

@@ -128,21 +128,33 @@ export function createMirror(dir) {
     for (const m of memories) {
       (byType[m.type] ??= []).push(m);
     }
+    // Per-type physical outcomes (audit peer D): a failed write for one type
+    // must not abort the whole render. Each type is written (or pruned) in its
+    // own try/catch and the result reported so the caller can persist per-type
+    // committed/failed receipts — a file that was already written is a real
+    // physical commit even when a sibling type errors.
+    const results = {};
     for (const type of Object.keys(TYPE_FILE)) {
-      const file = filePath(type);
-      const items = (byType[type] ?? [])
-        .slice()
-        .sort((a, b) => (a.updated_at < b.updated_at ? 1 : -1));
-      if (items.length === 0) {
-        // no memories of this type: drop any stale mirror file so deleted
-        // memories do not "resurrect" via readHumanEdits
-        rmSync(file, { force: true });
-        continue;
+      try {
+        const file = filePath(type);
+        const items = (byType[type] ?? [])
+          .slice()
+          .sort((a, b) => (a.updated_at < b.updated_at ? 1 : -1));
+        if (items.length === 0) {
+          // no memories of this type: drop any stale mirror file so deleted
+          // memories do not "resurrect" via readHumanEdits
+          rmSync(file, { force: true });
+        } else {
+          const header = `# ${TYPE_FILE[type]} — dsh-mneme 镜像\n\n<!-- 手工编辑此文件会被合并回记忆库（人工优先）。 -->\n\n`;
+          const body = items.map(renderMemory).join("\n");
+          writeFileSync(file, header + body, "utf8");
+        }
+        results[type] = { ok: true };
+      } catch (error) {
+        results[type] = { ok: false, error: error?.message ?? String(error) };
       }
-      const header = `# ${TYPE_FILE[type]} — dsh-mneme 镜像\n\n<!-- 手工编辑此文件会被合并回记忆库（人工优先）。 -->\n\n`;
-      const body = items.map(renderMemory).join("\n");
-      writeFileSync(file, header + body, "utf8");
     }
+    return results;
   }
 
   return { filePath, sync, readHumanEdits };

package/src/service.js

@@ -9,9 +9,9 @@ export function createService({ store, mirror, config, onWrite, logger }) {
   // passed in the constructor). Fired on the same write events as onWrite.
   let dreamHook = null;
 
-  // Optional sleep scheduler hook (v0.4.1), installed via setSleepHook after
-  // creation. Fired on the same write events: it tells the sleep scheduler the
-  // store just changed so the idle-detection clock resets.
+  // Optional sleep scheduler hook (v0.4.0), installed via setSleepHook after
+  // creation. Fired on the same write events as onWrite: it tells the sleep
+  // scheduler the store just changed so the idle-detection clock resets.
   let sleepHook = null;
 
   // Optional vector embedder, installed via setEmbedder after creation. After
@@ -42,7 +42,7 @@ export function createService({ store, mirror, config, onWrite, logger }) {
   // replays them exactly once against the committed state.
   let txDepth = 0;
 
-  // Serial task queue (sleep v0.4.1). Long-running background passes — dream
+  // Serial task queue (sleep v0.4.0). Long-running background passes — dream
   // consolidation, sleep cycles — must never overlap: two sleep runs racing
   // would double-demote or double-mint patterns. enqueue chains the task onto
   // a promise tail so N callers can queue work that runs strictly one at a
@@ -205,7 +205,9 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     for (const mem of keywordHits) {
       if (!merged.has(mem.id)) merged.set(mem.id, { ...mem, _source: "keyword", _score: 0.7 });
     }
-    return Array.from(merged.values()).sort((a, b) => b._score - a._score).slice(0, topK);
+    const hits = Array.from(merged.values()).sort((a, b) => b._score - a._score).slice(0, topK);
+    touchRecalled(hits);
+    return hits;
   }
 
   /**
@@ -223,7 +225,9 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     // store.findMemoriesByAttr —— 空 value 契约 = 返回该 attr_key 的全部
     // 当前有效记忆（v0.3.0，store.js 已实现）。
     const rows = store.findMemoriesByAttr(key, value ?? "");
-    return rows.slice(0, topK);
+    const hits = rows.slice(0, topK);
+    touchRecalled(hits);
+    return hits;
   }
 
   /**
@@ -253,6 +257,23 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     return base * (0.5 + (row.importance ?? 3) / 10);
   }
 
+  /**
+   * Sleep touch (v0.4.0): when sleep is enabled, any memory surfaced by recall
+   * or auto-injection gets its last_accessed_at bumped, so the "unrecalled N
+   * days → demote/archive" tiering counts real access. Best-effort and gated on
+   * config.sleepModeEnabled — when sleep is off this is a complete no-op (no
+   * writes on the hot recall path). A touch failure must never break search/inject.
+   */
+  function touchRecalled(memories) {
+    if (config?.sleepModeEnabled !== true || !Array.isArray(memories) || memories.length === 0) return;
+    for (const m of memories) {
+      if (!m?.id) continue;
+      try {
+        store.touchLastAccess(m.id);
+      } catch { /* touch is best effort */ }
+    }
+  }
+
   async function searchMemories(query, options = {}) {
     const { mode = "auto", topK = 20, threshold, useRerank = true, recordRecall = false } = options;
     const q = String(query ?? "").trim();
@@ -261,15 +282,11 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     // entity:/attr: 前缀路由（v0.3.0 Phase 3）。entitySearchEnabled 关闭时走原逻辑。
     if (config?.entitySearchEnabled) {
       if (q.startsWith("entity:")) {
-        const hits = searchByEntity(q.slice(7).trim(), options);
-        touchRecalled(hits);
-        return hits;
+        return searchByEntity(q.slice(7).trim(), options);
       }
       if (q.startsWith("attr:")) {
         const [key, value] = q.slice(5).split("=");
-        const hits = searchByAttr(key, value, options);
-        touchRecalled(hits);
-        return hits;
+        return searchByAttr(key, value, options);
       }
     }
 
@@ -456,23 +473,6 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     return { action: "created", memory: created };
   }
 
-  /**
-   * Sleep touch (v0.4.1): when sleep is enabled, any memory surfaced by recall
-   * or auto-injection gets its last_accessed_at bumped, so the "unrecalled N
-   * days → demote/archive" tiering counts real access. Best-effort and gated on
-   * config.sleepEnabled — when sleep is off this is a complete no-op (no writes
-   * on the hot recall path). A touch failure must never break search/inject.
-   */
-  function touchRecalled(memories) {
-    if (config?.sleepEnabled !== true || !Array.isArray(memories) || memories.length === 0) return;
-    for (const m of memories) {
-      if (!m?.id) continue;
-      try {
-        store.touchAccess(m.id);
-      } catch { /* touch is best effort */ }
-    }
-  }
-
   /**
    * Candidate memories for automatic context injection:
    * summaries first, then all preferences, then non-forgotten items with
@@ -648,26 +648,53 @@ export function createService({ store, mirror, config, onWrite, logger }) {
         }
       }
 
-      // 全量渲染
-      mirror.sync(reconcileHumanEdits(list));
-
-      // 成功：CAS/fence 绑定到本地 gen，旧 worker（gen 已过期）会被拦截。
-      // 此步失败说明核心 clean 状态没写成功，向上层报失败（不再静默）。
-      try {
-        store.markMirrorCleanForGeneration(gen, now);
-      } catch (stateError) {
-        logger?.warn?.("syncMirror: markMirrorCleanForGeneration failed:", stateError);
-        return { success: false, error: stateError?.message ?? String(stateError) };
+      // Per-type physical outcome (audit peer D): mirror.sync writes each type
+      // file independently and reports per-type success/failure. A type whose
+      // file was physically committed must be marked committed even when a
+      // sibling type errors — the old code batch-failed every type on any error,
+      // leaving committed files mislabeled as failed and masking partial state.
+      // Absent entries (a type with no memories) count as success: sync prunes
+      // the stale file, which is itself a completed physical state.
+      let allOk = true;
+      const results = mirror.sync(reconcileHumanEdits(list)) ?? {};
+      for (const type of Object.keys(TYPE_FILE)) {
+        const r = results[type];
+        const ok = !r || r.ok === true;
+        if (!ok) allOk = false;
+        try {
+          if (ok) {
+            store.setTypeStatus(type, { status: "committed", applied_gen: gen, last_error: null });
+          } else {
+            store.setTypeStatus(type, { status: "failed", last_error: r.error ?? "mirror sync failed" });
+          }
+        } catch (stateError) {
+          logger?.warn?.(`syncMirror: setTypeStatus(${type}) failed:`, stateError);
+        }
       }
-      // 逐 type 标记为 committed（peer blocker 4: per-type receipt）
-      for (const type of coveredTypes) {
+
+      // 全部 type 物理收敛：CAS/fence 绑定到本地 gen，旧 worker（gen 已过期）会被
+      // 拦截。此步失败说明核心 clean 状态没写成功，向上层报失败（不再静默）。
+      if (allOk) {
         try {
-          store.setTypeStatus(type, { status: "committed", applied_gen: gen, last_error: null });
+          store.markMirrorCleanForGeneration(gen, now);
         } catch (stateError) {
-          logger?.warn?.(`syncMirror: setTypeStatus(${type}) committed failed:`, stateError);
+          logger?.warn?.("syncMirror: markMirrorCleanForGeneration failed:", stateError);
+          return { success: false, error: stateError?.message ?? String(stateError) };
         }
+        return { success: true };
+      }
+
+      // 部分 type 失败：持久 dirty（债务绑定到新轮次），下次 recover 只补未收敛
+      // 的 type。committed 的 type 已应用本轮 gen，不因兄弟失败被回滚。
+      const failedTypes = Object.entries(results)
+        .filter(([, r]) => r && r.ok === false)
+        .map(([t]) => t);
+      try {
+        store.markMirrorDirty(`mirror sync failed for: ${failedTypes.join(", ")}`, now);
+      } catch (stateError) {
+        logger?.warn?.("syncMirror: markMirrorDirty failed:", stateError);
       }
-      return { success: true };
+      return { success: false, error: `mirror sync failed for: ${failedTypes.join(", ")}` };
     } catch (error) {
       const errMsg = error?.message ?? String(error);
       logger?.warn?.("syncMirror failed:", error);
@@ -691,14 +718,17 @@ export function createService({ store, mirror, config, onWrite, logger }) {
   }
 
   // afterSync: run syncMirror and surface a failure to the operator instead of
-  // swallowing it (peer blocker 2). The mirror debt has already been persisted
-  // by markMirrorDirty inside syncMirror, so a restart recovers — but the
-  // calling write path must not report clean while the mirror is known-stale.
+  // swallowing it (peer blocker 2 + audit peer B). The mirror debt has already
+  // been persisted by markMirrorDirty inside syncMirror, so a restart recovers —
+  // but the calling write path must not report clean while the mirror is
+  // known-stale. Returns the sync result so the caller can attach an explicit
+  // degraded/pending receipt to its return value instead of faking success.
   function afterSync(label) {
     const r = syncMirror();
     if (!r?.success && !r?.deferred) {
       logger?.warn?.(`${label}: mirror sync failed (will recover on restart):`, r?.error);
     }
+    return r;
   }
 
   // recoverMirror: 启动/手动 reconcile 时根据持久 dirty 状态决定是否恢复同步
@@ -873,9 +903,20 @@ export function createService({ store, mirror, config, onWrite, logger }) {
           memory_id: id
         });
       }
-      afterSync("write");
+      const sync = afterSync("write");
       notifyWrite();
       scheduleEmbed(updated);
+      // Audit peer B: when the mirror sync failed, the store write landed but
+      // the mirror did not converge — return an explicit degraded receipt rather
+      // than a plain success. Non-enumerable so existing deepEqual assertions on
+      // the memory shape keep passing.
+      if (!sync?.success && !sync?.deferred) {
+        Object.defineProperty(updated, "_mirror", {
+          value: { status: "degraded", error: sync?.error ?? "mirror sync failed" },
+          enumerable: false,
+          configurable: true
+        });
+      }
       return updated;
     },
     // Compare-and-set update: applies the patch only when the row still carries
@@ -902,9 +943,17 @@ export function createService({ store, mirror, config, onWrite, logger }) {
           memory_id: id
         });
       }
-      afterSync("write");
+      const sync = afterSync("write");
       notifyWrite();
       scheduleEmbed(updated);
+      // Audit peer B: mirror sync failure on a CAS write must surface too.
+      if (!sync?.success && !sync?.deferred) {
+        Object.defineProperty(updated, "_mirror", {
+          value: { status: "degraded", error: sync?.error ?? "mirror sync failed" },
+          enumerable: false,
+          configurable: true
+        });
+      }
       return updated;
     },
     setForget: (id, f) => {
@@ -917,11 +966,22 @@ export function createService({ store, mirror, config, onWrite, logger }) {
       afterSync("write");
       return updated;
     },
+    // sleep-mode storage (v0.4.0). demoteToSummary / restoreContent mutate
+    // content so they ride the normal write-hook path (mirror re-renders).
+    // touchLastAccess is a read-stamp — deliberately NO write hook (a recall
+    // must not dirty the mirror). getUnrecalledSince is a pure read.
     demoteToSummary: (id, summary, opts) => {
       const updated = store.demoteToSummary(id, summary, opts);
       afterSync("write");
       return updated;
     },
+    restoreContent: (id) => {
+      const updated = store.restoreContent(id);
+      afterSync("write");
+      return updated;
+    },
+    touchLastAccess: (id, at) => store.touchLastAccess(id, at),
+    getUnrecalledSince: (cutMs, opts) => store.getUnrecalledSince(cutMs, opts),
     // autoDream audit trail: passthroughs deliberately bypass write hooks —
     // an audit write is bookkeeping, and notifyWrite would loop back into the
     // dream scheduler that just recorded the run.
@@ -944,6 +1004,12 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     // migrates entity_attrs on merge. Bookkeeping writes like the audit
     // passthroughs above — never write-hook-triggering memory mutations.
     saveRelation: (r) => store.saveRelation(r),
+    listEntities: (o) => store.listEntities(o),
+    getRelations: (id) => store.getRelations(id),
+    saveAttr: (r) => store.saveAttr(r),
+    createEntity: (r) => store.createEntity(r),
+    findEntityByName: (n) => store.findEntityByName(n),
+    findEntityById: (id) => store.findEntityById(id),
     getAttrsByMemory: (id) => store.getAttrsByMemory(id),
     migrateAttrsToMemory: (fromId, toId, now) => store.migrateAttrsToMemory(fromId, toId, now)
   };