@modusensus/dsh-mneme 0.6.11 → 0.7.0

package/dsh-mneme/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@modusensus/dsh-mneme",
+  "description": "Cross-session memory plugin for DeepSeek Harness with autoDream consolidation: SQLite store, Markdown mirrors, 7 model tools, automatic injection, session summarization, user profile/rules, custom slash commands, vector (semantic) search, and a Web GUI panel",
+  "version": "0.7.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/modusensus/dsh-mneme.git"
+  },
+  "homepage": "https://github.com/modusensus/dsh-mneme#readme",
+  "bugs": {
+    "url": "https://github.com/modusensus/dsh-mneme/issues"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": {
+      "default": "./lib/index.js"
+    },
+    "./client": {
+      "default": "./lib/client.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "src",
+    "scripts",
+    "test",
+    "cordis.patch.yml"
+  ],
+  "dsh": {
+    "client": {
+      "inject": [
+        "slots",
+        "locale",
+        "layout",
+        "connection"
+      ],
+      "platform": "web"
+    },
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-system-prompt": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6",
+    "@deepseek-ai/schemastery": "^3.18.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-system-prompt": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6",
+    "@deepseek-ai/schemastery": "^3.18.1",
+    "c8": "^12.0.0"
+  },
+  "scripts": {
+    "sync": "node scripts/sync-lib.js",
+    "prepack": "npm run sync",
+    "test": "node --test test/*.test.js",
+    "test:coverage": "c8 node --test test/*.test.js",
+    "e2e": "node scripts/e2e-dsh.js",
+    "stress": "node scripts/stress-dsh.js"
+  },
+  "dependencies": {
+    "@huggingface/transformers": "^4.2.0"
+  },
+  "overrides": {
+    "adm-zip": "0.6.0"
+  },
+  "c8": {
+    "reporter": ["text", "lcov"]
+  }
+}

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

@@ -458,7 +458,10 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
             name: n.name,
             type: n.type ?? null,
             mention_count: n.mention_count ?? 1,
