@modusensus/dsh-mneme 0.3.8 → 0.4.1

package/src/dream/decisions.js

@@ -1,4 +1,8 @@
-const ACTIONS = new Set(["keep", "merge", "archive", "conflict", "update"]);
+const ACTIONS = new Set(["keep", "merge", "archive", "conflict", "update", "create"]);
+
+// create is used by sleep pattern discovery (v0.4.1). It fabricates a new
+// memory of any known type (default pattern) rather than touching existing ids.
+const CREATE_TYPES = new Set(["pattern", "preference", "project", "decision", "history", "summary"]);
 
 /**
  * Validate a dream decision list against a snapshot of eligible memories.
@@ -9,6 +13,7 @@ const ACTIONS = new Set(["keep", "merge", "archive", "conflict", "update"]);
 export function validateDecisions(decisions, snapshot, options = {}) {
   const errors = [];
   const maxUpdatePerRun = options.maxUpdatePerRun ?? 2;
+  const maxCreatePerRun = options.maxCreatePerRun ?? 5;
   const minAgeHours = options.minAgeHours ?? 24;
   if (!Array.isArray(decisions) || decisions.length === 0) {
     return { ok: false, errors: ["decision list must be a non-empty array"] };
@@ -20,6 +25,35 @@ export function validateDecisions(decisions, snapshot, options = {}) {
       errors.push(`${at}: invalid action ${JSON.stringify(d?.action)}`);
       continue;
     }
+    // create claims no existing id: it fabricates a new memory, so it runs its
+    // own field validation and skips the ids-required check + the claimed set.
+    if (d.action === "create") {
+      if (typeof d.title !== "string" || !d.title.trim()) {
+        errors.push(`${at}: create needs non-empty title`);
+        continue;
+      }
+      if (typeof d.content !== "string" || !d.content.trim()) {
+        errors.push(`${at}: create needs non-empty content`);
+        continue;
+      }
+      if (d.importance !== undefined && (!Number.isInteger(d.importance) || d.importance < 1 || d.importance > 5)) {
+        errors.push(`${at}: create importance must be an integer 1-5 when provided`);
+        continue;
+      }
+      if (d.type !== undefined && (typeof d.type !== "string" || !CREATE_TYPES.has(d.type))) {
+        errors.push(`${at}: create type must be one of ${[...CREATE_TYPES].join(", ")}`);
+        continue;
+      }
+      if (d.evidence !== undefined && !Array.isArray(d.evidence)) {
+        errors.push(`${at}: create evidence must be an array of memory ids`);
+        continue;
+      }
+      if (d.tags !== undefined && !Array.isArray(d.tags)) {
+        errors.push(`${at}: create tags must be an array`);
+        continue;
+      }
+      continue;
+    }
     const ids = d.action === "conflict" ? [d.winner, d.loser] : (d.ids ?? []);
     if (d.action === "conflict") {
       if (!d.winner || !d.loser || d.winner === d.loser) {
@@ -95,6 +129,12 @@ export function validateDecisions(decisions, snapshot, options = {}) {
   if (updateCount > maxUpdatePerRun) {
     errors.push(`too many update decisions: ${updateCount} > ${maxUpdatePerRun}`);
   }
+  // Cap create churn: a pattern-discovery loop fabricating endless new memories
+  // would bloat the store, so a run can mint at most maxCreatePerRun.
+  const createCount = decisions.filter((d) => d.action === "create").length;
+  if (createCount > maxCreatePerRun) {
+    errors.push(`too many create decisions: ${createCount} > ${maxCreatePerRun}`);
+  }
   // Every snapshot id must appear in at least one decision
   for (const id of snapshot.keys()) {
     if (!claimed.has(id)) errors.push(`memory ${JSON.stringify(id)} missing from decisions`);
@@ -202,10 +242,48 @@ function applyOne(d, service, snapshot, config = {}) {
     case "archive": return applyArchive(d, service, snapshot);
     case "merge": return applyMerge(d, service, snapshot, config);
     case "conflict": return applyConflict(d, service, snapshot);
+    case "create": return applyCreate(d, service, snapshot);
     default: return applyUpdate(d, service, snapshot, config);
   }
 }
 
+/**
+ * Mint a new memory (sleep pattern discovery). saveWithDedupe dedupes by
+ * (type, title) so a replayed create merges instead of duplicating — the
+ * idempotency guard. Evidence ids are folded into tags as `ev:<id>` so a
+ * pattern's provenance stays queryable after creation.
+ */
+function applyCreate(d, service, snapshot) {
+  const evidence = Array.isArray(d.evidence) ? d.evidence : [];
+  const tags = [
+    ...(Array.isArray(d.tags) ? d.tags : []),
+    ...evidence.map((id) => `ev:${id}`)
+  ];
+  const result = service.saveWithDedupe({
+    type: d.type ?? "pattern",
+    title: d.title,
+    content: d.content,
+    importance: d.importance ?? 3,
+    tags,
+    source: "dream-create"
+  });
+  if (!result?.memory) return "skipped";
+  return {
+    applied: 1,
+    committed: {
+      action: "create",
+      id: result.memory.id,
+      type: d.type ?? "pattern",
+      title: d.title,
+      content: d.content,
+      importance: d.importance ?? 3,
+      evidence,
+      count_before: 0,
+      count_after: 1
+    }
+  };
+}
+
 function applyArchive(d, service, snapshot) {
   const targets = d.ids.filter((id) => {
     const mem = service.getById(id);

package/src/index.js

@@ -5,6 +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 { createApi } from "./api.js";
 import { createSettings } from "./settings.js";
 import { createCommandManager } from "./commands.js";
@@ -181,6 +182,25 @@ 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.
+  let sleep = null;
+  if (cfg.sleepEnabled) {
+    sleep = createSleepScheduler({
+      service,
+      config: cfg,
+      logger: ctx.logger,
+      onRun: () => (sleep
+        ? runSleep(ctx, service, cfg, ctx.logger, { embedder, vectorIndex })
+        : Promise.resolve({ ok: true, skipped: true }))
+    });
+    service.setSleepHook(() => sleep.noteWrite());
+  }
+
   // Entity gene extraction (v0.3.0): wire the extractor into the service as a
   // hook so saveWithDedupe can fire-and-forget an extraction pass on fresh
   // writes. The service never sees ctx.llm — index.js adapts it here into the
@@ -251,6 +271,7 @@ export const apply = (ctx, config) => {
     }
     commands?.dispose();
     if (dream) await dream.dispose();
+    if (sleep) await sleep.dispose();
     store.close();
   };
 };

package/src/service.js

@@ -9,6 +9,11 @@ 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.
+  let sleepHook = null;
+
   // Optional vector embedder, installed via setEmbedder after creation. After
   // any content write it fire-and-forgets a re-embed of the row so vector
   // search stays in sync; failures are swallowed inside the embedder.
@@ -37,6 +42,19 @@ 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
+  // 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
+  // time. A task that rejects doesn't poison the queue (the tail swallows the
+  // rejection) but the rejection still propagates to that caller.
+  let queueTail = Promise.resolve();
+  function enqueue(fn) {
+    const next = queueTail.then(fn, fn);
+    queueTail = next.catch(() => {});
+    return next;
+  }
+
   // issue #6 (part 2): startup race defense. A local embedder (LocalEmbedder /
   // Ollama) exposes an async init(), so between `setEmbedder` and init()
   // resolving there is a window where embedSingle would throw "not initialized"
@@ -243,11 +261,15 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     // entity:/attr: 前缀路由（v0.3.0 Phase 3）。entitySearchEnabled 关闭时走原逻辑。
     if (config?.entitySearchEnabled) {
       if (q.startsWith("entity:")) {
-        return searchByEntity(q.slice(7).trim(), options);
+        const hits = searchByEntity(q.slice(7).trim(), options);
+        touchRecalled(hits);
+        return hits;
       }
       if (q.startsWith("attr:")) {
         const [key, value] = q.slice(5).split("=");
-        return searchByAttr(key, value, options);
+        const hits = searchByAttr(key, value, options);
+        touchRecalled(hits);
+        return hits;
       }
     }
 
@@ -345,6 +367,7 @@ export function createService({ store, mirror, config, onWrite, logger }) {
         });
       } catch { /* recall receipt is best effort */ }
     }
