@modusensus/dsh-mneme 0.7.4 → 0.7.6

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

@@ -7,7 +7,9 @@ export const TYPE_FILE = {
   project: "projects.md",
   decision: "decisions.md",
   history: "history.md",
-  summary: "summary.md"
+  summary: "summary.md",
+  user: "user.md",
+  fact: "facts.md"
 };
 
 const ESCAPE = /([\\`*_[\]{}()#+.!|>~-])/g;

package/{src → dsh-mneme/src}/quality-filter.js

@@ -34,7 +34,9 @@ const TYPE_LABELS = {
   decision: ["decision", "决策", "决定"],
   history: ["history", "历史", "事件"],
   summary: ["summary", "总结", "摘要", "总览"],
-  pattern: ["pattern", "模式", "规律"]
+  pattern: ["pattern", "模式", "规律"],
+  user: ["user", "用户"],
+  fact: ["fact", "事实", "原子事实"]
 };
 
 /** Normalized bigram-overlap similarity in [0,1]; 0 for tiny/empty inputs. */

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

@@ -7,7 +7,7 @@ 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"]);
+const INJECT_TYPES = new Set(["preference", "project", "decision", "summary", "user", "fact"]);
 
 // Epistemic trust weights (v0.4.5): when config.trustEpistemicWeighting is on,
 // each recall candidate's existing score is multiplied by the weight of its
@@ -1047,12 +1047,15 @@ export function createService({ store, mirror, config, onWrite, logger, settings
     // (quality_score null) count as 100 (weight 1), so legacy stores keep their
     // exact summary>preference>importance ordering.
     const qualityWeight = (m) => (m.quality_score != null ? m.quality_score / 100 : 1);
+    // summary/user/preference are injected regardless of importance (context
+    // layers); every other INJECT_TYPES type (e.g. fact) only when
+    // importance >= threshold — the frontend "常注入" badge maps to this split.
     const items = store.list({ limit: 200, includeForgotten: false })
       .filter((m) => !m.archived && INJECT_TYPES.has(m.type) && !m.forgotten &&
-        (m.type === "summary" || m.type === "preference" || m.importance >= threshold))
+        (m.type === "summary" || m.type === "preference" || m.type === "user" || m.importance >= threshold))
       .sort((a, b) => {
-        const pa = a.type === "summary" ? 0 : a.type === "preference" ? 1 : 2;
-        const pb = b.type === "summary" ? 0 : b.type === "preference" ? 1 : 2;
+        const pa = a.type === "summary" ? 0 : (a.type === "preference" || a.type === "user") ? 1 : 2;
+        const pb = b.type === "summary" ? 0 : (b.type === "preference" || b.type === "user") ? 1 : 2;
         return pa - pb || (b.importance * qualityWeight(b)) - (a.importance * qualityWeight(a));
       });
     let candidates = items;
@@ -1068,7 +1071,7 @@ export function createService({ store, mirror, config, onWrite, logger, settings
           const hits = vectorIndex.search(queryVector, { limit: maxItems * 2, threshold: 0 });
           for (const m of hits) {
             if (m && !m.archived && INJECT_TYPES.has(m.type) && !m.forgotten &&
-              (m.type === "summary" || m.type === "preference" || m.importance >= threshold)) {
+              (m.type === "summary" || m.type === "preference" || m.type === "user" || m.importance >= threshold)) {
               semanticItems.push(m);
             }
           }
@@ -1606,7 +1609,46 @@ export function createService({ store, mirror, config, onWrite, logger, settings
     list: (o) => store.list(o),
     all: () => store.all(),
     count: (type, opts) => store.count(type, opts),
+    stats: (opts) => store.stats(opts),
     getById: (id) => store.getById(id),
+    // issue #48: resolve a possibly-truncated id to its canonical full id.
+    // Exact hit wins; otherwise the input is treated as a prefix of the id
+    // PRIMARY KEY. Never guesses on ambiguity — returns the candidates and the
+    // caller must pass a full id. Outcome is {ok:true,id} or {ok:false,reason,
+    // message} with reason ∈ invalid | not-found | ambiguous. warnMiss logs the
+    // silent-miss case the delete tool previously swallowed (no return channel
+    // for it, so observability has to live here in the service layer).
+    resolveMemoryId: (input, { warnMiss = false } = {}) => {
+      const bad = (reason, message) => ({ ok: false, reason, message });
+      if (typeof input !== "string") return bad("invalid", "memory id is required");
+      // 手抄/上下文压缩来的 id 可能带首尾空白，统一 trim 后再做精确与前缀解析。
+      const id = input.trim();
+      if (!id) return bad("invalid", "memory id is required");
+      const exact = store.getById(id);
+      if (exact) return { ok: true, id: exact.id };
+      const matches = store.listByIdPrefix(id);
+      if (matches.length === 0) {
+        if (warnMiss) {
+          logger?.warn?.(
+            `[dsh-mneme] memory id "${id}" matched nothing (exact or prefix) — ` +
+            "no entry was deleted; ids are full-length, pass one from memory_list/memory_search output or delete by query=…"
+          );
+        }
+        return bad(
+          "not-found",
+          `memory not found: ${id} (checked exact id and prefix; use a full id from memory_list/memory_search output)`
+        );
+      }
+      if (matches.length > 1) {
+        const sample = matches.slice(0, 5).map((m) => m.id);
+        const tail = matches.length > sample.length ? ` …(+${matches.length - sample.length})` : "";
+        return bad(
+          "ambiguous",
+          `memory id prefix "${id}" matches ${matches.length} entries (${sample.join(", ")}${tail}); refusing to guess — pass a full id`
+        );
+      }
+      return { ok: true, id: matches[0].id };
+    },
     remove: (id) => {
       store.remove(id);
       afterSync("write");

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

@@ -242,7 +242,7 @@ CREATE TABLE IF NOT EXISTS mirror_state (
 );
 `;
 
-const TYPES = new Set(["preference", "project", "decision", "history", "summary", "pattern"]);
+const TYPES = new Set(["preference", "project", "decision", "history", "summary", "pattern", "user", "fact"]);
 
 // Epistemic status: what kind of evidence a memory rests on. Defaults to
 // 'subjective' so legacy rows (and rows without any signal) stay compatible.
@@ -659,11 +659,65 @@ export function createStore(path) {
     return db.prepare(`SELECT count(*) AS c FROM memories ${where}`).get(...params).c;
   }
 
+  /**
+   * Aggregated stats for the Web panel layered overview: per-type distribution
+   * plus a recent daily creation trend. Counts live (non-forgotten /
+   * non-archived / not session-disposed) memories only, matching `count`.
+   * created_at is ISO TEXT, so date strings compare lexicographically.
+   */
+  function stats({ days = 7 } = {}) {
+    const LIVE = "forgotten = 0 AND archived = 0 AND session_disposed_at IS NULL";
+    // Clamp + integer-coerce so fractional strings (e.g. ?days=7.5) can't
+    // produce ragged trend windows (kimi-k2.7-code 复验 S2).
+    days = Math.min(30, Math.max(1, Math.floor(Number(days) || 7)));
+    const now = Date.now(); // single clock read so the window doesn't span a day boundary
+    const byType = db.prepare(
+      `SELECT type, count(*) AS c FROM memories WHERE ${LIVE} GROUP BY type`
+    ).all();
+    const byTypeCounts = {};
+    for (const row of byType) byTypeCounts[row.type] = row.c;
+    const since = new Date(now - (days - 1) * 86400000).toISOString().slice(0, 10);
+    const trend = db.prepare(
+      `SELECT substr(created_at, 1, 10) AS d, count(*) AS c FROM memories
+       WHERE ${LIVE} AND created_at >= ? GROUP BY d ORDER BY d`
+    ).all(since);
+    const trendCounts = {};
+    for (const row of trend) trendCounts[row.d] = row.c;
+    const recent = [];
+    for (let i = days - 1; i >= 0; i--) {
+      const d = new Date(now - i * 86400000).toISOString().slice(0, 10);
+      recent.push({ date: d, count: trendCounts[d] ?? 0 });
+    }
+    const total = Object.values(byTypeCounts).reduce((s, n) => s + n, 0);
+    return { byType: byTypeCounts, total, recent, days };
+  }
+
   function getById(id) {
     const row = db.prepare("SELECT * FROM memories WHERE id = ?").get(id);
     return toRow(row);
   }
 
+  /**
+   * issue #48: resolve a truncated id — as can leak through an agent's context
+   * window when list/search output is shortened — by matching it as a prefix of
+   * the id PRIMARY KEY. Exact lookups keep using getById; this only serves
+   * resolving a *candidate* id. Returns up to 51 rows so the caller can tell
+   * "unique" from "ambiguous" without a second query. LIKE wildcards are
+   * stripped from the input (a valid id fragment is hex/UUID text, never % or
+   * _). Prefix over a PK stays an index scan, so this is cheap even at scale.
+   */
+  function listByIdPrefix(idPrefix) {
+    if (typeof idPrefix !== "string" || !idPrefix.trim()) return [];
+    // LIKE 通配符不参与 id 匹配，一律剥掉。若剥完为空（如 id="%"），
+    // 不能让 SQL 退化成 `LIKE '%'` 全表命中——那会让单条记忆被误删，
+    // 一律视为无匹配返回。
+    const safe = idPrefix.replace(/[\\%_]/g, "");
+    if (!safe) return [];
+    const rows = db.prepare("SELECT * FROM memories WHERE id LIKE ? LIMIT 51")
+      .all(`${safe}%`);
+    return rows.map(toRow);
+  }
+
   /**
    * Case-insensitive exact title lookup (v0.6.1 wiki-link). COLLATE NOCASE
    * folds ASCII case (CJK titles are inherently case-free, so they match
@@ -2175,7 +2229,9 @@ export function createStore(path) {
   return {
     db,
     count,
+    stats,
     getById,
+    listByIdPrefix,
     save,
     update,
     compareAndUpdate,

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

@@ -1,7 +1,7 @@
 import { BlockAssembler, createUserMessage } from "@deepseek-ai/dsh-llm";
 
 const SUMMARY_PROMPT = `你是记忆库提炼助手。根据下面的会话内容，提炼 2-3 条值得跨会话记住的记忆。
-只输出 JSON 数组，每项形如 {"type":"preference|project|decision|history","title":"简短标题","content":"一句话内容","importance":1-5}。
+只输出 JSON 数组，每项形如 {"type":"preference|project|decision|history|user|fact","title":"简短标题","content":"一句话内容","importance":1-5}。
 不要输出任何其他文字。`;
 
 /** Extract a JSON array from LLM output that may contain prose around it. */
@@ -17,7 +17,7 @@ export function parseSummaryJson(raw) {
     return [];
   }
   if (!Array.isArray(arr)) return [];
-  const VALID = new Set(["preference", "project", "decision", "history"]);
+  const VALID = new Set(["preference", "project", "decision", "history", "user", "fact"]);
   return arr.filter(
     (item) =>
       item &&

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

@@ -192,7 +192,7 @@ export function createTools(ctx, service, config, embedder) {
         "Call this when the user states a durable preference, a project decision is made, or a lesson is learned. " +
         "Merges into an existing entry of the same type when the title matches.",
       parameters: {
-        type: { type: "string", required: true, enum: ["preference", "project", "decision", "history"], description: "preference=user profile; project=project knowledge/state; decision=key decision; history=conversation summary" },
+        type: { type: "string", required: true, enum: ["preference", "project", "decision", "history", "user", "fact"], description: "preference=user preference; project=project knowledge/state; decision=key decision; history=conversation summary; user=user profile (background/identity); fact=atomic factual statement" },
         title: { type: "string", required: true, description: "Short unique title" },
         content: { type: "string", required: true, description: "Memory body" },
         tags: { type: "array", items: { type: "string" }, description: "Optional tags" },
@@ -266,7 +266,7 @@ export function createTools(ctx, service, config, embedder) {
       name: "memory_list",
       description: "List at most 50 memory entries by type, high-importance first, then newest, paginated. Set include_archived=true to also list archived (hidden) entries so they can be located and restored. The JSONL summary reports returned/shown/omitted, offset/total/next_offset, and each rendered entry's exact id, type, title, importance, updated_at, tags, and truncated content_preview.",
       parameters: {
-        type: { type: "string", enum: ["preference", "project", "decision", "history"], description: "Filter by type; omit for all" },
+        type: { type: "string", enum: ["preference", "project", "decision", "history", "user", "fact"], description: "Filter by type; omit for all" },
         limit: { type: "integer", description: "Page size (default and maximum 50; nonpositive values use 50)" },
         offset: { type: "integer", description: "Page offset (default 0)" },
         include_archived: { type: "boolean", description: "Include archived (hidden) entries so they can be found and restored (default false)" }
@@ -302,10 +302,10 @@ export function createTools(ctx, service, config, embedder) {
       name: "memory_update",
       description: "Modify an existing memory entry (title, content, type, tags, importance).",
       parameters: {
-        id: { type: "string", required: true, description: "Memory id" },
+        id: { type: "string", required: true, description: "Memory id (full id from memory_list/memory_search output, or a unique prefix of it)" },
         title: { type: "string" },
         content: { type: "string" },
-        type: { type: "string", enum: ["preference", "project", "decision", "history"] },
+        type: { type: "string", enum: ["preference", "project", "decision", "history", "user", "fact"] },
         tags: { type: "array", items: { type: "string" } },
         importance: { type: "integer", description: "1-5" },
         reason: { type: "string", description: "Optional context for the correction (what the user actually said/wanted), recorded for reflection" }
@@ -329,7 +329,9 @@ export function createTools(ctx, service, config, embedder) {
         render: (_args, value) => TEXT_OUTPUT(`Updated memory ${value.memory.id}: ${value.memory.title}`)
       },
       async execute(args) {
-        const memory = service.update(args.id, {
+        const resolved = service.resolveMemoryId(args.id);
+        if (!resolved.ok) throw new Error(resolved.message);
+        const memory = service.update(resolved.id, {
           title: args.title,
           content: args.content,
           type: args.type,
@@ -342,9 +344,9 @@ export function createTools(ctx, service, config, embedder) {
 
     defineTool({
       name: "memory_delete",
-      description: "Permanently delete a memory entry. Pass id for exact delete, or query to delete the single best-matching entry by text — lets the agent honor 'delete the memory about X' without a prior list/search round trip.",
+      description: "Permanently delete a memory entry. Pass id for exact delete (full id, or a unique prefix of it — ambiguous prefixes are rejected), or query to delete the single best-matching entry by text — lets the agent honor 'delete the memory about X' without a prior list/search round trip. An id that matches nothing is logged as a warning instead of failing silently.",
       parameters: {
-        id: { type: "string", description: "Exact memory id to delete (from memory_list/memory_search output)" },
+        id: { type: "string", description: "Memory id to delete: full id (from memory_list/memory_search output) or a unique prefix of it; a miss is logged (warn) and returns deleted:false" },
         query: { type: "string", description: "Delete the best-matching entry for this text (searches title/content/tags; uses hybrid recall when an embedder is configured)" }
       },
       output: {
@@ -353,13 +355,19 @@ export function createTools(ctx, service, config, embedder) {
           additionalProperties: false,
           properties: { deleted: { type: "boolean", required: true } }
         },
-        render: (_args, value) => TEXT_OUTPUT(value.deleted ? "Memory deleted." : "Memory not found.")
+        render: (_args, value) => TEXT_OUTPUT(value.deleted
+          ? "Memory deleted."
+          : "Memory not found — nothing was deleted. Pass a full id (or a unique prefix) from memory_list/memory_search output, or delete by query=… instead.")
       },
       async execute(args) {
         if (args.id) {
-          const existed = service.getById(args.id) !== undefined;
-          if (existed) service.remove(args.id);
-          return { deleted: existed };
+          const resolved = service.resolveMemoryId(args.id, { warnMiss: true });
+          if (!resolved.ok) {
+            if (resolved.reason === "ambiguous") throw new Error(resolved.message);
+            return { deleted: false };
+          }
+          service.remove(resolved.id);
+          return { deleted: true };
         }
         if (args.query) {
           const [best] = await service.searchMemories(args.query, { mode: "auto", topK: 1, useRerank: true });
@@ -378,7 +386,7 @@ export function createTools(ctx, service, config, embedder) {
         "Stop a memory from being auto-injected and from appearing in searches and lists without deleting it. " +
         "The entry stays in storage; pass forgotten: false to restore it.",
       parameters: {
-        id: { type: "string", required: true },
+        id: { type: "string", required: true, description: "Memory id: full id (from memory_list/memory_search output) or a unique prefix of it; ambiguous prefixes are rejected" },
         forgotten: { type: "boolean", description: "Suppress (true, default) or restore (false) the entry's visibility" }
       },
       output: {
@@ -399,10 +407,9 @@ export function createTools(ctx, service, config, embedder) {
         render: (_args, value) => TEXT_OUTPUT(`Memory ${value.memory.id} injection ${value.memory.forgotten ? "suppressed" : "restored"}.`)
       },
       async execute(args) {
-        if (service.getById(args.id) === undefined) {
-          throw new Error("memory not found");
-        }
-        const memory = service.setForget(args.id, args.forgotten ?? true);
+        const resolved = service.resolveMemoryId(args.id);
+        if (!resolved.ok) throw new Error(resolved.message);
+        const memory = service.setForget(resolved.id, args.forgotten ?? true);
         return { memory: { id: memory.id, forgotten: memory.forgotten } };
       }
     }),
@@ -414,7 +421,7 @@ export function createTools(ctx, service, config, embedder) {
         "Archived entries stay in storage and are recoverable: pass archived=false to restore, and use memory_list with " +
         "include_archived=true to find archived entries.",
       parameters: {
-        id: { type: "string", required: true, description: "Memory id" },
+        id: { type: "string", required: true, description: "Memory id: full id (from memory_list/memory_search output) or a unique prefix of it; ambiguous prefixes are rejected" },
         archived: { type: "boolean", description: "Archive (true, default) or restore (false) the entry" }
       },
       output: {
@@ -435,10 +442,9 @@ export function createTools(ctx, service, config, embedder) {
         render: (_args, value) => TEXT_OUTPUT(`Memory ${value.memory.id} ${value.memory.archived ? "archived" : "restored"}.`)
       },
       async execute(args) {
-        if (service.getById(args.id) === undefined) {
-          throw new Error("memory not found");
-        }
-        const memory = service.setArchived(args.id, args.archived ?? true);
+        const resolved = service.resolveMemoryId(args.id);
+        if (!resolved.ok) throw new Error(resolved.message);
+        const memory = service.setArchived(resolved.id, args.archived ?? true);
         return { memory: { id: memory.id, archived: memory.archived } };
       }
     })

package/{test → dsh-mneme/test}/client.test.js

@@ -5,7 +5,9 @@ import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 
 const root = join(dirname(fileURLToPath(import.meta.url)), "..");
-const clientSource = readFileSync(join(root, "lib/client.js"), "utf8");
+// src/ is the single source of truth for every module (including the Web
+// client bundle); lib/ is build output produced by `npm run sync`.
+const clientSource = readFileSync(join(root, "src/client.js"), "utf8");
 const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
 
 // The Web client bundle registers itself via __ModuleLoader__.load. DSH
@@ -18,11 +20,14 @@ test("client bundle registers under the package name", () => {
   assert.equal(match[1], pkg.name, "registered id must equal package.json name");
 });
 
-// client.js is hand-authored under lib/ only (no src/ counterpart), so the
-// src->lib sync must never prune it.
-test("client bundle is lib-only with no src counterpart", () => {
-  assert.equal(existsSync(join(root, "src/client.js")), false, "src/ must not contain client.js");
+// client.js is authored under src/ like every other module; lib/client.js is
+// build output generated by `npm run sync` (prepack), so it must stay a
+// byte-identical copy — drift here means the sync wasn't run.
+test("client bundle is src-authored and synced into lib", () => {
+  assert.equal(existsSync(join(root, "src/client.js")), true, "src/client.js must exist");
   assert.equal(existsSync(join(root, "lib/client.js")), true, "lib/client.js must exist");
+  const libClient = readFileSync(join(root, "lib/client.js"), "utf8");
+  assert.equal(libClient, clientSource, "lib/client.js must equal src/client.js (run `npm run sync`)");
 });
 
 // The memory entry lives at the sidebar foot, not in the settings modal: the

package/dsh-mneme/test/layered-types-stats.test.js

@@ -0,0 +1,144 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createApi } from "../src/api.js";
+import { createSettings } from "../src/settings.js";
+import { TYPE_FILE } from "../src/mirror.js";
+import { parseSummaryJson } from "../src/summarize.js";
+
+// v0.8.x: layered memory types (user / fact) + Web panel stats endpoint.
+// user = user profile (background/identity), fact = atomic factual statement.
+// Both ride the existing single-table `memories` design — only the type enum
+// and downstream lists (mirror / tools / summarize / inject) were extended.
+
+class FakeRes extends EventEmitter {
+  constructor() { super(); this.statusCode = 200; this.body = ""; }
+  writeHead(code, headers) { this.statusCode = code; this.headers = headers; return this; }
+  end(text) { this.body = text ?? ""; this.emit("end"); return this; }
+}
+
+function req(path, method = "GET", body = null) {
+  const r = new EventEmitter();
+  r.url = path;
+  r.method = method;
+  r.headers = {};
+  if (body !== null) {
+    process.nextTick(() => {
+      r.emit("data", Buffer.from(JSON.stringify(body)));
+      r.emit("end");
+    });
+  }
+  return r;
+}
+
+function setup() {
+  const store = createStore(":memory:");
+  const settings = createSettings(store.db);
+  const service = createService({ store, mirror: null, config: {}, settings });
+  const commands = { add: () => {}, remove: () => {}, list: () => [] };
+  const routes = [];
+  const ctx = {
+    webServer: {
+      register(route) { routes.push(route); return () => {}; }
+    }
+  };
+  createApi(ctx, service, settings, commands, undefined, undefined, "");
+  const handler = (path) => routes.find((r) => r.path === path)?.handler;
+  return { store, service, handler };
+}
+
+test("user/fact are valid memory types for saveWithDedupe", () => {
+  const { service } = setup();
+  const a = service.saveWithDedupe({ type: "user", title: "桉桉", content: "湖南工业大学学生，考研公共管理学", importance: 5 });
+  const b = service.saveWithDedupe({ type: "fact", title: "服务器地址", content: "云服务器 Ubuntu 22.04", importance: 3 });
+  assert.equal(a.memory.type, "user");
+  assert.equal(b.memory.type, "fact");
+  assert.equal(service.count("user"), 1);
+  assert.equal(service.count("fact"), 1);
+});
+
+test("mirror TYPE_FILE covers user/fact layers", () => {
+  assert.equal(TYPE_FILE.user, "user.md");
+  assert.equal(TYPE_FILE.fact, "facts.md");
+});
+
+test("autoSummarize accepts user/fact types", () => {
+  const parsed = parseSummaryJson(
+    '[{"type":"user","title":"用户城市","content":"湖南株洲","importance":4},{"type":"fact","title":"端口","content":"23334","importance":3}]'
+  );
+  assert.equal(parsed.length, 2);
+  assert.deepEqual(parsed.map((i) => i.type), ["user", "fact"]);
+  // legacy types still pass, unknown types rejected
+  const mixed = parseSummaryJson(
+    '[{"type":"preference","title":"语言","content":"中文","importance":2},{"type":"nonsense","title":"x","content":"y","importance":1}]'
+  );
+  assert.equal(mixed.length, 1);
+  assert.equal(mixed[0].type, "preference");
+});
+
+test("GET /api/dsh-mneme/list?type=user filters the new layer", async () => {
+  const { service, handler } = setup();
+  service.saveWithDedupe({ type: "user", title: "桉桉", content: "用户画像", importance: 5 });
+  service.saveWithDedupe({ type: "fact", title: "事实", content: "原子事实", importance: 3 });
+  const res = new FakeRes();
+  await handler("/api/dsh-mneme/list")?.({ url: "/api/dsh-mneme/list?type=user" }, res);
+  const data = JSON.parse(res.body);
+  assert.equal(res.statusCode, 200);
+  assert.equal(data.total, 1);
+  assert.equal(data.items[0].type, "user");
+});
+
+test("GET /api/dsh-mneme/stats returns byType distribution + recent trend", async () => {
+  const { service, handler } = setup();
+  service.saveWithDedupe({ type: "user", title: "桉桉", content: "用户画像", importance: 5 });
+  service.saveWithDedupe({ type: "fact", title: "事实1", content: "原子事实", importance: 3 });
+  service.saveWithDedupe({ type: "fact", title: "事实2", content: "另一个事实", importance: 2 });
+  service.saveWithDedupe({ type: "preference", title: "语言", content: "中文", importance: 2 });
+  const res = new FakeRes();
+  await handler("/api/dsh-mneme/stats")?.({ url: "/api/dsh-mneme/stats?days=7" }, res);
+  const data = JSON.parse(res.body);
+  assert.equal(res.statusCode, 200);
+  assert.equal(data.byType.user, 1);
+  assert.equal(data.byType.fact, 2);
+  assert.equal(data.byType.preference, 1);
+  assert.equal(data.total, 4);
+  // 7-day trend covers today (the only day with live rows)
+  assert.equal(data.recent.length, 7);
+  const today = new Date().toISOString().slice(0, 10);
+  assert.equal(data.recent[6].date, today);
+  assert.equal(data.recent[6].count, 4);
+});
+
+test("stats excludes archived/forgotten memories", async () => {
+  const { service, handler } = setup();
+  const a = service.saveWithDedupe({ type: "user", title: "桉桉", content: "用户画像", importance: 5 });
+  const b = service.saveWithDedupe({ type: "fact", title: "事实", content: "原子事实", importance: 3 });
+  service.setArchived(a.memory.id, true);
+  service.setForget(b.memory.id, true);
+  const res = new FakeRes();
+  await handler("/api/dsh-mneme/stats")?.({ url: "/api/dsh-mneme/stats?days=7" }, res);
+  const data = JSON.parse(res.body);
+  assert.equal(data.total, 0);
+});
+
+test("stats clamps days to 1..30", async () => {
+  const { handler } = setup();
+  const res = new FakeRes();
+  await handler("/api/dsh-mneme/stats")?.({ url: "/api/dsh-mneme/stats?days=999" }, res);
+  const data = JSON.parse(res.body);
+  assert.equal(res.statusCode, 200);
+  assert.equal(data.recent.length, 30);
+});
+
+test("stats coerces fractional days to integer (kimi S2)", async () => {
+  const { service, handler } = setup();
+  service.saveWithDedupe({ type: "fact", title: "事实", content: "原子事实", importance: 3 });
+  const res = new FakeRes();
+  await handler("/api/dsh-mneme/stats")?.({ url: "/api/dsh-mneme/stats?days=7.5" }, res);
+  const data = JSON.parse(res.body);
+  assert.equal(data.recent.length, 7); // floor(7.5) → 7, never a ragged 8
+  assert.equal(data.days, 7);
+  assert.equal(data.byType.fact, 1);
+});