-            distance: n.distance
+            distance: n.distance,
+            // v0.7.0 实体热投影：实体热 = 关联记忆 heat 聚合（max），前端据此
+            // 缩放节点大小/明暗。heatEnabled=false 时 entityHeat 返回 null。
+            heat: service.entityHeat?.(n.id) ?? null
           })),
           edges: [...edgeMap.values()].map((e) => ({
             id: e.id,

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

@@ -1,4 +1,5 @@
 import z from "@deepseek-ai/schemastery";
+import { TYPE_DECAY_DEFAULTS } from "./heat.js";
 
 export const Config = z.object({
   memoryDir: z.string().default("~/.dsh/memory"),
@@ -295,4 +296,20 @@ export const Config = z.object({
   // audits to recall_runs and NEVER touches recall_evals, regardless of this
   // flag (production isolation is unconditional).
   evalPersistTestResults: z.boolean().default(false),
+
+  // --- heat: v0.7.0 self-evolution (heat + interest drift) ----------------
+  // 总开关，默认开但保守：不改变召回排序，只提供热度字段 / sleep 降级
+  // 联合判定保护 / 前端热度投影。关闭后跳过所有 heat 计算与热度触达。
+  heatEnabled: z.boolean().default(true),
+  // 幂律形状参数 α（heat = 1/(1+λΔt)^α），越大衰减越快。
+  heatGlobalAlpha: z.number().min(0.1).max(5).default(1.2),
+  // per-type 衰减因子 λ；λ=0 的类型免疫（热度恒 1.0，sleep 永不降级）。
+  // 未知类型走默认 0.002。z.dict 的键为 type 字符串、值为数字 λ。
+  heatTypeDecay: z.dict(z.number(), z.string()).default({ ...TYPE_DECAY_DEFAULTS }),
+  // sleep 降级联合判定的热度下限：heat < 该值 且 importance<5 才允许降级。
+  sleepHeatThreshold: z.number().min(0).max(1).default(0.05),
+  // recordRecall 默认值（recall_runs 记录默认开；显式传 false 的调用方不受影响）。
+  recallRecordDefault: z.boolean().default(true),
+  // recall_runs 滚动清理保留天数。
+  recallRetentionDays: z.natural().min(1).max(3650).default(90),
 });

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

@@ -18,6 +18,7 @@ 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";
 
 const SUMMARY_MAX = 120;
 // Conflict similarity threshold per strictness level (v0.4.0):
@@ -247,10 +248,21 @@ function phaseDemotion(service, config, logger, runId, signal = null) {
   for (const m of service.all()) {
     if (signal?.aborted) break;
     if (m.archived || m.forgotten || m.session_disposed_at) continue;
-    const ref = m.last_accessed_at ?? m.updated_at ?? m.created_at;
+    // 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 (!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);

package/dsh-mneme/src/heat.js

@@ -0,0 +1,136 @@
+// dsh-mneme/src/heat.js
+// 热度（heat）纯函数模块：基于类遗忘曲线计算 memory 的当前热度。
+// 零数据库依赖，不引入任何外部依赖。
+
+/**
+ * 默认的 per-type 衰减因子 λ。
+ * λ = 0 表示该类型免疫热度衰减，热度恒为 1.0。
+ */
+export const TYPE_DECAY_DEFAULTS = Object.freeze({
+  preference: 0,    // 免疫：用户画像需长期保持
+  pattern: 0,       // 免疫：发现型稳定规律
+  summary: 0,       // 免疫：已是压缩产物
+  project: 0.0008,  // 慢衰减
+  decision: 0.002,  // 中速衰减
+  history: 0.006,   // 较快（会话摘要不断被合并）
+});
+
+const HOUR_MS = 3600000;
+const DEFAULT_ALPHA = 1.2;
+const DEFAULT_LAMBDA = 0.002;
+
+/**
+ * 将可能的日期值统一转成毫秒时间戳。
+ * 支持 Date、number、ISO 字符串；无法解析时返回 NaN。
+ */
+function toTimestamp(value) {
+  if (value === null || value === undefined) return NaN;
+
+  if (value instanceof Date) {
+    return Number.isFinite(value.getTime()) ? value.getTime() : NaN;
+  }
+
+  if (typeof value === 'number') {
+    return Number.isFinite(value) ? value : NaN;
+  }
+
+  if (typeof value === 'string') {
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : NaN;
+  }
+
+  return NaN;
+}
+
+/**
+ * 获取用于计算热度的参考时间点 ref。
+ * 优先取 last_accessed_at；缺失时退到 created_at。
+ * 绝不 fallback 到 updated_at。
+ */
+function getRef(memory) {
+  if (!memory || typeof memory !== 'object') return NaN;
+  return toTimestamp(memory.last_accessed_at ?? memory.created_at);
+}
+
+/**
+ * 解析并校验配置，提供安全的 alpha 与衰减表。
+ */
+function resolveConfig(config) {
+  const safe = config && typeof config === 'object' ? config : {};
+
+  let alpha = safe.heatGlobalAlpha ?? DEFAULT_ALPHA;
+  if (!Number.isFinite(alpha) || alpha <= 0) {
+    alpha = DEFAULT_ALPHA;
+  }
+
+  const decayMap = safe.heatTypeDecay ?? TYPE_DECAY_DEFAULTS;
+
+  return { alpha, decayMap };
+}
+
+/**
+ * 构建热度信号对象，便于调试与后续扩展。
+ *
+ * @param {object} memory - memory 记录
+ * @param {object} config - 插件配置
+ * @param {number} [now=Date.now()] - 当前毫秒时间戳
+ * @returns {{ type, ref, lambda, alpha, deltaHours }}
+ */
+export function buildHeatSignals(memory, config, now = Date.now()) {
+  const nowMs = Number.isFinite(now) ? now : Date.now();
+  const ref = getRef(memory);
+  const { alpha, decayMap } = resolveConfig(config);
+
+  const type = memory?.type;
+
+  // 取对应类型的 λ，未知类型走默认
+  let lambda = decayMap[type];
+  if (!Number.isFinite(lambda)) {
+    lambda = DEFAULT_LAMBDA;
+  }
+  // λ < 0 视为非法，回退到默认；λ === 0 保留为免疫
+  if (lambda < 0) {
+    lambda = DEFAULT_LAMBDA;
+  }
+
+  let deltaHours;
+  if (!Number.isFinite(ref)) {
+    deltaHours = NaN;
+  } else if (nowMs < ref) {
+    deltaHours = 0;
+  } else {
+    deltaHours = (nowMs - ref) / HOUR_MS;
+  }
+
+  return { type, ref, lambda, alpha, deltaHours };
+}
+
+/**
+ * 计算 memory 的热度 H ∈ [0, 1]。
+ *
+ * 公式：H = 1 / (1 + λ · ΔtHours)^α
+ *
+ * @param {object} memory - memory 记录
+ * @param {number} [now=Date.now()] - 当前毫秒时间戳
+ * @param {object} [config={}] - 插件配置
+ * @returns {number} 热度值
+ */
+export function computeHeat(memory, now = Date.now(), config = {}) {
+  const signals = buildHeatSignals(memory, config, now);
+  const { alpha, lambda, deltaHours, ref } = signals;
+
+  // 无有效参考时间、或未来时间，热度视为满格
+  if (!Number.isFinite(ref) || deltaHours <= 0) {
+    return 1.0;
+  }
+
+  // λ = 0 的类型免疫，热度恒满
+  if (lambda === 0) {
+    return 1.0;
+  }
+
+  const heat = 1 / Math.pow(1 + lambda * deltaHours, alpha);
+
+  // 防止浮点误差越界
+  return Math.min(1, Math.max(0, heat));
+}

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

@@ -52,6 +52,13 @@ export const apply = (ctx, config) => {
       store.deleteOldLlmAudits(new Date(Date.now() - retentionMs * 86400000).toISOString());
     }
   } catch { /* non-fatal */ }
+  // v0.7.0: recall_runs 滚动清理 —— recordRecall 默认开且注入路径也记账，表随
+  // 活跃度增长；启动时按 recallRetentionDays（默认 90 天）清一次，防膨胀。
+  // 与 llm_audit 同策略：纯 bookkeeping，清理失败绝不阻塞插件启动。
+  try {
+    const recallRetentionDays = Number.isInteger(cfg.recallRetentionDays) ? cfg.recallRetentionDays : 90;
+    store.purgeRecallRunsOlderThan(recallRetentionDays);
+  } catch { /* non-fatal */ }
   const mirror = createMirror(memoryDir);
   const service = createService({ store, mirror, config: cfg, logger: ctx.logger });
 

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

@@ -5,6 +5,7 @@ import { createBM25Index } from "./search/bm25.js";
 import { adaptiveThreshold } from "./search/adaptive.js";
 import { parseWikiLinks } from "./parser/wiki-link.js";
 import { extractQueryTags, applyTagBoost } from "./search/tag-boost.js";
+import { computeHeat } from "./heat.js";
 
 const INJECT_TYPES = new Set(["preference", "project", "decision", "summary"]);
 
@@ -467,14 +468,15 @@ export function createService({ store, mirror, config, onWrite, logger }) {
   }
 
   /**
-   * Sleep touch (v0.4.0): when sleep is enabled, any memory surfaced by recall
-   * or auto-injection gets its last_accessed_at bumped, so the "unrecalled N
-   * days → demote/archive" tiering counts real access. Best-effort and gated on
-   * config.sleepModeEnabled — when sleep is off this is a complete no-op (no
-   * writes on the hot recall path). A touch failure must never break search/inject.
+   * Recall touch (v0.7.0 数据前提): any memory surfaced by recall or
+   * auto-injection gets its last_accessed_at bumped so the heat model has a
+   * truthful access clock. Previously gated on config.sleepModeEnabled — now
+   * gated on config.heatEnabled (default on) so heat data is collected
+   * independently of sleep mode; sleep consumes it when it runs. Best-effort:
+   * a touch failure must never break search/inject.
    */
   function touchRecalled(memories) {
-    if (config?.sleepModeEnabled !== true || !Array.isArray(memories) || memories.length === 0) return;
+    if (config?.heatEnabled === false || !Array.isArray(memories) || memories.length === 0) return;
     for (const m of memories) {
       if (!m?.id) continue;
       try {
@@ -484,7 +486,15 @@ export function createService({ store, mirror, config, onWrite, logger }) {
   }
 
   async function searchMemories(query, options = {}) {
-    const { mode = "auto", topK = 20, threshold, useRerank = true, recordRecall = false } = options;
+    // v0.7.0: recall_runs 记录默认开（config.recallRecordDefault，默认 true）；
+    // 显式传 recordRecall:false 或配置 recallRecordDefault:false 可关。
+    const {
+      mode = "auto",
+      topK = 20,
+      threshold,
+      useRerank = true,
+      recordRecall = options.recordRecall ?? (config?.recallRecordDefault ?? true)
+    } = options;
     const raw = String(query ?? "").trim();
     if (!raw) return [];
 
@@ -683,12 +693,16 @@ export function createService({ store, mirror, config, onWrite, logger }) {
           mode,
           topK: lim,
           threshold: threshold ?? null,
+          // v0.7.0 recall-layer 强度标记：搜索帧一律 injected:false（被召回 =
+          // 检索直接命中）；注入上下文帧由 injectCandidates 以 injected:true
+          // 单独记账（被注入 = 替对话搭建上下文），两档强度可区分。
           candidates: result.map((m) => ({
             id: m.id,
             title: m.title,
             content: m.content,
             score: m.score ?? null,
-            source: m.source ?? "keyword"
+            source: m.source ?? "keyword",
+            injected: false
           })),
           createdAt: new Date().toISOString()
         });
@@ -1060,6 +1074,32 @@ export function createService({ store, mirror, config, onWrite, logger }) {
       } catch { /* topic re-rank unavailable: keep rule-based order */ }
     }
     const selected = candidates.slice(0, maxItems);
+    // v0.7.0 recall-layer 强度标记：注入场景也走 recall_runs 记账（mode="inject"、
+    // injected:true），与 searchMemories 的搜索帧（injected:false）互补，区分
+    // "被召回"与"被注入上下文"两个消耗强度。与搜索侧同受 recallRecordDefault
+    // 门控；记账失败绝不阻断注入本身。
+    if (recallRecorder && config.recallRecordDefault !== false) {
+      try {
+        recallRecorder({
+          query: q,
+          mode: "inject",
+          topK: selected.length,
+          threshold: null,
+          candidates: selected.map((m) => ({
+            id: m.id,
+            title: m.title,
+            content: m.content,
+            score: m.score ?? null,
+            // 注入帧的 source 固定为帧级标记 "inject"，与搜索帧的
+            // keyword/vector/rerank 对齐（记忆行自带的 source 是来源列，
+            // 与检索层级无关，不混入）。
+            source: "inject",
+            injected: true
+          })),
+          createdAt: new Date().toISOString()
+        });
+      } catch { /* recall receipt is best effort */ }
+    }
     touchRecalled(selected);
     return selected;
   }
@@ -1696,6 +1736,21 @@ export function createService({ store, mirror, config, onWrite, logger }) {
     saveWikiLinks: (r) => store.saveWikiLinks(r),
     listEntities: (o) => store.listEntities(o),
     getRelations: (id) => store.getRelations(id),
+    // v0.7.0 实体热投影：实体热 = 关联记忆 heat 聚合（取 max）。无关联记忆
+    // 或 heatEnabled=false 时返回 null；前端据此决定图谱节点大小/明暗。
+    entityHeat: (entityId) => {
+      if (config.heatEnabled === false) return null;
+      const rels = store.getRelations(entityId) ?? [];
+      let max = -Infinity;
+      for (const rel of rels) {
+        if (!rel.memory_id) continue;
+        const mem = store.getById(rel.memory_id);
+        if (!mem) continue;
+        const h = computeHeat(mem, Date.now(), config);
+        if (h > max) max = h;
+      }
+      return max === -Infinity ? null : max;
+    },
     // Tag system (v0.6.2). setMemoryTags is the manual/user path: gated by
     // config.manualTagEnabled (default true), re-renders the mirror and fires
     // the write hook. applyMemoryTags is the raw write used by the autoDream

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

@@ -725,6 +725,9 @@ export function createStore(path) {
     return getById(id);
   }
 
+  // v0.7.0 语义：updated_at 只记录内容变更，绝不当访问（与 last_accessed_at
+  // 正交，sleep/heat 永不 fallback 到它）。合并/更新刷 updated_at 不应
+  // 重置热度时钟 —— 防 autoDream 合并动作伪装成"刚被召回"。
   function update(id, patch) {
     const existing = getById(id);
     if (!existing) throw new Error(`memory not found: ${id}`);
@@ -1288,6 +1291,19 @@ export function createStore(path) {
     return rows.map(toRecallRun);
   }
 
+  /**
+   * Rolling purge of the recall_runs production audit (v0.7.0): with recordRecall
+   * defaulting ON, the table would otherwise grow unboundedly on a busy store.
+   * Drop rows older than `days` (config.recallRetentionDays, default 90).
+   * created_at is an ISO TEXT string, so the ISO bound compares lexicographically.
+   * Returns the number of rows deleted (bookkeeping — never throws on empty).
+   */
+  function purgeRecallRunsOlderThan(days) {
+    const cutoff = new Date(Date.now() - days * 86400000).toISOString();
+    const result = db.prepare("DELETE FROM recall_runs WHERE created_at < ?").run(cutoff);
+    return result.changes;
+  }
+
   // --- recall evaluation trail (方案 B: separate from the production audit) -
 
   /**
@@ -2185,6 +2201,7 @@ export function createStore(path) {
     saveRecallRun,
     getRecallRun,
     listRecallRuns,
+    purgeRecallRunsOlderThan,
     saveRecallEval,
     getRecallEval,
     listRecallEvals,

package/{test → dsh-mneme/test}/graph-api.test.js

@@ -173,3 +173,37 @@ test("ego 2-hop over 100+ nodes stays under 50ms (spec §7)", async () => {
   assert.ok(data.edges.length > 0);
   assert.ok(ms < 50, `2-hop query took ${ms.toFixed(1)}ms, spec budget is 50ms`);
 });
+
+test("ego node heat projects from linked memory heat (v0.7.0)", async () => {
+  const { routes, service } = setup();
+  const mem = service.saveWithDedupe({ type: "history", title: "test", content: "test entity heat", importance: 3 });
+  const entity = service.createEntity({ name: "E", type: "project" });
+  service.saveRelation({ from_entity: entity.id, to_entity: entity.id, relation_type: "evidence", memory_id: mem.memory.id });
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/semantic/graph/ego");
+  assert.ok(route, "ego route exists");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/semantic/graph/ego?entity=E"), res);
+  const data = JSON.parse(res.body);
+  const node = data.nodes.find((n) => n.name === "E");
+  assert.ok(typeof node.heat === "number" && node.heat >= 0 && node.heat <= 1, "entity node has a heat value");
+  assert.ok(Math.abs(node.heat - 1) < 0.01, "fresh memory -> heat ~1.0 -> entity heat ~1.0");
+});
+
+test("ego node heat is null when heatEnabled=false (v0.7.0)", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: { heatEnabled: false } });
+  const settings = createSettings(store.db);
+  const commands = { add: () => {}, remove: () => {}, list: () => [] };
+  const routes = [];
+  const ctx = { webServer: { register(route) { routes.push(route); return () => {}; } } };
+  createApi(ctx, service, settings, commands, null, undefined, "");
+  const mem = service.saveWithDedupe({ type: "history", title: "关联记忆", content: "实体关联", importance: 3 });
+  const entity = service.createEntity({ name: "F", type: "project" });
+  service.saveRelation({ from_entity: entity.id, to_entity: entity.id, relation_type: "evidence", memory_id: mem.memory.id });
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/semantic/graph/ego");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/semantic/graph/ego?entity=F"), res);
+  const data = JSON.parse(res.body);
+  assert.equal(data.nodes.find((n) => n.name === "F").heat, null, "heat disabled → entity heat is null");
+  store.close();
+});

package/dsh-mneme/test/heat.test.js

@@ -0,0 +1,148 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  computeHeat,
+  buildHeatSignals,
+  TYPE_DECAY_DEFAULTS,
+} from '../src/heat.js';
+
+const HOUR = 3600000;
+
+describe('heat.js', () => {
+  test('未知类型使用默认 λ=0.002；72h 后 heat < 1 且 > 0.8，并随 Δt 单调递减', () => {
+    const now = Date.now();
+    const base = { type: 'episodic', last_accessed_at: now - 72 * HOUR };
+
+    const heat72 = computeHeat(base, now, {});
+    const heat144 = computeHeat(
+      { ...base, last_accessed_at: now - 144 * HOUR },
+      now,
+      {}
+    );
+
+    assert(heat72 < 1.0, '72h 后热度应小于 1');
+    assert(heat72 > 0.8, '72h 后热度应仍大于 0.8');
+    assert(heat144 < heat72, 'Δt 越大，热度应越低');
+  });
+
+  test('λ=0 的免疫类型任意 Δt 返回 1.0', () => {
+    const now = Date.now();
+    const config = { heatTypeDecay: { preference: 0 } };
+
+    assert.strictEqual(
+      computeHeat(
+        { type: 'preference', last_accessed_at: now - 999 * 24 * HOUR },
+        now,
+        config
+      ),
+      1.0
+    );
+
+    assert.strictEqual(
+      computeHeat(
+        { type: 'pattern', last_accessed_at: now - 365 * 24 * HOUR },
+        now,
+        { heatTypeDecay: TYPE_DECAY_DEFAULTS }
+      ),
+      1.0
+    );
+  });
+
+  test('ref 优先使用 last_accessed_at，缺失退 created_at，皆无返回 1.0', () => {
+    const now = Date.now();
+    const config = {
+      heatTypeDecay: { decision: 0.002 },
+      heatGlobalAlpha: 1.0,
+    };
+
+    const withLast = computeHeat(
+      {
+        type: 'decision',
+        last_accessed_at: now - 24 * HOUR,
+        created_at: now - 100 * HOUR,
+      },
+      now,
+      config
+    );
+
+    const withCreated = computeHeat(
+      { type: 'decision', created_at: now - 24 * HOUR },
+      now,
+      config
+    );
+
+    assert(withLast < 1.0);
+    assert.strictEqual(withLast, withCreated);
+
+    const noRef = computeHeat({ type: 'decision' }, now, config);
+    assert.strictEqual(noRef, 1.0);
+  });
+
+  test('非法 ref 或 now < ref 时返回 1.0', () => {
+    const now = Date.now();
+
+    assert.strictEqual(
+      computeHeat(
+        { type: 'decision', last_accessed_at: 'not-a-date' },
+        now,
+        {}
+      ),
+      1.0
+    );
+
+    assert.strictEqual(
+      computeHeat(
+        { type: 'decision', last_accessed_at: now + 1000 },
+        now,
+        {}
+      ),
+      1.0
+    );
+  });
+
+  test('α 越大衰减越快（同一 Δt 下 α=2 的热度低于 α=1）', () => {
+    const now = Date.now();
+    const base = {
+      type: 'decision',
+      last_accessed_at: now - 7 * 24 * HOUR,
+    };
+
+    const h1 = computeHeat(base, now, {
+      heatTypeDecay: { decision: 0.002 },
+      heatGlobalAlpha: 1.0,
+    });
+
+    const h2 = computeHeat(base, now, {
+      heatTypeDecay: { decision: 0.002 },
+      heatGlobalAlpha: 2.0,
+    });
+
+    assert(h2 < h1, 'α 更大时，同一 Δt 热度应更低');
+  });
+
+  test('buildHeatSignals 返回字段齐全且 deltaHours 正确', () => {
+    const now = 1000000000000; // 固定毫秒时间戳
+    const ref = now - 12 * HOUR;
+
+    const signals = buildHeatSignals(
+      { type: 'project', last_accessed_at: ref },
+      { heatGlobalAlpha: 1.5 },
+      now
+    );
+
+    assert.deepStrictEqual(Object.keys(signals).sort(), [
+      'alpha',
+      'deltaHours',
+      'lambda',
+      'ref',
+      'type',
+    ]);
+
+    assert.strictEqual(signals.type, 'project');
+    assert.strictEqual(signals.lambda, 0.0008);
+    assert.strictEqual(signals.alpha, 1.5);
+    assert.strictEqual(signals.ref, ref);
+    assert.strictEqual(signals.deltaHours, 12);
+  });
+});