+    touchRecalled(result);
     return result;
   }
 
@@ -362,6 +385,9 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     if (dreamHook) {
       try { dreamHook(); } catch { /* ignore */ }
     }
+    if (sleepHook) {
+      try { sleepHook(); } catch { /* ignore */ }
+    }
   }
 
   /**
@@ -430,6 +456,23 @@ 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
@@ -446,7 +489,9 @@ export function createService({ store, mirror, config, onWrite, logger }) {
         const pb = b.type === "summary" ? 0 : b.type === "preference" ? 1 : 2;
         return pa - pb || b.importance - a.importance;
       });
-    return items.slice(0, maxItems);
+    const selected = items.slice(0, maxItems);
+    touchRecalled(selected);
+    return selected;
   }
 
   /**
@@ -758,7 +803,9 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     mergeHumanEdits,
     toApiList,
     transaction,
+    enqueue,
     setDreamHook(fn) { dreamHook = fn; },
+    setSleepHook(fn) { sleepHook = fn; },
     setEmbedder(emb) {
       embedder = emb;
       if (!emb) {
@@ -870,6 +917,11 @@ export function createService({ store, mirror, config, onWrite, logger }) {
       afterSync("write");
       return updated;
     },
+    demoteToSummary: (id, summary, opts) => {
+      const updated = store.demoteToSummary(id, summary, opts);
+      afterSync("write");
+      return updated;
+    },
     // 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.