@modusensus/dsh-mneme 0.5.2 → 0.6.0

package/lib/config.js

@@ -4,6 +4,11 @@ export const Config = z.object({
   memoryDir: z.string().default("~/.dsh/memory"),
   autoInject: z.boolean().default(true),
   autoSummarize: z.boolean().default(true),
+  // Session lifecycle (v0.6.0): when enabled, deleting/disposing a session also
+  // archives every memory that was born in it (treating the session as a save
+  // point — entries stay recoverable via memory_archive/restoreBySession).
+  // Default OFF: legacy behavior, a disposed session leaves its memories active.
+  sessionLifecycleEnabled: z.boolean().default(false),
   // Optional model override for summarization. When both are non-empty, they
   // take priority over the session's current model. Empty = use the session's
   // active provider/model (same as before).
@@ -19,11 +24,13 @@ export const Config = z.object({
   dreamModel: z.string(),
   dreamMaxTokens: z.natural().min(256).max(131072).default(8192),
   // Pass-through reasoning effort for dream's LLM calls. 'none' (default)
-  // omits the field so the provider's own default applies; low/medium/high
-  // are forwarded verbatim. Useful to cap reasoning spend on thinking-type
-  // models that would otherwise drain the whole token budget and return an
-  // empty body ("no json array in llm output").
+  // omits the field so the provider's own default applies; 'off' explicitly
+  // disables thinking — REQUIRED for thinking-type models (deepseek-v4-flash
+  // etc.) that would otherwise drain the whole token budget into reasoning and
+  // return an empty body ("no json array in llm output"); low/medium/high are
+  // forwarded verbatim to cap reasoning spend.
   dreamReasoningEffort: z.union([
+    z.const("off"),
     z.const("low"),
     z.const("medium"),
     z.const("high"),
@@ -197,9 +204,11 @@ export const Config = z.object({
   sleepProvider: z.string().default(""),
   sleepModel: z.string().default(""),
   // Pass-through reasoning effort for sleep's LLM passes, same semantics as
-  // dreamReasoningEffort: 'none' (default) omits the field; low/medium/high
-  // are forwarded verbatim.
+  // dreamReasoningEffort: 'none' (default) omits the field; 'off' explicitly
+  // disables thinking (thinking-type models would burn the whole budget on
+  // reasoning); low/medium/high are forwarded verbatim.
   sleepReasoningEffort: z.union([
+    z.const("off"),
     z.const("low"),
     z.const("medium"),
     z.const("high"),

package/lib/dream/sleep.js

@@ -108,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.forgotten && m.type !== "summary");
+  const memories = service.all().filter((m) => !m.archived && !m.session_disposed_at && !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" };
 
@@ -239,7 +239,7 @@ 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) continue;
+    if (m.archived || m.forgotten || m.session_disposed_at) continue;
     const ref = m.last_accessed_at ?? m.updated_at ?? m.created_at;
     if (!ref) continue;
     const t = new Date(ref).getTime();
@@ -273,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.type !== "summary" && m.type !== "pattern")
+    .filter((m) => !m.archived && !m.session_disposed_at && 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" };
@@ -342,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.forgotten);
+  const memories = service.all().filter((m) => !m.archived && !m.session_disposed_at && !m.forgotten);
   const seen = new Set();
   const related = [];
   const MAX_RELATIONS_PER_ORPHAN = 3;

package/lib/dream.js

@@ -1,7 +1,7 @@
 import { validateDecisions, applyDecisions } from "./dream/decisions.js";
 import { clusterMemories, findPotentialConflicts } from "./dream/clustering.js";
 import { createHash, randomUUID } from "node:crypto";
-export { validateDecisions, applyDecisions };
+export { validateDecisions, applyDecisions, normalizeDecisions };
 
 
 // Extract the first JSON array from LLM output, tolerating markdown fences,
@@ -40,6 +40,95 @@ 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、类型、标题、内容、重要性、更新时间）。
@@ -406,7 +495,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
   let inFlight = null;
 
   function shouldTrigger(service) {
-    const memories = service.all().filter((m) => !m.archived && m.type !== "summary");
+    const memories = service.all().filter((m) => !m.archived && !m.session_disposed_at && m.type !== "summary");
     const count = memories.length;
     const chars = totalChars(memories);
     const overBase = count >= baseline.count + thresholdCount || chars >= baseline.chars + thresholdChars;
@@ -616,7 +705,10 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       return finish({ ok: false, error: "llm failed", summary: false });
     }
 
-    const decisions = extractJsonArray(decisionText);
+    // v0.5.3 字段名归一化兜底：thinking 模型可能输出别名键/wrapper 对象，
+    // 在 validateDecisions 之前重写到规范字段名，语义正确但 schema 不听话的
+    // 输出不再整单被拒。
+    const decisions = normalizeDecisions(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 });
@@ -752,7 +844,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.type !== "summary").map((m) => `- ${m.title}: ${m.content}`).join("\n") }] }
+          { 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") }] }
         ]
       }, reportUsage));
     } catch (error) {

package/lib/hot-memory.js

@@ -1,53 +1,53 @@
-// Session-scoped hot memory (v0.5.0 召回率优化 1.3): a short-term buffer of
-// the latest dialogue rounds, kept strictly apart from the long-term memory
-// store. The injector renders it ahead of the long-term recall block so the
-// agent sees "what we were just talking about" without those rounds ever
-// being persisted as memories. Bounded two ways: maxRounds (count) and
-// maxTokens (budget) — whichever evicts first.
-
-// CJK-aware token estimate: one Chinese character ≈ 0.6 tokens (clustering
-// behavior of mainstream tokenizers), one ASCII char ≈ 0.25.
-export function estimateTokens(text) {
-  const s = String(text ?? "");
-  let cjk = 0;
-  for (const ch of s) if (ch >= "\u4e00" && ch <= "\u9fff") cjk++;
-  return Math.ceil(cjk * 0.6 + (s.length - cjk) * 0.25);
-}
-
-/**
- * @param {{maxRounds?: number, maxTokens?: number}} opts
- * @returns {{add(round: {query: string, response?: string}): void,
- *            getContext(): string,
- *            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() {
-    return buffer.reduce(
-      (sum, r) => sum + estimateTokens(`Q: ${r.query}\nA: ${r.response ?? ""}`),
-      0
-    );
-  }
-
-  return {
-    add(round) {
-      if (!round?.query) return;
-      buffer.push({ query: String(round.query), response: String(round.response ?? "") });
-      while (buffer.length > maxRounds) buffer.shift();
-      while (buffer.length > 1 && totalTokens() > maxTokens) buffer.shift();
-    },
-    getContext() {
-      return buffer.map((r) => `Q: ${r.query}\nA: ${r.response ?? ""}`).join("\n\n");
-    },
-    rounds: () => [...buffer],
-    clear() { buffer.length = 0; }
-  };
-}
+// Session-scoped hot memory (v0.5.0 召回率优化 1.3): a short-term buffer of
+// the latest dialogue rounds, kept strictly apart from the long-term memory
+// store. The injector renders it ahead of the long-term recall block so the
+// agent sees "what we were just talking about" without those rounds ever
+// being persisted as memories. Bounded two ways: maxRounds (count) and
+// maxTokens (budget) — whichever evicts first.
+
+// CJK-aware token estimate: one Chinese character ≈ 0.6 tokens (clustering
+// behavior of mainstream tokenizers), one ASCII char ≈ 0.25.
+export function estimateTokens(text) {
+  const s = String(text ?? "");
+  let cjk = 0;
+  for (const ch of s) if (ch >= "\u4e00" && ch <= "\u9fff") cjk++;
+  return Math.ceil(cjk * 0.6 + (s.length - cjk) * 0.25);
+}
+
+/**
+ * @param {{maxRounds?: number, maxTokens?: number}} opts
+ * @returns {{add(round: {query: string, response?: string}): void,
+ *            getContext(): string,
+ *            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() {
+    return buffer.reduce(
+      (sum, r) => sum + estimateTokens(`Q: ${r.query}\nA: ${r.response ?? ""}`),
+      0
+    );
+  }
+
+  return {
+    add(round) {
+      if (!round?.query) return;
+      buffer.push({ query: String(round.query), response: String(round.response ?? "") });
+      while (buffer.length > maxRounds) buffer.shift();
+      while (buffer.length > 1 && totalTokens() > maxTokens) buffer.shift();
+    },
+    getContext() {
+      return buffer.map((r) => `Q: ${r.query}\nA: ${r.response ?? ""}`).join("\n\n");
+    },
+    rounds: () => [...buffer],
+    clear() { buffer.length = 0; }
+  };
+}

package/lib/index.js

@@ -317,6 +317,26 @@ export const apply = (ctx, config) => {
   const summarizer = createSummarizer(ctx, service, cfg);
   disposers.push(summarizer.dispose);
 
+  // Session lifecycle (v0.6.0): when a session leaves the store and the toggle
+  // is enabled, mark every memory born in it as session-disposed (hidden from
+  // injection/search/dream but never destroyed — recoverable via
+  // restoreBySession). Default off, so a disposed session leaves its memories
+  // active (legacy behavior). Every path is guarded: a failure inside the
+  // callback must never propagate into DSH's session teardown (that would crash
+  // the plugin on the very delete action it serves).
+  if (cfg.sessionLifecycleEnabled) {
+    disposers.push(ctx.on("session/disposed", (session) => {
+      const sessionId = session?.id;
+      if (!sessionId) return;
+      try {
+        const { disposed } = service.disposeBySession(sessionId);
+        ctx.logger?.info?.(`[dsh-mneme] session disposed, hid ${disposed} memory(s) for ${sessionId}`);
+      } catch (error) {
+        ctx.logger?.warn?.(`[dsh-mneme] session dispose failed for ${sessionId}: ${String(error)}`);
+      }
+    }));
+  }
+
   if (ctx.webServer) {
     const api = createApi(ctx, service, settings, commands ?? {
       add: () => { throw new Error("commands unavailable"); },