@modusensus/dsh-mneme 0.3.7 → 0.4.1

package/lib/store.js

@@ -180,13 +180,18 @@ CREATE TABLE IF NOT EXISTS mirror_state (
   last_error TEXT,                   -- 最近失败原因
   last_attempt TEXT,                 -- 最近尝试时间（ISO）
   success_at TEXT,                   -- 最近成功时间（ISO）
-  generation INTEGER NOT NULL DEFAULT 0,         -- 期望的同步轮次（desired）
-  applied_generation INTEGER NOT NULL DEFAULT 0, -- 已成功应用的轮次
+  generation INTEGER NOT NULL DEFAULT 0 CHECK (generation >= 0 AND generation <= 9007199254740991),         -- 期望的同步轮次（desired）
+  applied_generation INTEGER NOT NULL DEFAULT 0 CHECK (applied_generation >= 0 AND applied_generation <= 9007199254740991), -- 已成功应用的轮次
   type_status TEXT                               -- JSON: 逐 type 状态 {type: {dirty, applied_gen, last_error}}
 );
 `;
 
-const TYPES = new Set(["preference", "project", "decision", "history", "summary"]);
+const TYPES = new Set(["preference", "project", "decision", "history", "summary", "pattern"]);
+
+// Per-type mirror sync receipts (peer blocker 4): a type is either committed
+// (file written + fence applied), failed (last sync round errored for it), or
+// pending (still owed a write).
+const VALID_TYPE_STATUS = new Set(["committed", "failed", "pending"]);
 
 // Pure helpers: no shared module state.
 
@@ -222,7 +227,12 @@ function toRow(row) {
     archived: row.archived === 1,
     source: row.source ?? undefined,
     created_at: row.created_at,
-    updated_at: row.updated_at
+    updated_at: row.updated_at,
+    // Sleep (v0.4.1): last_accessed_at drives the unrecalled tiering;
+    // _full_content holds the pre-demotion body for a memory reduced to its
+    // summary. Both are internal — the mirror render must not expose them.
+    last_accessed_at: row.last_accessed_at ?? undefined,
+    _full_content: row._full_content ?? undefined
   };
 }
 
@@ -243,7 +253,8 @@ function toDreamRun(row) {
     applied: row.applied,
     summary_stored: row.summary_stored === 1,
     receipt: row.receipt,
-    policy_epoch: row.policy_epoch ?? 0
+    policy_epoch: row.policy_epoch ?? 0,
+    run_type: row.run_type ?? "auto"
   };
 }
 
@@ -387,6 +398,10 @@ function parseJsonArray(raw) {
 export function createStore(path) {
   const db = new DatabaseSync(path);
   db.exec("PRAGMA journal_mode = WAL;");
+  // Concurrent writers (peer probe: 8 independent processes) must wait for the
+  // write lock instead of failing immediately with SQLITE_BUSY — otherwise the
+  // atomic generation increment loses whole writes, not just increments.
+  db.exec("PRAGMA busy_timeout = 5000;");
   db.exec(SCHEMA);
 
   // Schema migrations for legacy databases (idempotent).
@@ -403,6 +418,19 @@ export function createStore(path) {
   if (!dreamCols.includes("policy_epoch")) {
     db.exec("ALTER TABLE dream_runs ADD COLUMN policy_epoch INTEGER NOT NULL DEFAULT 0");
   }
+  if (!dreamCols.includes("run_type")) {
+    db.exec("ALTER TABLE dream_runs ADD COLUMN run_type TEXT NOT NULL DEFAULT 'auto'");
+  }
+
+  // Sleep (v0.4.1) columns: last_accessed_at tracks recall/inject touch for the
+  // "unrecalled N days → demote/archive" tiering; _full_content holds the pre-demotion
+  // body when a memory is reduced to its summary. Both are additive-only.
+  if (!columns.includes("last_accessed_at")) {
+    db.exec("ALTER TABLE memories ADD COLUMN last_accessed_at TEXT");
+  }
+  if (!columns.includes("_full_content")) {
+    db.exec("ALTER TABLE memories ADD COLUMN _full_content TEXT");
+  }
 
   // Legacy mirror_state without v0.3.6 generation columns → add each missing
   // column idempotently (old DBs open cleanly, no data loss).
@@ -467,10 +495,17 @@ export function createStore(path) {
     const embedding = Array.isArray(memory.embedding) && memory.embedding.length
       ? JSON.stringify(memory.embedding)
       : null;
-    db.prepare(
-      `INSERT INTO memories (id, type, title, content, tags, importance, forgotten, source, embedding, created_at, updated_at)
-       VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?, ?, ?)`
-    ).run(id, type, memory.title, memory.content, tags, importance, memory.source ?? null, embedding, now, now);
+    runAtomically(() => {
+      db.prepare(
+        `INSERT INTO memories (id, type, title, content, tags, importance, forgotten, source, embedding, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?, ?, ?)`
+      ).run(id, type, memory.title, memory.content, tags, importance, memory.source ?? null, embedding, now, now);
+      // desired generation bumped in the same transaction as the write: once
+      // this commits, generation > applied_generation, so a crash right after
+      // (before syncMirror) is caught by recoverMirror on restart (peer
+      // blocker 1). ROLLBACK on error rolls this back with the write.
+      incrementGeneration();
+    });
     return getById(id);
   }
 
@@ -486,24 +521,34 @@ export function createStore(path) {
     const embedding = patch.embedding !== undefined
       ? (Array.isArray(patch.embedding) && patch.embedding.length ? JSON.stringify(patch.embedding) : null)
       : existing.embedding ?? null;
-    db.prepare(
-      `UPDATE memories SET type=?, title=?, content=?, tags=?, importance=?, source=?, embedding=?, updated_at=? WHERE id=?`
-    ).run(
-      type,
-      patch.title ?? existing.title,
-      patch.content ?? existing.content,
-      JSON.stringify(patch.tags ?? existing.tags),
-      Number.isInteger(patch.importance) ? patch.importance : existing.importance,
-      patch.source !== undefined ? patch.source : (existing.source ?? null),
-      embedding,
-      now,
-      id
-    );
+    runAtomically(() => {
+      db.prepare(
+        `UPDATE memories SET type=?, title=?, content=?, tags=?, importance=?, source=?, embedding=?, updated_at=? WHERE id=?`
+      ).run(
+        type,
+        patch.title ?? existing.title,
+        patch.content ?? existing.content,
+        JSON.stringify(patch.tags ?? existing.tags),
+        Number.isInteger(patch.importance) ? patch.importance : existing.importance,
+        patch.source !== undefined ? patch.source : (existing.source ?? null),
+        embedding,
+        now,
+        id
+      );
+      // Desired generation bumped in the same transaction as the update (peer
+      // blocker 1: crash between write and sync must still be recoverable).
+      incrementGeneration();
+    });
     return getById(id);
   }
 
   function remove(id) {
-    db.prepare("DELETE FROM memories WHERE id = ?").run(id);
+    runAtomically(() => {
+      db.prepare("DELETE FROM memories WHERE id = ?").run(id);
+      // Mirror sync must reflect the deletion; bump desired generation so a
+      // crash between the delete and syncMirror leaves a recoverable debt.
+      incrementGeneration();
+    });
   }
 
   /**
@@ -542,18 +587,68 @@ export function createStore(path) {
       expectedUpdatedAt
     );
     if (result.changes === 0) return undefined; // CAS miss: a concurrent write won
+    // Only bump desired generation on a successful CAS — a miss writes nothing.
+    runAtomically(() => { incrementGeneration(); });
     return getById(id);
   }
 
   function setForget(id, forgotten) {
-    db.prepare("UPDATE memories SET forgotten = ?, updated_at = ? WHERE id = ?")
-      .run(forgotten === true || forgotten === 1 ? 1 : 0, nowIso(), id);
+    runAtomically(() => {
+      db.prepare("UPDATE memories SET forgotten = ?, updated_at = ? WHERE id = ?")
+        .run(forgotten === true || forgotten === 1 ? 1 : 0, nowIso(), id);
+      incrementGeneration();
+    });
     return getById(id);
   }
 
   function setArchived(id, archived) {
-    db.prepare("UPDATE memories SET archived = ?, updated_at = ? WHERE id = ?")
-      .run(archived ? 1 : 0, nowIso(), id);
+    runAtomically(() => {
+      db.prepare("UPDATE memories SET archived = ?, updated_at = ? WHERE id = ?")
+        .run(archived ? 1 : 0, nowIso(), id);
+      incrementGeneration();
+    });
+    return getById(id);
+  }
+
+  /** Recall/inject touch. Records last_accessed_at WITHOUT bumping the mirror
+   *  generation — sleep's "unrecalled N days → demote/archive" tiering must not
+   *  spin the desired generation (that would mislead the mirror peer into
+   *  thinking the touched memory's content changed). Only bumps a timestamp,
+   *  so it is safe on hot recall paths. */
+  function touchAccess(id) {
+    const result = db.prepare(
+      "UPDATE memories SET last_accessed_at = ? WHERE id = ?"
+    ).run(nowIso(), id);
+    return result.changes > 0;
+  }
+
+  /** Sleep demotion (v0.4.1): move the full body into _full_content and replace
+   *  content with a one-line summary. Skips when already demoted (_full_content
+   *  present) so a replayed sleep run never double-wraps. Bumps the mirror
+   *  generation because content visibly changes in the mirror file.
+   *
+   *  minRefTimeMs (optional): the sleep tiering's freshness cutoff. A memory
+   *  whose reference time (last_accessed_at ?? updated_at ?? created_at) is
+   *  newer than the cutoff is skipped — phaseDemotion snapshots ref times up
+   *  front, and a recall touch landing between the snapshot and this call must
+   *  not demote a freshly-accessed memory. The check and the update run in the
+   *  same synchronous transaction, so the read-then-write is atomic. */
+  function demoteToSummary(id, summary, { minRefTimeMs } = {}) {
+    runAtomically(() => {
+      const row = db.prepare(
+        "SELECT content, _full_content, last_accessed_at, updated_at, created_at FROM memories WHERE id = ?"
+      ).get(id);
+      if (!row || row._full_content) return; // idempotent: never double-wrap
+      if (minRefTimeMs != null) {
+        const ref = row.last_accessed_at ?? row.updated_at ?? row.created_at;
+        const t = ref ? new Date(ref).getTime() : NaN;
+        if (!Number.isNaN(t) && t >= minRefTimeMs) return; // freshly touched: keep full
+      }
+      db.prepare(
+        "UPDATE memories SET _full_content = ?, content = ?, updated_at = ? WHERE id = ?"
+      ).run(row.content ?? "", summary ?? "", nowIso(), id);
+      incrementGeneration();
+    });
     return getById(id);
   }
 
@@ -682,16 +777,17 @@ export function createStore(path) {
     const id = run.id ?? randomUUID();
     const now = nowIso();
     const policyEpoch = Number.isInteger(run.policy_epoch) ? run.policy_epoch : 0;
+    const runType = run.run_type ?? "auto";
     db.prepare(
       `INSERT INTO dream_runs (id, created_at, status, error, provider, model, snapshot_hash,
-        input_count, input, decisions, outcome, applied, summary_stored, receipt, policy_epoch)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        input_count, input, decisions, outcome, applied, summary_stored, receipt, policy_epoch, run_type)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(id) DO UPDATE SET
          created_at=excluded.created_at, status=excluded.status, error=excluded.error,
          provider=excluded.provider, model=excluded.model, snapshot_hash=excluded.snapshot_hash,
          input_count=excluded.input_count, input=excluded.input, decisions=excluded.decisions,
          outcome=excluded.outcome, applied=excluded.applied, summary_stored=excluded.summary_stored,
