@modusensus/dsh-mneme 0.7.10 → 0.7.12

package/{dsh-mneme/src → 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);

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

@@ -1,8 +1,7 @@
 import { validateDecisions, applyDecisions } from "./dream/decisions.js";
 import { clusterMemories, findPotentialConflicts } from "./dream/clustering.js";
-import { runAutoTag } from "./dream/tag-extractor.js";
 import { createHash, randomUUID } from "node:crypto";
-export { validateDecisions, applyDecisions, normalizeDecisions };
+export { validateDecisions, applyDecisions };
 
 
 // Extract the first JSON array from LLM output, tolerating markdown fences,
@@ -41,95 +40,6 @@ function extractJsonArray(text) {
   }
   return null;
 }
-
-/**
- * Field-name drift guard (v0.5.3): thinking-type models (deepseek-v4-flash
- * etc.) occasionally ignore the prompt's exact decision schema and emit alias
- * keys —实测方案 A 输出 "consolidation"/"target_ids"、方案 B 输出
- * "action"/"targetIds"，都不是插件要求的 "action"/"ids"。normalizeDecisions
- * 在 validateDecisions 之前把常见变体重写回规范字段名，让"字段名不听话但
- * 语义正确"的输出仍可被应用，而不是整单被拒。覆盖三类漂移：
- *   1. 整个 body 是包在对象里的数组（{consolidation:[...]} /
- *      {decisions:[...]} / {actions:[...]}）；
- *   2. 决策对象用了别名键（target_ids→ids、keep_source→keepSource、
- *      winner_id→winner、targetIds→ids 等）；
- *   3. action 值用了同义词（archived→archive、consolidation→merge 等）。
- * 无归一化必要时原样返回（null→null，调用方"no json array"分支不受影响）。
- */
-const FIELD_ALIASES = {
-  // "consolidation" 也可作 action 键（实测 deepseek-v4-flash 这么写过）；
-  // 但 normalizeOne 对 action 键做字符串过滤，{consolidation:[...]} 这种
-  // wrapper 数组不会被误当成 action（顶层 WRAPPER_KEYS 负责解包）。
-  action: ["action", "decision", "operation", "op", "action_type", "actionType", "mode", "consolidation"],
-  // 注意：action 别名不含 "type"——create 决策的 type 是合法的记忆类型字段，
-  // 不能误当 action。
-  ids: ["ids", "target_ids", "targetIds", "targets", "memory_ids", "memoryIds", "id_list", "idList", "memories"],
-  reason: ["reason", "rationale", "why", "comment", "note", "explanation"],
-  importance: ["importance", "priority", "weight", "level", "score"],
-  keepSource: ["keepSource", "keep_source", "source_id", "sourceId", "keeper", "keep_id", "keepId"],
-  winner: ["winner", "winner_id", "winnerId", "win_id", "winId", "preferred", "primary"],
-  loser: ["loser", "loser_id", "loserId", "lose_id", "loseId", "drop_id", "dropId", "archive_id", "archiveId"],
-  title: ["title", "new_title", "newTitle", "merged_title", "mergedTitle", "merge_title", "mergeTitle"],
-  content: ["content", "new_content", "newContent", "merged_content", "mergedContent", "merge_content", "mergeContent"],
-  evidence: ["evidence", "evidence_ids", "evidenceIds"]
-};
-
-// 保守的 action 值同义词：只收语义无歧义、不可能被误认为记忆类型/其他 action 的映射。
-const ACTION_SYNONYMS = {
-  archived: "archive",
-  remove: "archive",
-  delete: "archive",
-  combine: "merge",
-  consolidation: "merge",
-  consolidate: "merge",
-  modify: "update",
-  edit: "update"
-};
-
-const WRAPPER_KEYS = ["consolidation", "decisions", "actions", "results", "updates", "list", "data"];
-
-/** 把单个决策对象重写到规范字段名；非对象原样返回。 */
-function normalizeOne(raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;
-  const d = {};
-  const consumed = new Set();
-  for (const [canon, aliases] of Object.entries(FIELD_ALIASES)) {
-    for (const key of aliases) {
-      if (key in raw && raw[key] !== undefined && raw[key] !== null) {
-        // action 必须是字符串——{consolidation:[...]} 的 wrapper 数组跳过。
-        if (canon === "action" && Array.isArray(raw[key])) continue;
-        d[canon] = raw[key];
-        consumed.add(key);
-        break;
-      }
-    }
-  }
-  // 保留未被别名消费的原始键（create 的 type、未来字段）原样透传。
-  for (const key of Object.keys(raw)) {
-    if (!consumed.has(key)) d[key] = raw[key];
-  }
-  if (typeof d.action === "string") {
-    const low = d.action.toLowerCase();
-    if (ACTION_SYNONYMS[low] !== undefined) d.action = ACTION_SYNONYMS[low];
-  }
-  // ids 若被写成单个字符串则包成数组（validateDecisions 要求数组）。
-  if (d.ids !== undefined && typeof d.ids === "string") d.ids = [d.ids];
-  return d;
-}
-
-/** 归一化 LLM 决策 body（数组 / 包裹对象 / 单个决策对象），null 原样返回。 */
-function normalizeDecisions(raw) {
-  if (!raw) return raw;
-  if (Array.isArray(raw)) return raw.map(normalizeOne).filter((d) => d && typeof d === "object");
-  if (typeof raw === "object") {
-    for (const key of WRAPPER_KEYS) {
-      if (Array.isArray(raw[key])) return normalizeDecisions(raw[key]);
-    }
-    // 单个决策对象 → 包成单元素数组（validateDecisions 要求数组）。
-    return [normalizeOne(raw)];
-  }
-  return raw;
-}
 const SUMMARY_PROMPT = `你是记忆库摘要助手。根据整理后的记忆，生成一段 150-200 字的记忆库总览，覆盖：用户偏好、活跃项目、关键决策。之后作为会话上下文注入。只输出摘要文本，不要其他内容。`;
 
 const CONSOLIDATION_PROMPT = `你是记忆库整理助手。下面是全部记忆条目（id、类型、标题、内容、重要性、更新时间）。
@@ -401,26 +311,20 @@ async function runAuditedLlm(ctx, service, config, spec, body) {
 }
 
 /**
- * Resolve the LLM route (Issue #25): an explicit plugin config
- * (dreamProvider/dreamModel) is the user's declared override and wins; the
- * agent default model (deployment) is only a fallback when no config route is
- * set. In a standard DSH install agentDefaultModel always resolves, so without
- * this ordering the config route would be dead code and dreamProvider/dreamModel
- * could never take effect. Falls through to undefined when no route exists —
- * runDream then fails safe. A config→default switch is logged so it is observable.
+ * Resolve the LLM route: agent default model (deployment) first, plugin config
+ * (dreamProvider/dreamModel) as fallback. Falls through to undefined when no
+ * route exists — runDream then fails safe. Fallback is logged so a silent
+ * route switch is observable.
  */
 function resolveRoute(ctx, config, logger) {
-  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 dream: no dreamProvider/dreamModel config, falling back to agent default");
-      return { provider: sel.provider, model: sel.model };
-    }
-    logger?.warn?.("dsh-mneme dream: agentDefaultModel unavailable, no config route either");
+    if (sel?.provider && sel?.model) return { provider: sel.provider, model: sel.model };
+    logger?.warn?.("dsh-mneme dream: agentDefaultModel unavailable, falling back to config route");
   } catch (error) {
-    logger?.warn?.(`dsh-mneme dream: agentDefaultModel lookup failed: ${String(error)}`);
+    logger?.warn?.(`dsh-mneme dream: agentDefaultModel lookup failed, falling back to config route: ${String(error)}`);
   }
+  if (config.dreamProvider && config.dreamModel) return { provider: config.dreamProvider, model: config.dreamModel };
   return undefined;
 }
 
@@ -502,7 +406,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
   let inFlight = null;
 
   function shouldTrigger(service) {
-    const memories = service.all().filter((m) => !m.archived && !m.session_disposed_at && m.type !== "summary");
+    const memories = service.all().filter((m) => !m.archived && m.type !== "summary");
     const count = memories.length;
     const chars = totalChars(memories);
     const overBase = count >= baseline.count + thresholdCount || chars >= baseline.chars + thresholdChars;
@@ -559,7 +463,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     if (inFlight) await inFlight.catch(() => {});
   }
 
-  async function runDream(ctx, service, config, settings) {
+  async function runDream(ctx, service, config) {
     const logger = ctx.logger;
     let memories = service.all().filter((m) => !m.archived && m.type !== "summary");
     if (memories.length === 0) return { ok: true, applied: 0, skipped: true, summary: false };
@@ -712,35 +616,23 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       return finish({ ok: false, error: "llm failed", summary: false });
     }
 
-    // v0.5.3 字段名归一化兜底：thinking 模型可能输出别名键/wrapper 对象，
-    // 在 validateDecisions 之前重写到规范字段名，语义正确但 schema 不听话的
-    // 输出不再整单被拒。
-    const decisions = normalizeDecisions(extractJsonArray(decisionText));
+    const decisions = extractJsonArray(decisionText);
     if (!Array.isArray(decisions)) {
       logger?.warn?.(`dsh-mneme dream: no json array in llm output (raw length ${decisionText?.length ?? 0})`);
       return finish({ ok: false, error: "no json array in llm output", summary: false });
     }
-    const { ok, errors, skipped = [] } = validateDecisions(decisions, snapshot, {
+    const { ok, errors } = validateDecisions(decisions, snapshot, {
       maxUpdatePerRun: config.reflectionUpdateMaxPerRun,
       minAgeHours: config.reflectionUpdateMinAgeHours,
       // v0.4.4 fix：显式透传，用户配 dreamImplicitKeep:false 时严格模式必须
       // 真正生效，dreamMinExplicitCoverage 决定隐式 keep 下的覆盖率下限。
       dreamImplicitKeep: config.dreamImplicitKeep,
-      dreamMinExplicitCoverage: config.dreamMinExplicitCoverage,
-      // Issue #26 (P0)：跨类型 merge 等"单条非法"决策不再拖垮整批——默认开启
-      // skipInvalid，非法决策跳过、合法子集照常应用（run 记为 degraded）。
-      // dreamSkipInvalid:false 可恢复旧的"任意非法即整单拒绝"。
-      skipInvalid: config.dreamSkipInvalid !== false,
-      // Issue #26 (P1)：显式开启 allowCrossTypeMerge 后放宽跨类型合并检查。
-      allowCrossTypeMerge: config.allowCrossTypeMerge === true
+      dreamMinExplicitCoverage: config.dreamMinExplicitCoverage
     });
     if (!ok) {
       logger?.warn?.(`dsh-mneme dream: invalid decisions: ${errors.join("; ")}`);
       return finish({ ok: false, error: `invalid decisions: ${errors.length} errors`, summary: false });
     }
-    for (const s of skipped) {
-      logger?.warn?.(`dsh-mneme dream: skipping invalid decision[${s.index}] (${s.action}): ${s.error}`);
-    }
 
     // Capture pre-update snapshots so the audit records what each update changed.
     const updateSnapshots = {};
@@ -813,11 +705,9 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     );
     // Outcome is derived from the ACTUALLY committed sub-steps, never from the
     // raw LLM decision list — a merge whose archive step rolled back must not
-    // claim "merge-archived" (item ②). Conflicts/failures/skipped ride along
-    // so the audit row records why the run diverged (Issue #26: skipped =
-    // decisions dropped by skipInvalid because they were individually invalid,
-    // e.g. cross-type merge).
-    const outcome = { ...buildOutcome(committed), conflicts, failures, skipped };
+    // claim "merge-archived" (item ②). Conflicts/failures ride along so the
+    // audit row records why the run diverged.
+    const outcome = { ...buildOutcome(committed), conflicts, failures };
     // Frozen conflicts were not adjudicated: mark both sides pending in the
     // per-id outcome so the audit row shows they were parked, not skipped.
     if (frozenIds.length) {
@@ -833,30 +723,6 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     // that only froze conflicts is not a noop.
     const noChange = frozenCount === 0 && applied === 0 && committed.every((c) => c.action === "keep");
 
-    // v0.6.2 auto-tag: a light LLM pass over the retained (post-consolidation)
-    // memories. Opt-in via config.autoTagEnabled, bounded by autoTagMaxPerRun,
-    // and always fail-safe — a tag failure must never change the consolidation
-    // outcome reported below (it is logged and counted, nothing more).
-    let autoTagged = 0;
-    // Effective opt-in (issue #31): the Web panel's settings toggle
-    // (user_settings) overrides the zod plugin config when explicitly stored;
-    // unset → fall back to config.autoTagEnabled. settings is null-safe (absent
-    // in tests / direct calls) so behaviour is unchanged without it.
-    const autoTagEnabled = settings?.getAutoTagConfig?.().autoTagEnabled ?? config.autoTagEnabled;
-    if (autoTagEnabled === true) {
-      try {
-        const tagResult = await runAutoTag({ ctx, service, config, route });
-        autoTagged = tagResult?.tagged ?? 0;
-        if (tagResult?.ok === false && tagResult?.skippedBy && tagResult.skippedBy !== "empty") {
-          logger?.warn?.(`dsh-mneme dream: auto-tag skipped (${tagResult.skippedBy})`);
-        } else if (autoTagged > 0) {
-          logger?.info?.(`[dsh-mneme] auto-tag: ${autoTagged} memory(ies) tagged`);
-        }
-      } catch (error) {
-        logger?.warn?.(`dsh-mneme dream: auto-tag failed: ${String(error)}`);
-      }
-    }
-
     // Keep the vector index consistent with the post-dream store state.
     if (semantic?.embedder && semantic?.vectorIndex) {
       try {
@@ -886,7 +752,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
           : {}),
         messages: [
           { role: "system", content: [{ type: "text", text: SUMMARY_PROMPT }] },
-          { role: "user", content: [{ type: "text", text: service.all().filter((m) => !m.archived && !m.session_disposed_at && m.type !== "summary").map((m) => `- ${m.title}: ${m.content}`).join("\n") }] }
+          { role: "user", content: [{ type: "text", text: service.all().filter((m) => !m.archived && m.type !== "summary").map((m) => `- ${m.title}: ${m.content}`).join("\n") }] }
         ]
       }, reportUsage));
     } catch (error) {
@@ -919,12 +785,9 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     //               run. ok:false keeps the scheduler from moving the baseline.
     //   ok        — either real changes landed, or a fresh summary was stored
     //               (all-keep + summary is a substantive summary refresh).
-    //   degraded  — real consolidation landed but the run did not produce its
-    //               full output: the summary came back empty/missing, or
-    //               (Issue #26) some individually-invalid decisions were
-    //               skipped by skipInvalid. The valid subset was absorbed (ok
-    //               for the baseline — a future run won't re-fail on the same
-    //               permanently-invalid pairs), but the run is marked, not faked.
+    //   degraded  — real consolidation landed but the summary came back empty/
+    //               missing: the store was absorbed (ok for the baseline) but
+    //               the run did not produce its full output (marked, not faked).
     let status;
     let okResult;
     if (partial) {
@@ -933,13 +796,6 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     } else if (noChange) {
       status = summaryStored ? "ok" : "noop";
       okResult = summaryStored;
-    } else if (skipped.length > 0) {
-      // Issue #26: valid subset landed but at least one decision was dropped as
-      // invalid (e.g. cross-type merge). degraded (not ok) — never a fake ok.
-      // autoTag still runs on degraded runs, so it is not blocked behind a
-      // "success" that a skipped-invalid run can never reach.
-      status = "degraded";
-      okResult = true;
     } else {
       status = summaryStored ? "ok" : "degraded";
       okResult = true;
@@ -952,10 +808,8 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       outcome,
       conflicts,
       failures,
-      skipped,
       frozen: frozenCount,
-      summary: summaryStored,
-      error: skipped.length > 0 ? `skipped ${skipped.length} invalid decision(s)` : undefined
+      summary: summaryStored
     });
   }
 

package/{dsh-mneme/lib → src}/hot-memory.js

@@ -21,13 +21,6 @@ export function estimateTokens(text) {
  *            rounds(): Array, clear(): void}}
  */
 export function createHotMemory({ maxRounds = 5, maxTokens = 2000 } = {}) {
-  // Entry defense: a non-positive or non-integer maxRounds (0, -1, 1.5, NaN,
-  // null, "2") would make the eviction while-loop unbounded — the buffer can
-  // never shrink below `buffer.length > maxRounds`, so `add` would spin forever.
-  // Fall back to the defaults so a hostile/buggy caller can never wedge the
-  // hot-memory buffer in an infinite loop.
-  maxRounds = (Number.isInteger(maxRounds) && maxRounds > 0) ? maxRounds : 5;
-  maxTokens = (Number.isFinite(maxTokens) && maxTokens > 0) ? maxTokens : 2000;
   const buffer = [];
 
   function totalTokens() {