@modusensus/dsh-mneme 0.7.9 → 0.7.11

package/{dsh-mneme/src → src}/dream/decisions.js

@@ -7,163 +7,120 @@ const EPISTEMIC_PRIORITY = { observation: 3, inferred: 2, subjective: 1 };
 
 /**
  * Validate a dream decision list against a snapshot of eligible memories.
- *
- * Issue #26 (skipInvalid): 模型几乎必然为了语义相关性而产出跨类型 merge
- * （type 不同，硬性禁止），这类"单条非法"此前让整批校验 ok:false、整单拒绝
- * （applied=0、白耗一次 LLM 调用）。`options.skipInvalid` 开启后，逐条非法的
- * 决策被跳过（从 decisions 中移除、不 claim 任何 id、记录到 `skipped`），
- * 只有全局性错误（update/create 超量、显式覆盖率不足——
- * 这些是"模型失控/输出被截断"信号）仍整单拒绝，防洗白语义不变。
- * `options.allowCrossTypeMerge`（Issue #26 P1）显式放宽跨类型合并检查——
- * 默认 false 保持现有类型边界，true 时跨类型 merge 被允许（类型边界由
- * 用户自行承担）。
- *
- * @param decisions - LLM-produced decision list. In skipInvalid mode, invalid
- *   entries are spliced out in place so the caller's downstream apply/audit
- *   operates on the surviving subset only.
+ * @param decisions - LLM-produced decision list.
  * @param snapshot - Map<id, memory> of eligible (non-archived, non-summary) entries.
- * @returns {{ok: boolean, errors: string[], skipped?: Array<{index, action, ids, error}>}}
+ * @returns {{ok: boolean, errors: string[]}}
  */
 export function validateDecisions(decisions, snapshot, options = {}) {
   const errors = [];
-  const skipped = [];
   const maxUpdatePerRun = options.maxUpdatePerRun ?? 2;
   const minAgeHours = options.minAgeHours ?? 24;
-  const skipInvalid = options.skipInvalid === true;
   if (!Array.isArray(decisions) || decisions.length === 0) {
     return { ok: false, errors: ["decision list must be a non-empty array"] };
   }
   const claimed = new Set();
-  const survivors = [];
   for (const [index, d] of decisions.entries()) {
     const at = `decision[${index}]`;
-    const local = [];
-    const ids = d && d.action === "conflict" ? [d.winner, d.loser] : (d?.ids ?? []);
     if (!d || typeof d !== "object" || !ACTIONS.has(d.action)) {
-      local.push(`${at}: invalid action ${JSON.stringify(d?.action)}`);
-    } else {
-      if (d.action === "conflict") {
-        if (!d.winner || !d.loser || d.winner === d.loser) {
-          local.push(`${at}: conflict needs distinct winner and loser`);
-        }
-      } else if (d.action === "create") {
-        // Mint a fresh memory (sleep pattern discovery). Claims no existing id,
-        // so it skips the claiming loop below; evidence is optional provenance
-        // (already filtered to real ids by the caller) and is stored in content.
-        if (typeof d.title !== "string" || !d.title.trim()) {
-          local.push(`${at}: create needs non-empty title`);
-        }
-        if (typeof d.content !== "string" || !d.content.trim()) {
-          local.push(`${at}: create needs non-empty content`);
-        }
-        if (d.importance !== undefined && (!Number.isInteger(d.importance) || d.importance < 1 || d.importance > 5)) {
-          local.push(`${at}: create importance must be an integer 1-5 when provided`);
-        }
-        if (typeof d.type !== "string" || !d.type.trim()) {
-          local.push(`${at}: create needs non-empty type`);
-        }
-      } else if (!Array.isArray(d.ids) || d.ids.length === 0) {
-        local.push(`${at}: ${d.action} needs non-empty ids`);
+      errors.push(`${at}: invalid action ${JSON.stringify(d?.action)}`);
+      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) {
+        errors.push(`${at}: conflict needs distinct winner and loser`);
+        continue;
       }
-      // update-specific field validation runs BEFORE claiming ids, so a failing
-      // update never pollutes the claimed set (which drives the "every id must
-      // appear in a decision" check below).
-      if (d.action === "update") {
-        // 只能更新单条
-        if (!Array.isArray(d.ids) || d.ids.length !== 1) {
-          local.push(`${at}: update must target exactly one id`);
-        } else {
-          // 必须产生实际变化
-          const mem = snapshot.get(d.ids[0]);
-          const hasChange = (d.title !== undefined && d.title !== mem?.title)
-            || (d.content !== undefined && d.content !== mem?.content)
-            || (d.importance !== undefined && d.importance !== mem?.importance);
-          if (!hasChange) {
-            local.push(`${at}: update must change at least one field`);
-          }
-          // 不能更新 summary
-          if (mem?.type === "summary") {
-            local.push(`${at}: cannot update summary via update action`);
-          }
-          // 保护期：新建记忆不可立即被 update（可配置）
-          const ageHours = (Date.now() - new Date(mem?.created_at).getTime()) / 3600000;
-          if (ageHours < minAgeHours) {
-            local.push(`${at}: memory too young (< ${minAgeHours}h)`);
-          }
-        }
+    } else if (d.action === "create") {
+      // Mint a fresh memory (sleep pattern discovery). Claims no existing id,
+      // so it skips the claiming loop below; evidence is optional provenance
+      // (already filtered to real ids by the caller) and is stored in content.
+      if (typeof d.title !== "string" || !d.title.trim()) {
+        errors.push(`${at}: create needs non-empty title`);
+        continue;
       }
-      if (d.action !== "create") {
-        const seen = new Set();
-        for (const id of ids) {
-          const mem = snapshot.get(id);
-          if (!mem) {
-            local.push(`${at}: unknown id ${JSON.stringify(id)}`);
-          } else if (mem.archived || mem.type === "summary") {
-            local.push(`${at}: id ${JSON.stringify(id)} is archived or summary (not eligible)`);
-          }
-          // 单决策内重复 id（同一决策引用同一记忆两次）→ 非法；跨决策重复由
-          // 全局 claimed 检测（只含已通过校验的幸存决策的 claim）。
-          if (seen.has(id)) {
-            local.push(`${at}: duplicate id ${JSON.stringify(id)} within one decision`);
-          }
-          if (claimed.has(id)) {
-            local.push(`${at}: id ${JSON.stringify(id)} claimed by multiple decisions`);
-          }
-          seen.add(id);
-        }
-        if (d.action === "merge") {
-          if (!d.keepSource || !d.ids.includes(d.keepSource)) {
-            local.push(`${at}: merge keepSource must be one of ids`);
-          }
-          if (typeof d.title !== "string" || !d.title.trim() || typeof d.content !== "string" || !d.content.trim()) {
-            local.push(`${at}: merge needs non-empty title and content`);
-          }
-          if (d.importance !== undefined && (!Number.isInteger(d.importance) || d.importance < 1 || d.importance > 5)) {
-            local.push(`${at}: merge importance must be an integer 1-5 when provided`);
-          }
-          // Merging across types would blur preference/project/decision boundaries
-          // in the injected context; the snapshot carries each entry's type.
-          // Issue #26 (P1): 默认禁止跨类型合并（类型有语义作用——preference 注入
-          // 权重更高、decision/project 注入上下文不同，合并会丢类型边界）。用户显式
-          // 开启 allowCrossTypeMerge 后放宽该检查，类型边界由用户自行承担。
-          const mergeTypes = new Set(d.ids.map((id) => snapshot.get(id)?.type));
-          if (mergeTypes.size > 1 && options.allowCrossTypeMerge !== true) {
-            local.push(`${at}: merge ids span multiple types (${[...mergeTypes].join(", ")})`);
-          }
-        }
+      if (typeof d.content !== "string" || !d.content.trim()) {
+        errors.push(`${at}: create needs non-empty content`);
+        continue;
       }
-    }
-    if (local.length > 0) {
-      if (skipInvalid) {
-        // 单条非法 → 跳过该决策，不 claim id（其目标记忆留给其它合法决策/
-        // 隐式 keep），并记录到 skipped 供调用方日志/审计。信息性跳过绝不
-        // 写入全局 errors，否则会误触发下方的整单拒绝。
-        skipped.push({
-          index,
-          action: d?.action,
-          ids,
-          error: local.join("; ")
-        });
-      } else {
-        errors.push(...local);
+      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`);
+      }
+      if (typeof d.type !== "string" || !d.type.trim()) {
+        errors.push(`${at}: create needs non-empty type`);
       }
       continue;
+    } else if (!Array.isArray(d.ids) || d.ids.length === 0) {
+      errors.push(`${at}: ${d.action} needs non-empty ids`);
+      continue;
+    }
+    // update-specific field validation runs BEFORE claiming ids, so a failing
+    // update never pollutes the claimed set (which drives the "every id must
+    // appear in a decision" check below).
+    if (d.action === "update") {
+      // 只能更新单条
+      if (!Array.isArray(d.ids) || d.ids.length !== 1) {
+        errors.push(`${at}: update must target exactly one id`);
+        continue;
+      }
+      // 必须产生实际变化
+      const mem = snapshot.get(d.ids[0]);
+      const hasChange = (d.title !== undefined && d.title !== mem?.title)
+        || (d.content !== undefined && d.content !== mem?.content)
+        || (d.importance !== undefined && d.importance !== mem?.importance);
+      if (!hasChange) {
+        errors.push(`${at}: update must change at least one field`);
+        continue;
+      }
+      // 不能更新 summary
+      if (mem?.type === "summary") {
+        errors.push(`${at}: cannot update summary via update action`);
+        continue;
+      }
+      // 保护期：新建记忆不可立即被 update（可配置）
+      const ageHours = (Date.now() - new Date(mem?.created_at).getTime()) / 3600000;
+      if (ageHours < minAgeHours) {
+        errors.push(`${at}: memory too young (< ${minAgeHours}h)`);
+        continue;
+      }
     }
-    if (d.action !== "create") {
-      for (const id of ids) claimed.add(id);
+    for (const id of ids) {
+      const mem = snapshot.get(id);
+      if (!mem) {
+        errors.push(`${at}: unknown id ${JSON.stringify(id)}`);
+      } else if (mem.archived || mem.type === "summary") {
+        errors.push(`${at}: id ${JSON.stringify(id)} is archived or summary (not eligible)`);
+      }
+      if (claimed.has(id)) {
+        errors.push(`${at}: id ${JSON.stringify(id)} claimed by multiple decisions`);
+      }
+      claimed.add(id);
+    }
+    if (d.action === "merge") {
+      if (!d.keepSource || !d.ids.includes(d.keepSource)) {
+        errors.push(`${at}: merge keepSource must be one of ids`);
+      }
+      if (typeof d.title !== "string" || !d.title.trim() || typeof d.content !== "string" || !d.content.trim()) {
+        errors.push(`${at}: merge needs non-empty title and content`);
+      }
+      if (d.importance !== undefined && (!Number.isInteger(d.importance) || d.importance < 1 || d.importance > 5)) {
+        errors.push(`${at}: merge importance must be an integer 1-5 when provided`);
+      }
+      // Merging across types would blur preference/project/decision boundaries
+      // in the injected context; the snapshot carries each entry's type.
+      const mergeTypes = new Set(d.ids.map((id) => snapshot.get(id)?.type));
+      if (mergeTypes.size > 1) {
+        errors.push(`${at}: merge ids span multiple types (${[...mergeTypes].join(", ")})`);
+      }
     }
-    survivors.push(d);
   }
-  // Cap update churn: too many edits in one cycle signals a runaway model.
-  // These are GLOBAL signals — in skipInvalid mode they still reject the whole
-  // batch, because a model that floods updates/creates is broken, not just
-  // slightly schema-drifting.
-  const updateCount = survivors.filter((d) => d.action === "update").length;
+  // Cap update churn: too many edits in one cycle signals a runaway model
+  const updateCount = decisions.filter((d) => d.action === "update").length;
   if (updateCount > maxUpdatePerRun) {
     errors.push(`too many update decisions: ${updateCount} > ${maxUpdatePerRun}`);
   }
   // Cap pattern minting per run (sleepMaxPatternPerRun passes through here).
-  const createCount = survivors.filter((d) => d.action === "create").length;
+  const createCount = decisions.filter((d) => d.action === "create").length;
   const maxCreatePerRun = options.maxCreatePerRun ?? 5;
   if (createCount > maxCreatePerRun) {
     errors.push(`too many create decisions: ${createCount} > ${maxCreatePerRun}`);
@@ -180,31 +137,25 @@ export function validateDecisions(decisions, snapshot, options = {}) {
   // snapshot（claimed.size / snapshot.size < dreamMinExplicitCoverage）时整单拒绝，
   // 而不是用 keep 把绝大部分 snapshot 全部"通过"。
   if (errors.length > 0) {
-    return { ok: false, errors, skipped };
+    return { ok: false, errors };
   }
   const minCoverage = options.dreamMinExplicitCoverage ?? 0.5;
   if (options.dreamImplicitKeep !== false) {
     const coverage = snapshot.size > 0 ? claimed.size / snapshot.size : 1;
     if (coverage < minCoverage) {
       errors.push(`explicit decision coverage ${Math.round(coverage * 100)}% < minimum ${Math.round(minCoverage * 100)}%`);
-      return { ok: false, errors, skipped };
+      return { ok: false, errors };
     }
     for (const id of snapshot.keys()) {
-      if (!claimed.has(id)) survivors.push({ action: "keep", ids: [id] });
+      if (!claimed.has(id)) decisions.push({ action: "keep", ids: [id] });
     }
   } else {
     for (const id of snapshot.keys()) {
       if (!claimed.has(id)) errors.push(`memory ${JSON.stringify(id)} missing from decisions`);
     }
-    if (errors.length > 0) return { ok: false, errors, skipped };
-  }
-  // 调用方下游（apply/audit）复用同一 decisions 引用：就地同步为 survivors——
-  // 在 skipInvalid 模式下去掉被跳过的非法决策；在隐式 keep 下追加补齐的 keep。
-  // 内容一致时（无跳过、无补齐）为 no-op。
-  if (survivors.length !== decisions.length) {
-    decisions.splice(0, decisions.length, ...survivors);
+    if (errors.length > 0) return { ok: false, errors };
   }
-  return { ok: true, errors, skipped };
+  return { ok: true, errors };
 }
 
 /** Marker thrown when a decision target changed since the run snapshot. */

package/{dsh-mneme/lib → src}/dream/sleep.js

@@ -18,8 +18,6 @@ import { randomUUID, createHash } from "node:crypto";
 import { validateDecisions, applyDecisions } from "./decisions.js";
 import { findPotentialConflicts } from "./clustering.js";
 import { buildReceipt } from "../dream.js";
-import { computeHeat } from "../heat.js";
-import { extractEntities } from "../entities/extractor.js";
 
 const SUMMARY_MAX = 120;
 // Conflict similarity threshold per strictness level (v0.4.0):
@@ -74,23 +72,16 @@ async function streamText(ctx, options) {
   return text;
 }
 
-// LLM route (Issue #25): explicit config wins — sleepProvider/sleepModel first,
-// then the dream route as a shared fallback (config is the user's declared
-// override), and agent default model only last as the generic fallback. Sleep
-// can pin a cheaper model for its bulk passes without disturbing the dream
-// route. The agent-default-last ordering matters: in a standard DSH install
-// agentDefaultModel always resolves, so putting it first would make every
-// config route dead code.
+/** LLM route: agent default model first, then sleepProvider/Model, then the
+ *  dream route as a shared fallback. Sleep can pin a cheaper model for its
+ *  bulk passes without disturbing the dream route. */
 function resolveSleepRoute(ctx, config, logger) {
-  if (config.sleepProvider && config.sleepModel) return { provider: config.sleepProvider, model: config.sleepModel };
-  if (config.dreamProvider && config.dreamModel) return { provider: config.dreamProvider, model: config.dreamModel };
   try {
     const sel = ctx?.agentDefaultModel?.currentSelection?.();
-    if (sel?.provider && sel?.model) {
-      logger?.info?.("dsh-mneme sleep: no sleepProvider/sleepModel config, falling back to agent default");
-      return { provider: sel.provider, model: sel.model };
-    }
-  } catch { /* fall through */ }
+    if (sel?.provider && sel?.model) return { provider: sel.provider, model: sel.model };
+  } catch { /* fall through to config route */ }
+  if (config.sleepProvider && config.sleepModel) return { provider: config.sleepProvider, model: config.sleepModel };
+  if (config.dreamProvider && config.dreamModel) return { provider: config.dreamProvider, model: config.dreamModel };
   logger?.warn?.("dsh-mneme sleep: no llm route available");
   return undefined;
 }
@@ -117,7 +108,7 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
   }
   const strictness = config.sleepConflictStrictness ?? "normal";
   const threshold = CONFLICT_THRESHOLDS[strictness] ?? CONFLICT_THRESHOLDS.normal;
-  const memories = service.all().filter((m) => !m.archived && !m.session_disposed_at && !m.forgotten && m.type !== "summary");
+  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" };
 
@@ -248,22 +239,11 @@ function phaseDemotion(service, config, logger, runId, signal = null) {
   const archived = [];
   for (const m of service.all()) {
     if (signal?.aborted) break;
-    if (m.archived || m.forgotten || m.session_disposed_at) continue;
-    // v0.7.0 语义修正：ref 只用 last_accessed_at，缺失退 created_at；不再
-    // fallback updated_at —— 合并/更新刷的 updated_at 不是访问，防止
-    // autoDream 合并动作重置新鲜度时钟而伪装成"刚被召回"。
-    const ref = m.last_accessed_at ?? m.created_at;
+    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;
-    // v0.7.0 热联合判定（待办③）：时间窗之外再加两道保护闸——热度低于
-    // sleepHeatThreshold 且 importance<5 才允许降级。λ=0 的免疫类型 heat 恒
-    // 1.0 天然豁免（preference/pattern/summary 永不因 sleep 降级）；importance
-    // ≥5 的紧要记忆无论多冷都保留。`冷但重要` 与 `热但低值` 均不满足条件。
-    const heat = computeHeat(m, Date.now(), config);
-    const heatProtected = heat >= (config.sleepHeatThreshold ?? 0.05);
-    const important = (m.importance ?? 0) >= 5;
-    if (heatProtected || important) continue;
     if (t < compressCut) {
       service.setArchived(m.id, true);
       archived.push(m.id);
@@ -293,7 +273,7 @@ async function phasePatterns(ctx, service, config, logger, runId, signal = null)
   const limit = config.sleepPatternMinMemories ?? 100;
   const memories = service
     .list({ limit: 200, includeForgotten: false })
-    .filter((m) => !m.archived && !m.session_disposed_at && m.type !== "summary" && m.type !== "pattern")
+    .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" };
@@ -362,7 +342,7 @@ function phaseRelations(service, config, logger, runId, signal = null) {
   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.session_disposed_at && !m.forgotten);
+  const memories = service.all().filter((m) => !m.archived && !m.forgotten);
   const seen = new Set();
   const related = [];
   const MAX_RELATIONS_PER_ORPHAN = 3;
@@ -397,123 +377,6 @@ function phaseRelations(service, config, logger, runId, signal = null) {
   };
 }
 
-/**
- * Phase 4.5 — batch entity extraction. The write-path extractor (index.js)
- * only fires when entityExtractionEnabled is on — one LLM call per write, a
- * deliberate cost decision — so default installs never accumulate entities,
- * which is exactly why the ego-graph panel (issue #23) renders blank for users
- * with plenty of memories. This phase backfills the entity graph in bulk:
- * memories that carry no entity attrs yet are passed through extractEntities
- * one at a time (oldest first, capped per run). Write-path stays untouched —
- * this is an additive channel for sleep users. Fail-safe per memory: one bad
- * extract never aborts the phase or the cycle.
- */
-async function phaseEntityExtraction(ctx, service, config, logger, runId, signal = null) {
-  if (config.sleepEntityExtractionEnabled !== true) {
-    return { status: "skipped", reason: "disabled" };
-  }
-  const route = resolveSleepRoute(ctx, config, logger);
-  if (!route) return { status: "skipped", reason: "no llm route" };
-  const maxPerRun = config.sleepEntityExtractionMaxPerRun ?? 20;
-
-  // Oldest un-extracted first. The store returns bounded pages via SQL (no
-  // O(N) full-table scan); JS pages through offsets and only pays the
-  // getAttrsByMemory cross-table check on each page, stopping once it has
-  // maxPerRun un-extracted memories or the store is exhausted. Every memory
-  // this phase touches gets stamped entity_extracted_at (successful or
-  // entity-less extracts alike) so a text with no extractable entities is not
-  // re-queued forever; failures are NOT stamped, so a transient LLM hiccup
-  // retries next cycle.
-  const candidates = [];
-  for (let offset = 0; candidates.length < maxPerRun; offset += 100) {
-    const page = service.listForEntityExtraction({ limit: 100, offset });
-    if (page.length === 0) break;
-    candidates.push(...page.filter((m) => (service.getAttrsByMemory?.(m.id) ?? []).length === 0));
-  }
-  candidates.length = Math.min(candidates.length, maxPerRun);
-  if (candidates.length === 0) return { status: "skipped", reason: "no memories to extract" };
-  if (signal?.aborted) return { status: "aborted", reason: "user activity" };
-
-  // extractEntities expects callLLM(messages, options) → text; adapt sleep's
-  // streamText + route resolution (same precedence as the other phases).
-  const callLLM = async (messages) => {
-    const r = resolveSleepRoute(ctx, config, logger);
-    if (!r) return undefined;
-    return streamText(ctx, {
-      ...r,
-      purpose: "sleep-entity-extract",
-      maxTokens: 4096,
-      ...(config.sleepReasoningEffort && config.sleepReasoningEffort !== "none"
-        ? { reasoningEffort: config.sleepReasoningEffort }
-        : {}),
-      messages
-    });
-  };
-
-  let extracted = 0;
-  let failed = 0;
-  let aborted = false;
-  const extractedIds = [];
-  for (const m of candidates) {
-    if (signal?.aborted) {
-      aborted = true;
-      break;
-    }
-    const now = new Date().toISOString();
-    try {
-      // Stamp a pending marker BEFORE the LLM call so a crash mid-extract (the
-      // stamp and the entity writes are not one transaction) cannot re-queue
-      // this memory while we are already working it. Cleared on outcome.
-      service.setMemoryMetadata?.(m.id, { pending_extracted_at: now });
-    } catch (error) {
-      logger?.warn?.(`dsh-mneme sleep: failed to stamp pending_extracted_at for ${m.id}: ${String(error)}`);
-      failed++;
-      continue;
-    }
-    try {
-      const result = await extractEntities(m, { store: service, config, callLLM, logger });
-      if (result?.ok) {
-        extracted++;
-        extractedIds.push(m.id);
-        // Stamp done regardless of whether the LLM found entities — an empty
-        // extract is still a definitive answer for this memory.
-        try {
-          service.setMemoryMetadata?.(m.id, { entity_extracted_at: now, pending_extracted_at: null });
-        } catch (error) {
-          logger?.warn?.(`dsh-mneme sleep: failed to stamp entity_extracted_at for ${m.id}: ${String(error)}`);
-        }
-      } else {
-        failed++;
-        logger?.warn?.(`dsh-mneme sleep: entity extraction failed for ${m.id}: ${result?.error ?? "unknown"}`);
-        try {
-          service.setMemoryMetadata?.(m.id, { pending_extracted_at: null });
-        } catch (error) {
-          logger?.warn?.(`dsh-mneme sleep: failed to clear pending_extracted_at for ${m.id}: ${String(error)}`);
-        }
-      }
-    } catch (error) {
-      failed++;
-      logger?.warn?.(`dsh-mneme sleep: entity extraction threw for ${m.id}: ${String(error)}`);
-      try {
-        service.setMemoryMetadata?.(m.id, { pending_extracted_at: null });
-      } catch (err) {
-        logger?.warn?.(`dsh-mneme sleep: failed to clear pending_extracted_at for ${m.id}: ${String(err)}`);
-      }
-    }
-  }
-  return {
-    // Any success counts as ok (failures are surfaced via detail.failed + warn,
-    // matching phaseConflicts); all-failed reports failed so deriveStatus can
-    // reflect a broken route without aborting the other phases.
-    status: aborted ? "aborted" : extracted > 0 ? "ok" : failed > 0 ? "failed" : "noop",
-    scanned: candidates.length,
-    extracted,
-    failed,
-    aborted,
-    extractedIds
-  };
-}
-
 // ---------------------------------------------------------------- run
 
 function deriveStatus(phases) {
@@ -547,9 +410,6 @@ export async function runSleep(ctx, service, config, logger, semantic = null, si
   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));
-  // entity-extraction runs before relation completion so freshly minted
-  // entities get their orphan relations completed in the same cycle.
-  await attempt("entity-extraction", () => phaseEntityExtraction(ctx, service, config, logger, runId, signal));
   await attempt("relations", () => phaseRelations(service, config, logger, runId, signal));
 
   const status = deriveStatus(phases);