-         receipt=excluded.receipt, policy_epoch=excluded.policy_epoch`
+         receipt=excluded.receipt, policy_epoch=excluded.policy_epoch, run_type=excluded.run_type`
     ).run(
       id,
       run.created_at ?? now,
@@ -707,7 +803,8 @@ export function createStore(path) {
       run.applied ?? 0,
       run.summary_stored ? 1 : 0,
       run.receipt,
-      policyEpoch
+      policyEpoch,
+      runType
     );
     return getDreamRun(id);
   }
@@ -1189,7 +1286,10 @@ export function createStore(path) {
       if (key === "dirty") {
         value = value ? 1 : 0;
       } else if (key === "generation" || key === "applied_generation") {
-        value = Math.trunc(Number(value)) || 0;
+        value = Math.trunc(Number(value));
+        if (!Number.isFinite(value) || value < 0 || value > Number.MAX_SAFE_INTEGER) {
+          throw new RangeError(`mirror_state.${key} out of range: ${value}`);
+        }
       } else if (key === "type_status" && value != null && typeof value !== "string") {
         value = JSON.stringify(value);
       }
@@ -1220,12 +1320,15 @@ export function createStore(path) {
    * recent as this one may.
    */
   function markMirrorDirty(error, now) {
-    const current = getMirrorState();
+    // Bump the desired generation atomically first — the new debt must be bound
+    // to a fresh round so a stale worker cannot fence-clean it. Even if this
+    // write fails (peer blocker 2), generation still advanced, so recoverMirror
+    // sees generation > applied_generation and retries rather than false-clean.
+    incrementGeneration();
     return setMirrorState({
       dirty: 1,
       last_error: error,
-      last_attempt: now ?? nowIso(),
-      generation: (current.generation || 0) + 1
+      last_attempt: now ?? nowIso()
     });
   }
 
@@ -1262,13 +1365,23 @@ export function createStore(path) {
 
   /**
    * Record per-type mirror status (partial success bookkeeping). `status` is a
-   * partial patch {dirty?, applied_gen?, last_error?} merged into the existing
-   * entry for `type` (other types untouched). Returns the updated full state.
+   * patch {status: 'committed'|'failed'|'pending', applied_gen?, last_error?}
+   * replacing the entry for `type` (other types untouched). Standardizing on an
+   * explicit status gives per-type committed/failed/pending receipts — a type
+   * whose file was written while a sibling failed is recorded as such, not
+   * collapsed into a bulk "dirty" (peer blocker 4). Returns the updated state.
    */
   function setTypeStatus(type, status) {
+    if (!VALID_TYPE_STATUS.has(status?.status)) {
+      throw new TypeError(`setTypeStatus: status must be one of committed|failed|pending, got ${status?.status}`);
+    }
     const current = getMirrorState();
     const statuses = current.type_status || {};
-    statuses[type] = { ...(statuses[type] || {}), ...status };
+    statuses[type] = {
+      status: status.status,
+      ...(status.applied_gen !== undefined ? { applied_gen: status.applied_gen } : {}),
+      ...(status.last_error !== undefined ? { last_error: status.last_error } : {})
+    };
     return setMirrorState({ type_status: JSON.stringify(statuses) });
   }
 
@@ -1278,10 +1391,40 @@ export function createStore(path) {
     return current.type_status || {};
   }
 
-  /** Bump the desired generation (new sync round), returning the new state. */
+  /** Run fn atomically: when the connection is already inside a transaction
+   *  (service.transaction's BEGIN), just run it — the outer COMMIT covers us.
+   *  Otherwise wrap in BEGIN/COMMIT so a memory write and its desired-generation
+   *  bump commit together: a crash between them can never leave a mutated store
+   *  with generation == applied (audit peer blocker 1, "crash window"). */
+  function runAtomically(fn) {
+    if (db.isTransaction) return fn();
+    db.exec("BEGIN");
+    try {
+      const result = fn();
+      db.exec("COMMIT");
+      return result;
+    } catch (error) {
+      try { db.exec("ROLLBACK"); } catch { /* connection may be closed */ }
+      throw error;
+    }
+  }
+
+  /** Bump the desired generation atomically (SQLite single-statement increment,
+   *  no SELECT-then-UPSERT race: peer blocker 3 lost 10 of 91 concurrent
+   *  increments under an 8-process probe). Returns the new mirror state.
+   *  Guards the upper bound: generation must stay within MAX_SAFE_INTEGER so
+   *  reads never hit ERR_OUT_OF_RANGE (peer blocker 6). */
   function incrementGeneration() {
-    const current = getMirrorState();
-    return setMirrorState({ generation: (current.generation || 0) + 1 });
+    return runAtomically(() => {
+      // Ensure the singleton row exists before incrementing (UPDATE alone would
+      // match nothing on a fresh DB).
+      db.prepare("INSERT OR IGNORE INTO mirror_state (id) VALUES ('main')").run();
+      const row = db.prepare(
+        "UPDATE mirror_state SET generation = generation + 1 WHERE id = 'main' AND generation < ? RETURNING generation"
+      ).get(Number.MAX_SAFE_INTEGER);
+      if (!row) throw new RangeError("mirror_state.generation exceeded MAX_SAFE_INTEGER");
+      return getMirrorState();
+    });
   }
 
   return {
@@ -1294,6 +1437,8 @@ export function createStore(path) {
     remove,
     setForget,
     setArchived,
+    touchAccess,
+    demoteToSummary,
     list,
     all,
     search,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@modusensus/dsh-mneme",
   "description": "Cross-session memory plugin for DeepSeek Harness with autoDream consolidation: SQLite store, Markdown mirrors, 6 model tools, automatic injection, session summarization, user profile/rules, custom slash commands, vector (semantic) search, and a Web GUI panel",
-  "version": "0.3.7",
+  "version": "0.4.1",
   "license": "MIT",
   "type": "module",
   "main": "lib/index.js",

package/src/api.js

@@ -289,6 +289,14 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
         sendJson(res, 200, { mirror: { dirty: null, status: "unknown", last_error: null, last_attempt: null, success_at: null } });
         return;
       }
+      // Real read failure surfaces as dirty === null (peer blocker 5): report
+      // unknown explicitly instead of collapsing into a false "ok"/"degraded".
+      if (state.dirty === null) {
+        sendJson(res, 200, {
+          mirror: { dirty: null, status: "unknown", last_error: null, last_attempt: null, success_at: null }
+        });
+        return;
+      }
       // Sanitized: boolean dirty + coarse status only; error string is mapped to
       // a bounded code, never echoed verbatim.
       let code = null;

package/src/config.js

@@ -91,4 +91,32 @@ export const Config = z.object({
   entityExtractionMaxAttrs: z.natural().min(1).max(50).default(20),
   // Prefix/semantic search over entity names (used by recall).
   entitySearchEnabled: z.boolean().default(true),
+
+  // --- system-level sleep (v0.4.1) -----------------------------------------
+  // Opt-in: when false (default) the plugin never runs a sleep cycle, so the
+  // access-touch bookkeeping on recall/inject paths stays off too. Sleep is
+  // three phases: conflict resolution (reuses the dream conflict machinery),
+  // archival demotion (unrecalled memories tier down to summary then archive),
+  // and pattern discovery (LLM scans recent memories and mints type=pattern
+  // entries with evidence references).
+  sleepEnabled: z.boolean().default(false),
+  // A sleep run only fires when the store has been idle for this long and the
+  // last run is older than sleepMinIntervalHours. Idle detection replaces a
+  // cron-like schedule (DSH plugins have no resident crontab).
+  sleepIdleMinutes: z.natural().min(1).max(1440).default(30),
+  sleepMinIntervalHours: z.natural().min(1).max(168).default(8),
+  // Unrecalled (COALESCE(last_accessed_at, updated_at, created_at)) beyond
+  // sleepArchiveDays → demote: full body moves to _full_content, content
+  // becomes a one-line summary. Beyond sleepDeepArchiveDays → archive.
+  sleepArchiveDays: z.natural().min(1).max(365).default(30),
+  sleepDeepArchiveDays: z.natural().min(1).max(3650).default(90),
+  // How many most-recent memories the pattern-discovery pass scans.
+  sleepPatternScanCount: z.natural().min(10).max(500).default(100),
+  // Max patterns minted per sleep run (mirrors decisions maxCreatePerRun).
+  sleepMaxPatterns: z.natural().min(1).max(20).default(5),
+  // Optional LLM route override; empty = fall back to agentDefaultModel then
+  // the dream route. Distinct from dreamProvider/dreamModel so the sleep pass
+  // can pin a cheaper model for its bulk summarization.
+  sleepProvider: z.string().default(""),
+  sleepModel: z.string().default(""),
 });

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();
   };
 };