@modusensus/dsh-mneme 0.8.0 → 0.8.2

package/test/scope-strict.test.js

@@ -4,9 +4,13 @@ import { createStore } from "../src/store.js";
 import { createService } from "../src/service.js";
 import { createTools } from "../src/tools.js";
 
-// v0.8.0 A3（issue #17）：strictScope 硬过滤 + agent 不对称可见性。
-// 四象限公式：记忆可见 ⇔ (agent 维未标注或命中) AND (workspace 维未标注或命中)；
-// 当前会话维度解析不到时该维度带标注的记忆不可见（fail-closed）。
+// v0.8.0 A3（issue #17）→ v0.8.1 第 3 步（issue #170 4.3，作者已确认）：
+// strictScope 硬过滤只认显式声明。可见性公式收窄为：记忆可见 ⇔ 对每一维
+// （该维标注存在且来源=explicit 时：命中当前会话）AND。
+//   - explicit 行为硬墙：他者维度不可见（含 memory_get 无存在性泄漏）；
+//   - auto / 存量 NULL 来源（v0.8.0 自动标注）不进硬过滤，只吃 A2 软加权
+//     （foreign ×0.5 保留可见）；
+//   - 当前会话维度解析不到 → 该维 explicit 行一律不可见（fail-closed 收窄）。
 
 function setup(config) {
   const store = createStore(":memory:");
@@ -14,46 +18,69 @@ function setup(config) {
   return { store, service };
 }
 
-test("visibility predicate: four-quadrant semantics", () => {
+test("visibility predicate: explicit rows keep four-quadrant semantics", () => {
   const { service } = setup({ scopeEnabled: true, strictScope: true });
   const vis = service.isVisibleInScope;
   const me = { agent_scope: "coder", workspace_scope: "D:\\p" };
+  const E = "explicit";
 
   // 全局（未标注）对谁都可见。
   assert.equal(vis({}, me), true);
   // agent 专属：同 agent 任意 workspace 可见，他人不可见。
-  assert.equal(vis({ agent_scope: "coder" }, me), true);
-  assert.equal(vis({ agent_scope: "novelist" }, me), false);
+  assert.equal(vis({ agent_scope: "coder", agent_scope_source: E }, me), true);
+  assert.equal(vis({ agent_scope: "novelist", agent_scope_source: E }, me), false);
   // workspace 专属：同 workspace 任意 agent 可见，别的 workspace 不可见。
-  assert.equal(vis({ workspace_scope: "D:\\p" }, me), true);
-  assert.equal(vis({ workspace_scope: "D:\\q" }, me), false);
+  assert.equal(vis({ workspace_scope: "D:\\p", workspace_scope_source: E }, me), true);
+  assert.equal(vis({ workspace_scope: "D:\\q", workspace_scope_source: E }, me), false);
   // 双标注：精确命中才可见。
-  assert.equal(vis({ agent_scope: "coder", workspace_scope: "D:\\p" }, me), true);
-  assert.equal(vis({ agent_scope: "coder", workspace_scope: "D:\\q" }, me), false);
-  assert.equal(vis({ agent_scope: "novelist", workspace_scope: "D:\\p" }, me), false);
+  assert.equal(vis({ agent_scope: "coder", agent_scope_source: E, workspace_scope: "D:\\p", workspace_scope_source: E }, me), true);
+  assert.equal(vis({ agent_scope: "coder", agent_scope_source: E, workspace_scope: "D:\\q", workspace_scope_source: E }, me), false);
+  assert.equal(vis({ agent_scope: "novelist", agent_scope_source: E, workspace_scope: "D:\\p", workspace_scope_source: E }, me), false);
 });
 
-test("visibility predicate: anonymous session sees only unscoped rows (fail-closed)", () => {
+test("visibility predicate: auto and legacy rows are NOT hard walls (soft only)", () => {
+  const { service } = setup({ scopeEnabled: true, strictScope: true });
+  const vis = service.isVisibleInScope;
+  const me = { agent_scope: "coder", workspace_scope: "D:\\p" };
+
+  // auto（v0.8.1 载体自动标注）与存量 NULL 来源（v0.8.0 自动标注）他者维度
+  // 也可见——硬过滤只认 explicit。
+  assert.equal(vis({ agent_scope: "novelist" }, me), true, "legacy NULL source");
+  assert.equal(vis({ agent_scope: "novelist", agent_scope_source: "auto" }, me), true);
+  assert.equal(vis({ workspace_scope: "D:\\q", workspace_scope_source: "auto" }, me), true);
+  // 混合：agent 维 auto + workspace 维 explicit → 只 workspace 维构成硬墙。
+  assert.equal(vis({ agent_scope: "novelist", agent_scope_source: "auto", workspace_scope: "D:\\q", workspace_scope_source: "explicit" }, me), false);
+  assert.equal(vis({ agent_scope: "novelist", agent_scope_source: "explicit", workspace_scope: "D:\\q", workspace_scope_source: "auto" }, me), false);
+});
+
+test("visibility predicate: anonymous session fail-closes only explicit rows", () => {
   const { service } = setup({ scopeEnabled: true, strictScope: true });
   const vis = service.isVisibleInScope;
   const anon = { agent_scope: null, workspace_scope: null };
   assert.equal(vis({}, anon), true);
-  assert.equal(vis({ agent_scope: "coder" }, anon), false);
-  assert.equal(vis({ workspace_scope: "D:\\p" }, anon), false);
+  assert.equal(vis({ agent_scope: "coder", agent_scope_source: "explicit" }, anon), false);
+  assert.equal(vis({ workspace_scope: "D:\\p", workspace_scope_source: "explicit" }, anon), false);
+  // auto/存量行照常可见（不冒认，但也不因身份缺失误杀软标注）。
+  assert.equal(vis({ agent_scope: "coder" }, anon), true);
+  assert.equal(vis({ agent_scope: "coder", agent_scope_source: "auto" }, anon), true);
 });
 
-test("searchMemories hard-filters foreign scopes when strictScope is on", async () => {
+test("searchMemories: explicit foreign filtered, auto/legacy foreign stay visible under strictScope", async () => {
   const { store, service } = setup({ scopeEnabled: true, strictScope: true });
   store.save({ type: "project", title: "global needle", content: "x" });
-  store.save({ type: "project", title: "mine needle", content: "x", agent_scope: "me" });
-  store.save({ type: "project", title: "foreign needle", content: "x", agent_scope: "other" });
+  store.save({ type: "project", title: "mine needle", content: "x", agent_scope: "me", agent_scope_source: "explicit" });
+  store.save({ type: "project", title: "explicit foreign needle", content: "x", agent_scope: "other", agent_scope_source: "explicit" });
+  store.save({ type: "project", title: "auto foreign needle", content: "x", agent_scope: "other", agent_scope_source: "auto" });
+  store.save({ type: "project", title: "legacy foreign needle", content: "x", agent_scope: "other" });
 
   const rows = await service.searchMemories("needle", {
     mode: "keyword",
     scope: { agent_scope: "me", workspace_scope: null }
   });
-  // 他 scope 直接出局（区别于 A2 的降权保留可见）；未标注与命中行保留。
-  assert.deepEqual(rows.map((m) => m.title).sort(), ["global needle", "mine needle"]);
+  // explicit 他者出局；auto/存量他者保留（A2 降权仍可见）；未标注与命中行保留。
+  assert.deepEqual(rows.map((m) => m.title).sort(), [
+    "auto foreign needle", "global needle", "legacy foreign needle", "mine needle"
+  ]);
 });
 
 test("strictScope off keeps A2 behavior: foreign rows demoted but visible", async () => {
@@ -66,38 +93,73 @@ test("strictScope off keeps A2 behavior: foreign rows demoted but visible", asyn
   assert.deepEqual(rows.map((m) => m.title), ["foreign needle"]);
 });
 
-test("store.list/count visibility option filters in SQL with consistent totals", () => {
+test("store.list/count visibility: explicit hard wall + auto/legacy pass, consistent totals", () => {
   const { store } = setup({ scopeEnabled: true, strictScope: true });
   store.save({ type: "decision", title: "g", content: "x" });
-  store.save({ type: "decision", title: "mine", content: "x", agent_scope: "me", workspace_scope: "D:\\p" });
-  store.save({ type: "decision", title: "theirs", content: "x", agent_scope: "other" });
-  store.save({ type: "decision", title: "other-ws", content: "x", workspace_scope: "D:\\q" });
+  store.save({ type: "decision", title: "mine", content: "x", agent_scope: "me", agent_scope_source: "explicit", workspace_scope: "D:\\p", workspace_scope_source: "explicit" });
+  store.save({ type: "decision", title: "theirs-explicit", content: "x", agent_scope: "other", agent_scope_source: "explicit" });
+  store.save({ type: "decision", title: "theirs-auto", content: "x", agent_scope: "other", agent_scope_source: "auto" });
+  store.save({ type: "decision", title: "theirs-legacy", content: "x", agent_scope: "other" });
+  store.save({ type: "decision", title: "other-ws-explicit", content: "x", workspace_scope: "D:\\q", workspace_scope_source: "explicit" });
 
   const vis = { agentScope: "me", workspaceScope: "D:\\p" };
   const titles = store.list({ visibility: vis }).map((m) => m.title).sort();
-  assert.deepEqual(titles, ["g", "mine"]);
-  assert.equal(store.count("decision", { visibility: vis }), 2);
+  assert.deepEqual(titles, ["g", "mine", "theirs-auto", "theirs-legacy"]);
+  assert.equal(store.count("decision", { visibility: vis }), 4);
 
-  // 匿名会话（维度解析不到）：只放行未标注行。
-  const anonTitles = store.list({ visibility: { agentScope: null, workspaceScope: null } }).map((m) => m.title);
-  assert.deepEqual(anonTitles, ["g"]);
+  // 匿名会话：explicit 行全出局，auto/存量/未标注放行。
+  const anonTitles = store.list({ visibility: { agentScope: null, workspaceScope: null } }).map((m) => m.title).sort();
+  assert.deepEqual(anonTitles, ["g", "theirs-auto", "theirs-legacy"]);
+  assert.equal(store.count("decision", { visibility: { agentScope: null, workspaceScope: null } }), 3);
 });
 
-test("injectCandidates hard-filters scoped rows when strictScope is on", () => {
+test("injectCandidates hard-filters explicit foreign rows when strictScope is on", () => {
   const { store, service } = setup({ scopeEnabled: true, strictScope: true });
   store.save({ type: "decision", title: "global", content: "x", importance: 4 });
-  store.save({ type: "decision", title: "foreign", content: "x", importance: 4, agent_scope: "other" });
+  store.save({ type: "decision", title: "foreign", content: "x", importance: 4, agent_scope: "other", agent_scope_source: "explicit" });
+  store.save({ type: "decision", title: "auto-foreign", content: "x", importance: 4, agent_scope: "other", agent_scope_source: "auto" });
 
   const injected = service.injectCandidates({
     maxItems: 5,
     threshold: 3,
     scope: { agent_scope: "me", workspace_scope: null }
   });
-  assert.deepEqual(injected.map((m) => m.title), ["global"]);
+  assert.deepEqual(injected.map((m) => m.title).sort(), ["auto-foreign", "global"]);
 
   // flag 下（scope 不传）→ 他 scope 照常注入（A2 前行为）。
   const unscoped = service.injectCandidates({ maxItems: 5, threshold: 3 });
-  assert.deepEqual(unscoped.map((m) => m.title).sort(), ["foreign", "global"]);
+  assert.deepEqual(unscoped.map((m) => m.title).sort(), ["auto-foreign", "foreign", "global"]);
+});
+
+test("memory_update/memory_delete hide explicit foreign-scope rows under strictScope (review item 4, aligned with memory_get)", async () => {
+  const { store, pick } = setupTools({ scopeEnabled: true, strictScope: true });
+  const theirs = store.save({ type: "pitfall", title: "theirs", content: "c", agent_scope: "other", agent_scope_source: "explicit" });
+  const autoTheirs = store.save({ type: "pitfall", title: "auto-theirs", content: "c", agent_scope: "other", agent_scope_source: "auto" });
+  const update = pick("memory_update");
+  const del = pick("memory_delete");
+
+  // explicit 他 scope：update 按不存在拒绝、delete 视作不存在——不能凭 id 直改直删。
+  await assert.rejects(() => runHandler(update, { id: theirs.id, content: "tampered" }, STRICT_EXEC), /memory not found/);
+  assert.equal(store.getById(theirs.id).content, "c", "row untouched by the rejected update");
+  const delOut = await runHandler(del, { id: theirs.id }, STRICT_EXEC);
+  assert.equal(delOut.deleted, false, "delete treats invisible rows as absent (no existence leak)");
+  assert.ok(store.getById(theirs.id), "row NOT deleted");
+
+  // auto 他 scope：不构成硬墙，照常可改（与 get 的可见性口径一致）。
+  const updAuto = await runHandler(update, { id: autoTheirs.id, content: "updated" }, STRICT_EXEC);
+  assert.equal(updAuto.memory.id, autoTheirs.id);
+
+  // 行主人自己照常可改。
+  const ownerOut = await runHandler(update, { id: theirs.id, content: "owner edit" }, OTHER_EXEC);
+  assert.equal(ownerOut.memory.id, theirs.id);
+
+  // strictScope 关：update/delete 不做可见性校验（管理语义回归）。
+  const { store: store2, pick: pick2 } = setupTools({ scopeEnabled: true });
+  const t2 = store2.save({ type: "pitfall", title: "theirs", content: "c", agent_scope: "other", agent_scope_source: "explicit" });
+  await runHandler(pick2("memory_update"), { id: t2.id, content: "edited" }, STRICT_EXEC);
+  assert.equal(store2.getById(t2.id).content, "edited");
+  const del2 = await runHandler(pick2("memory_delete"), { id: t2.id }, STRICT_EXEC);
+  assert.equal(del2.deleted, true);
 });
 
 function setupTools(config) {
@@ -121,17 +183,21 @@ async function runHandler(def, args, exec) {
 const STRICT_EXEC = { agent: { session: { id: "s1", header: { agentPreset: "me", cwd: "D:\\p" } } } };
 const OTHER_EXEC = { agent: { session: { id: "s2", header: { agentPreset: "other", cwd: "D:\\q" } } } };
 
-test("memory_get hides foreign-scope rows under strictScope, resolvable for the owner", async () => {
+test("memory_get hides explicit foreign-scope rows under strictScope, resolvable for the owner", async () => {
   const { store, pick } = setupTools({ scopeEnabled: true, strictScope: true });
-  const mine = store.save({ type: "pitfall", title: "mine", content: "c", agent_scope: "me" });
-  const theirs = store.save({ type: "pitfall", title: "theirs", content: "c", agent_scope: "other" });
+  const mine = store.save({ type: "pitfall", title: "mine", content: "c", agent_scope: "me", agent_scope_source: "explicit" });
+  const theirs = store.save({ type: "pitfall", title: "theirs", content: "c", agent_scope: "other", agent_scope_source: "explicit" });
+  const autoTheirs = store.save({ type: "pitfall", title: "auto-theirs", content: "c", agent_scope: "other", agent_scope_source: "auto" });
   const get = pick("memory_get");
 
   const out = await runHandler(get, { id: mine.id }, STRICT_EXEC);
   assert.equal(out.memory.title, "mine");
 
-  // 他 scope → 按不存在处理（无存在性泄漏）。
+  // explicit 他 scope → 按不存在处理（无存在性泄漏）。
   await assert.rejects(() => runHandler(get, { id: theirs.id }, STRICT_EXEC), /memory not found/);
+  // auto 他 scope → 可见（软加权不进硬过滤）。
+  const autoOut = await runHandler(get, { id: autoTheirs.id }, STRICT_EXEC);
+  assert.equal(autoOut.memory.title, "auto-theirs");
   // 行主人自己照常可取。
   const ownerOut = await runHandler(get, { id: theirs.id }, OTHER_EXEC);
   assert.equal(ownerOut.memory.title, "theirs");
@@ -139,17 +205,17 @@ test("memory_get hides foreign-scope rows under strictScope, resolvable for the
 
 test("memory_get without strictScope returns any row regardless of scope annotation", async () => {
   const { store, pick } = setupTools({ scopeEnabled: true });
-  const theirs = store.save({ type: "pitfall", title: "theirs", content: "c", agent_scope: "other" });
+  const theirs = store.save({ type: "pitfall", title: "theirs", content: "c", agent_scope: "other", agent_scope_source: "explicit" });
   const get = pick("memory_get");
   const out = await runHandler(get, { id: theirs.id }, STRICT_EXEC);
   assert.equal(out.memory.title, "theirs");
 });
 
-test("memory_list filters rows and keeps total consistent under strictScope", async () => {
+test("memory_list filters explicit rows and keeps total consistent under strictScope", async () => {
   const { store, pick } = setupTools({ scopeEnabled: true, strictScope: true });
   store.save({ type: "decision", title: "g", content: "x" });
-  store.save({ type: "decision", title: "mine", content: "x", agent_scope: "me" });
-  store.save({ type: "decision", title: "theirs", content: "x", agent_scope: "other" });
+  store.save({ type: "decision", title: "mine", content: "x", agent_scope: "me", agent_scope_source: "explicit" });
+  store.save({ type: "decision", title: "theirs", content: "x", agent_scope: "other", agent_scope_source: "explicit" });
   const list = pick("memory_list");
 
   const out = await runHandler(list, { type: "decision" }, STRICT_EXEC);
@@ -158,7 +224,7 @@ test("memory_list filters rows and keeps total consistent under strictScope", as
 
   // flag 关（A2 默认）：他 scope 的行照常出现在浏览视图。
   const { store: store2, pick: pick2 } = setupTools({ scopeEnabled: true });
-  store2.save({ type: "decision", title: "theirs", content: "x", agent_scope: "other" });
+  store2.save({ type: "decision", title: "theirs", content: "x", agent_scope: "other", agent_scope_source: "explicit" });
   const out2 = await runHandler(pick2("memory_list"), { type: "decision" }, STRICT_EXEC);
   assert.deepEqual(out2.items.map((m) => m.title), ["theirs"]);
   assert.equal(out2.total, 1);

package/test/skip-invalid-restore.test.js

@@ -151,17 +151,19 @@ test("validateDecisions skipInvalid: conflict without a distinct winner/loser is
 
 // ------------------------------------------------------- skipInvalid 与全局闸门
 
-test("validateDecisions skipInvalid: valid subset below the coverage floor still rejects the whole batch", () => {
+test("validateDecisions skipInvalid: valid subset below the coverage floor degrades (Issue #104 方向 1)", () => {
   const snap = makeSnap(["p", "j", "x"]);
   const decisions = [
     { action: "archive", ids: ["p"], reason: "stale" },
     { action: "merge", ids: ["p", "j"], keepSource: "p", title: "跨类型", content: "m", importance: 4 }
   ];
-  const { ok, errors, skipped } = validateDecisions(decisions, snap, { skipInvalid: true });
-  assert.equal(ok, false, "skip does not bypass the coverage floor");
+  const { ok, errors, skipped, coverageShortfall } = validateDecisions(decisions, snap, { skipInvalid: true });
+  assert.equal(ok, true, "valid subset applies — shortfall degrades instead of rejecting");
+  assert.deepEqual(errors, []);
   assert.equal(skipped.length, 1);
-  assert.ok(errors.some((e) => e.includes("coverage")), "coverage error present");
-  assert.equal(decisions.length, 2, "rejected batch left untouched (splice only on the success path)");
+  assert.match(String(coverageShortfall), /coverage/, "shortfall reason surfaced for audit");
+  // claimed {p} = 1/3 = 33% < 50%；j/x 隐式 keep 补齐
+  assert.deepEqual(decisions.map((d) => d.action), ["archive", "keep", "keep"]);
 });
 
 test("validateDecisions skipInvalid: updates skipped for other reasons do not count toward the update cap", () => {

package/test/sleep-scheduler-rearm.test.js

@@ -0,0 +1,89 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createSleepScheduler } from "../src/dream/sleep.js";
+
+// 回归（issue #187）：idle 计时器到点时若撞上 sleepMinIntervalHours（CD）未满，
+// maybeSchedule 返回 false 后没有任何东西重排——armIdleTimer 的回调把返回值丢掉、
+// idleTimer 已被置 null，"CD 到期"成了没有监听者的时刻，库里攒着待清理的新写入
+// 却什么都不发生，要等用户恰好再写一次才救回来。两个断言方向：
+//   1. 撞 CD 后必须按剩余窗口重排，CD 到点自行起跑；
+//   2. 调度器构造时就该挂表——重启后零写入也应有闹钟（同族缺陷：无表可 firing）。
+// 全程注入时钟/定时器，不依赖真实等待。
+
+function makeHarness(overrides = {}) {
+  let nowMs = 1_000_000;
+  const timers = [];
+  let seq = 1;
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  let runs = 0;
+  const sched = createSleepScheduler({
+    service,
+    config: { sleepModeEnabled: true, sleepIdleMinutes: 5, sleepMinIntervalHours: 1, ...overrides },
+    logger: { warn: () => {} },
+    onRun: async () => { runs++; return { ok: true }; },
+    now: () => nowMs,
+    setTimeoutFn: (fn, delay) => {
+      const t = { id: seq++, at: nowMs + delay, fn };
+      timers.push(t);
+      return t.id;
+    },
+    clearTimeoutFn: (id) => {
+      const i = timers.findIndex((t) => t.id === id);
+      if (i >= 0) timers.splice(i, 1);
+    }
+  });
+  // 触发最早到点的那个表；回调内部可能再挂新表，继续留在队列里等下一次触发。
+  const fireNext = async () => {
+    timers.sort((a, b) => a.at - b.at);
+    const t = timers.shift();
+    if (!t) throw new Error("no armed timer to fire");
+    nowMs = t.at;
+    await t.fn();
+  };
+  return {
+    sched,
+    store,
+    timers,
+    fireNext,
+    runs: () => runs,
+    now: () => nowMs,
+    write: () => { nowMs += 1000; sched.noteWrite(); }
+  };
+}
+
+test("sleep #187: CD collision re-arms a timer instead of dropping the round", async () => {
+  const h = makeHarness();
+  h.write();
+  await h.fireNext();
+  assert.equal(h.runs(), 1, "first run fires after the idle window");
+  const firstRunAt = h.now();
+
+  h.write(); // 落在 CD 窗口内的写入（默认 8h 时几乎必中）
+  await h.fireNext(); // idle 到点 → CD 未满 → 修复前：整轮被静默丢弃
+  assert.ok(h.timers.length > 0, "a timer must be re-armed after the CD collision");
+  await h.fireNext(); // 重排的表 → CD 到点 → 自行起跑
+  assert.equal(h.runs(), 2, "second run fires on its own at the CD boundary");
+  assert.ok(
+    h.now() >= firstRunAt + 3_600_000,
+    `second run must wait out the full min interval (fired at +${h.now() - firstRunAt}ms)`
+  );
+  h.store.close();
+});
+
+test("sleep #187: scheduler arms its first timer at construction (no write needed)", async () => {
+  const h = makeHarness();
+  assert.equal(h.timers.length, 1, "construction arms the idle timer");
+  await h.fireNext();
+  assert.equal(h.runs(), 1, "a quiet boot still reaches its first sleep cycle");
+  h.store.close();
+});
+
+test("sleep #187: dispose cancels the construction-armed timer", async () => {
+  const h = makeHarness();
+  await h.sched.dispose();
+  assert.equal(h.timers.length, 0, "dispose clears the armed timer");
+  h.store.close();
+});

package/test/sleep.test.js

@@ -165,8 +165,8 @@ test("sleep: dispose clears the timer and prevents further runs", async () => {
     setTimeoutFn: () => 1,
     clearTimeoutFn: () => { cleared = true; }
   });
-  sched.noteWrite(); // arm the idle timer so dispose has something to clear
-  assert.equal(cleared, false, "timer armed, not yet cleared");
+  // #187 起构造即挂表——dispose 必须能清掉这张（以及 noteWrite 重挂过的任何）表。
+  assert.equal(cleared, false, "timer armed at construction, not yet cleared");
   await sched.dispose();
   assert.equal(cleared, true, "idle timer cleared on dispose");
   assert.equal(sched.shouldRun(1_000_000 + 6 * 60000), false, "disposed never runs");

package/test/standalone-api.test.js

@@ -40,7 +40,7 @@ test("GET /health is open without a token; every other route 401s", async () =>
     assert.equal(health.status, 200);
     assert.deepEqual(await health.json(), { ok: true });
 
-    for (const path of ["/status", "/memories", "/memories/x", "/search?q=x"]) {
+    for (const path of ["/status", "/profile", "/rules", "/memories", "/memories/x", "/search?q=x"]) {
       const res = await fetch(`${base}${path}`);
       assert.equal(res.status, 401, `${path} requires a token`);
       assert.deepEqual(await res.json(), { error: "unauthorized" });
@@ -53,6 +53,39 @@ test("GET /health is open without a token; every other route 401s", async () =>
   }
 });
 
+test("GET /profile and /rules return saved settings", async () => {
+  const { base, auth, settings, close } = await setup();
+  try {
+    settings.setProfile("我是后端工程师");
+    settings.setRules(["先验证再修改", "默认使用中文回复"]);
+
+    const profile = await fetch(`${base}/profile`, { headers: auth });
+    assert.equal(profile.status, 200);
+    assert.deepEqual(await profile.json(), { profile: "我是后端工程师" });
+
+    const rules = await fetch(`${base}/rules`, { headers: auth });
+    assert.equal(rules.status, 200);
+    assert.deepEqual(await rules.json(), { rules: ["先验证再修改", "默认使用中文回复"] });
+  } finally {
+    close();
+  }
+});
+
+test("GET /profile and /rules return empty values when unset", async () => {
+  const { base, auth, close } = await setup();
+  try {
+    const profile = await fetch(`${base}/profile`, { headers: auth });
+    assert.equal(profile.status, 200);
+    assert.deepEqual(await profile.json(), { profile: "" });
+
+    const rules = await fetch(`${base}/rules`, { headers: auth });
+    assert.equal(rules.status, 200);
+    assert.deepEqual(await rules.json(), { rules: [] });
+  } finally {
+    close();
+  }
+});
+
 test("token is persisted into settings kv and reused across restarts", async () => {
   const store = createStore(":memory:");
   const service = createService({ store, mirror: null, config: {} });

package/test/store-vector-cache.test.js

@@ -0,0 +1,98 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+
+// 回归（issue #202）：检索路径的固定成本。此前 searchVector 每次调用
+// SELECT * 全表 + 逐行 JSON.parse（993 × 512 维 ≈ 48ms，余弦本身只占 3%），
+// all() 拖着 embedding 列（5k 行 ≈ 9.4MB）且 ORDER BY 无索引走临时 B 树。
+// 本批修复：updated_at 索引入 schema；all() 显式列清单排除 embedding；
+// searchVector 只取 id 列 + 解析缓存（setEmbedding 为单一失效点）+ Top-N 回表。
+
+function make() {
+  const store = createStore(":memory:");
+  return store;
+}
+
+test("#202: updated_at index is created on open (existing DBs included)", () => {
+  const store = make();
+  const row = store.db.prepare(
+    "SELECT name FROM sqlite_master WHERE type='index' AND name='idx_memories_updated'"
+  ).get();
+  assert.ok(row, "idx_memories_updated exists after open");
+  store.close();
+});
+
+test("#202: all() returns full rows (minus embedding) ordered by updated_at desc", () => {
+  const store = make();
+  store.save({ type: "project", title: "旧", content: "c1", importance: 3 });
+  store.save({ type: "decision", title: "新", content: "c2", importance: 3 });
+  const rows = store.all();
+  assert.equal(rows.length, 2);
+  assert.equal(rows[0].title, "新", "most recently updated first");
+  for (const row of rows) {
+    assert.equal(row.content?.length > 0, true, "content present");
+    assert.equal("embedding" in row, false, "embedding never leaks into row objects");
+  }
+  store.close();
+});
+
+test("#202: searchVector cache invalidates on setEmbedding rewrite", () => {
+  const store = make();
+  const { id } = store.save({ type: "project", title: "A", content: "a" });
+  store.setEmbedding(id, [1, 0, 0]);
+
+  // 第一次检索：缓存 v1（[1,0,0] 方向命中）
+  const hitV1 = store.searchVector([1, 0, 0], { limit: 5 });
+  assert.equal(hitV1[0]?.id, id, "v1 direction matches");
+
+  // 重写为正交向量后，旧方向必须不再命中、新方向命中——缓存失效点生效。
+  // （正交余弦=0，threshold=0 会连 0 分一起入选，所以用 0.5 的阈值区分。）
+  store.setEmbedding(id, [0, 1, 0]);
+  const hitStale = store.searchVector([1, 0, 0], { limit: 5, threshold: 0.5 });
+  assert.equal(hitStale.some((r) => r.id === id), false, "stale vector must not match after rewrite");
+  const hitV2 = store.searchVector([0, 1, 0], { limit: 5 });
+  assert.equal(hitV2[0]?.id, id, "new vector matches after rewrite");
+  store.close();
+});
+
+test("#202: setEmbedding(null) drops the row from vector search", () => {
+  const store = make();
+  const { id } = store.save({ type: "project", title: "A", content: "a" });
+  store.setEmbedding(id, [1, 0, 0]);
+  assert.equal(store.searchVector([1, 0, 0], { limit: 5 }).length, 1);
+  store.setEmbedding(id, null);
+  assert.equal(store.searchVector([1, 0, 0], { limit: 5 }).length, 0, "cleared embedding leaves the search set");
+  store.close();
+});
+
+test("#202: searchVector returns full memory rows with scores, sorted desc", () => {
+  const store = make();
+  const a = store.save({ type: "project", title: "标题A", content: "内容A", importance: 4 });
+  const b = store.save({ type: "decision", title: "标题B", content: "内容B", importance: 2 });
+  store.setEmbedding(a.id, [1, 0, 0]);
+  store.setEmbedding(b.id, [0.6, 0.8, 0]);
+
+  const hits = store.searchVector([1, 0, 0], { limit: 5 });
+  assert.equal(hits.length, 2);
+  assert.equal(hits[0].id, a.id, "closest vector first");
+  assert.ok(hits[0].score > hits[1].score, "descending scores");
+  for (const hit of hits) {
+    assert.ok(hit.title && hit.content, "full fields refetched for top hits");
+    assert.equal(typeof hit.score, "number");
+    assert.equal(hit.importance > 0, true, "non-score fields intact");
+  }
+  store.close();
+});
+
+test("#202: getParsedEmbedding / getEmbeddings reflect rewrites (dedup path cache)", () => {
+  const store = make();
+  const { id } = store.save({ type: "project", title: "A", content: "a" });
+  store.setEmbedding(id, [1, 2, 3]);
+  assert.deepEqual(store.getParsedEmbedding(id), [1, 2, 3]);
+  assert.deepEqual(store.getEmbeddings([id]).get(id), [1, 2, 3]);
+
+  store.setEmbedding(id, [4, 5, 6]);
+  assert.deepEqual(store.getParsedEmbedding(id), [4, 5, 6], "cache-first read sees the rewrite");
+  assert.deepEqual(store.getEmbeddings([id]).get(id), [4, 5, 6]);
+  store.close();
+});

package/test/tools-memory-get-schema.test.js

@@ -0,0 +1,65 @@
+// #184 回归：memory_get 的内联输出 schema 漏声明 v0.8.1 的 scope 来源三键
+// （agent_scope_source / workspace_scope_source / scope_decided_at），且
+// additionalProperties:false → toApiList 对被标注行条件展开这些键后，宿主
+// in-process 校验直接拒收（"invalid output"），表现为「个别 id 必失败、多数
+// 正常」。本文件用生产同款校验器（@deepseek-ai/dsh-tools 的
+// validateJsonSchemaValue）复现并防漂移；修复 = memory_get 复用与
+// list/search 共享的 MEMORY_ITEM_SCHEMA，不再维护内联副本。
+import test from "node:test";
+import assert from "node:assert/strict";
+import { validateJsonSchemaValue } from "@deepseek-ai/dsh-tools";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createTools, MEMORY_ITEM_SCHEMA } from "../src/tools.js";
+
+function setup() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const registered = [];
+  const ctx = {
+    tools: {
+      register(def) {
+        registered.push(def);
+        return () => {};
+      }
+    }
+  };
+  createTools(ctx, service, {}, undefined);
+  const byName = Object.fromEntries(registered.map((def) => [def.name, def]));
+  return { store, service, byName };
+}
+
+// memory_get.execute 的返回 = { memory: toApiList([getById(id)])[0] }——契约
+// 测试直接对「toApiList 产出的 DTO ↔ 声明的 output schema」做校验（DTO 键的
+// 唯一来源就是 toApiList，execute 只是包装）。
+test("memory_get output validates for fully scope-annotated rows (#184)", () => {
+  const { store, service, byName } = setup();
+  const saved = store.save({
+    type: "preference",
+    title: "annotated row",
+    content: "带全量 scope 来源标注的记忆行",
+    source: "test",
+    agent_scope: "coder",
+    agent_scope_source: "auto",
+    workspace_scope: "proj-alpha",
+    workspace_scope_source: "auto",
+    scope_decided_at: "2026-09-15T00:00:00Z"
+  });
+  const get = byName.memory_get;
+  const dto = service.toApiList([store.getById(saved.id)])[0];
+  const res = { memory: dto };
+  assert.deepEqual(validateJsonSchemaValue(get.output.schema, res), []);
+});
+
+test("memory_get item schema reuses MEMORY_ITEM_SCHEMA (no inline copy) (#184)", () => {
+  const { byName } = setup();
+  const get = byName.memory_get;
+  // defineTool 编译会克隆 schema，恒等不成立——断言键集与严格性同源。
+  const compiled = get.output.schema.properties.memory;
+  assert.deepEqual(
+    Object.keys(compiled.properties).sort(),
+    Object.keys(MEMORY_ITEM_SCHEMA.properties).sort()
+  );
+  assert.equal(compiled.additionalProperties, false);
+  assert.deepEqual(compiled.required.sort(), ["content", "created_at", "id", "importance", "title", "type", "updated_at"]);
+});