@modusensus/dsh-mneme 0.8.12 → 0.8.14

package/test/standalone-api.test.js

@@ -4,14 +4,15 @@ import { createStore } from "../src/store.js";
 import { createService } from "../src/service.js";
 import { createSettings } from "../src/settings.js";
 import { createStandaloneApi } from "../src/api-standalone.js";
+import { PACKAGE_VERSION } from "../src/version-check.js";
 import { Config, applyLightModePreset } from "../src/config.js";
 
 // Real HTTP server on an OS-assigned port (port: 0), driven with fetch.
-async function setup() {
+async function setup({ config = {}, embedder = null, embedTimeoutMs } = {}) {
   const store = createStore(":memory:");
-  const service = createService({ store, mirror: null, config: {} });
+  const service = createService({ store, mirror: null, config });
   const settings = createSettings(store.db);
-  const api = createStandaloneApi({ service, store, config: {}, settings, logger: null, port: 0 });
+  const api = createStandaloneApi({ service, store, config, settings, logger: null, port: 0, embedder, embedTimeoutMs });
   await api.ready;
   const base = `http://127.0.0.1:${api.port}`;
   const auth = { authorization: `Bearer ${api.token}` };
@@ -40,7 +41,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", "/profile", "/rules", "/memories", "/memories/x", "/search?q=x"]) {
+    for (const path of ["/status", "/profile", "/rules", "/memories", "/memories/x", "/search?q=x", "/context"]) {
       const res = await fetch(`${base}${path}`);
       assert.equal(res.status, 401, `${path} requires a token`);
       assert.deepEqual(await res.json(), { error: "unauthorized" });
@@ -249,7 +250,9 @@ test("GET /status reports version, per-type totals, entities and uptime", async
     const res = await fetch(`${base}/status`, { headers: auth });
     assert.equal(res.status, 200);
     const body = await res.json();
-    assert.equal(body.version, "0.7.12");
+    // 回归锁：/status 的版本必须来自 package.json（PACKAGE_VERSION），不是散落的
+    // 字面量——曾经此处硬编码常量在发版时漏 bump，运行 0.8.13 却对外报 0.7.12。
+    assert.equal(body.version, PACKAGE_VERSION);
     assert.equal(body.memories.total, 3);
     assert.equal(body.memories.byType.preference, 1);
     assert.equal(body.memories.byType.project, 2);
@@ -542,3 +545,207 @@ test("GET /search honors the occurred_at window", async () => {
     close();
   }
 });
+
+// --- GET /context（issue #370，#363 承诺）---------------------------------------
+
+/** /context 用例的省事入库：走 POST /memories，与第三方调用同路径。 */
+async function saveMemory(base, auth, body) {
+  const res = await fetch(`${base}/memories`, {
+    method: "POST",
+    headers: { ...auth, "content-type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  assert.ok(res.status === 201 || res.status === 200, `save ${body.title} → ${res.status}`);
+  return res.json();
+}
+
+test("GET /search passes a declared scope through (strictScope hard wall on the search face too)", async () => {
+  // issue #370：searchMemories 本就收 scope，8790 此前没有入口——透传后第三方
+  // 声明身份，A2 软加权与 strictScope 硬过滤在检索面同样成立；不传参数行为
+  // 与既往逐字节一致（scopeFromSearchParams 返回 undefined → 不进 options）。
+  const { base, auth, close } = await setup({ config: { strictScope: true } });
+  try {
+    await saveMemory(base, auth, { type: "decision", title: "他域检索", content: "外部线索 abc", importance: 5, agent_scope: "other-agent" });
+
+    const scoped = await (await fetch(`${base}/search?q=${encodeURIComponent("外部线索")}&agent_scope=me`, { headers: auth })).json();
+    assert.ok(!scoped.items.some((m) => m.title === "他域检索"), "explicit foreign agent_scope row is hard-filtered");
+
+    const unscoped = await (await fetch(`${base}/search?q=${encodeURIComponent("外部线索")}`, { headers: auth })).json();
+    assert.ok(unscoped.items.some((m) => m.title === "他域检索"), "no scope declared → gate dormant, behavior unchanged");
+  } finally {
+    close();
+  }
+});
+
+test("GET /context returns the injection-shaped aggregate; empty q still serves the rule tier", async () => {
+  const { base, auth, settings, close } = await setup();
+  try {
+    settings.setProfile("我是后端工程师");
+    settings.setRules(["先验证再修改"]);
+    await saveMemory(base, auth, { type: "decision", title: "核心决策", content: "选定 SQLite 单文件库", importance: 5 });
+    await saveMemory(base, auth, { type: "preference", title: "默认中文", content: "回复默认用中文", importance: 4 });
+
+    const res = await fetch(`${base}/context`, { headers: auth });
+    assert.equal(res.status, 200);
+    const body = await res.json();
+    // 形状锁：四键响应——bridge 等调用方按这四个键渲染，漂移（加塞/漏带）在此变红。
+    assert.deepEqual(Object.keys(body).sort(), ["items", "pinnedCount", "profile", "rules"]);
+    assert.equal(body.profile, "我是后端工程师");
+    assert.deepEqual(body.rules, ["先验证再修改"]);
+    assert.equal(body.pinnedCount, 0, "pinnedInjectBudget 默认 0（opt-in 纪律，issue #370 取舍 3）");
+    const titles = body.items.map((m) => m.title);
+    assert.ok(titles.includes("核心决策") && titles.includes("默认中文"), "empty q → pure rule tier, high-importance rows still served");
+    for (const item of body.items) {
+      assert.ok(item.id && item.type && item.title && typeof item.content === "string" && Number.isInteger(item.importance));
+    }
+  } finally {
+    close();
+  }
+});
+
+test("GET /context threshold is an importance gate (not /search's similarity threshold)", async () => {
+  // 同名不同义锁（issue #370 点名的文档区分）：/context 的 threshold 走
+  // injectCandidates 的 importance 门（summary/preference 豁免），与相似度无关
+  // ——本用例全程无 embedder/向量，纯规则档即可验证。
+  const { base, auth, close } = await setup();
+  try {
+    await saveMemory(base, auth, { type: "decision", title: "低重要", content: "小事一桩", importance: 3 });
+    await saveMemory(base, auth, { type: "decision", title: "高重要", content: "大事记", importance: 5 });
+
+    const open = await (await fetch(`${base}/context`, { headers: auth })).json();
+    const openTitles = open.items.map((m) => m.title);
+    assert.ok(openTitles.includes("低重要") && openTitles.includes("高重要"), "default threshold=3 admits both");
+
+    const gated = await (await fetch(`${base}/context?threshold=4`, { headers: auth })).json();
+    const gatedTitles = gated.items.map((m) => m.title);
+    assert.ok(gatedTitles.includes("高重要"), "importance 5 survives threshold=4");
+    assert.ok(!gatedTitles.includes("低重要"), "importance 3 is gated out at threshold=4");
+  } finally {
+    close();
+  }
+});
+
+test("GET /context pins preference rows ahead when pinnedInjectBudget is on", async () => {
+  // #249 pin 池经 8790 透出。用 preference 而非 constraint：constraint 属编码
+  // 记忆，非编码查询被 codingGate 排除在候选池外，pin 池也够不着它。
+  const { base, auth, close } = await setup({ config: { pinnedInjectBudget: 2 } });
+  try {
+    await saveMemory(base, auth, { type: "preference", title: "pin-偏好", content: "永远先讲结论", importance: 5 });
+    await saveMemory(base, auth, { type: "decision", title: "普通决策", content: "先做 A 再做 B", importance: 5 });
+
+    const body = await (await fetch(`${base}/context`, { headers: auth })).json();
+    assert.equal(body.items[0].title, "pin-偏好", "pinned row leads the block");
+    assert.equal(body.pinnedCount, 1);
+  } finally {
+    close();
+  }
+});
+
+test("GET /context honors a declared scope under strictScope; undeclared stays unfiltered", async () => {
+  // scope 语义锁（issue #370）：声明身份 → strictScope 硬过滤按 isVisibleInScope
+  // 生效；不声明 → scope=null，门不触发（与宿主「会话身份取不到时两维为 null」
+  // 同构）。任一维声明而另一维缺省时，缺维按解析不到走 fail-closed。
+  const { base, auth, close } = await setup({ config: { strictScope: true } });
+  try {
+    await saveMemory(base, auth, { type: "decision", title: "他域决策", content: "别的 agent 的事", importance: 5, agent_scope: "other-agent" });
+    await saveMemory(base, auth, { type: "decision", title: "全域决策", content: "谁都可见", importance: 5 });
+
+    const declared = await (await fetch(`${base}/context?agent_scope=me`, { headers: auth })).json();
+    const declaredTitles = declared.items.map((m) => m.title);
+    assert.ok(!declaredTitles.includes("他域决策"), "explicit foreign agent_scope row is hard-filtered");
+    assert.ok(declaredTitles.includes("全域决策"));
+
+    const undeclared = await (await fetch(`${base}/context`, { headers: auth })).json();
+    const undeclaredTitles = undeclared.items.map((m) => m.title);
+    assert.ok(undeclaredTitles.includes("他域决策"), "no declared scope → no gate");
+  } finally {
+    close();
+  }
+});
+
+test("GET /context embeds the query via the injected embedder (wiring lock)", async () => {
+  // embedder 接线锁（issue #370）：createStandaloneApi 新增的可选 embedder 必须
+  // 真被 /context 用上——宿主与 daemon 传的都是 semantic 装配的同一实例。
+  const calls = [];
+  const fake = {
+    ready: true,
+    modelHash: "fake-hash-1",
+    dimension: 4,
+    embedSingle: async (text) => {
+      calls.push(text);
+      return [1, 0, 0, 0];
+    }
+  };
+  const { base, auth, close } = await setup({ embedder: fake });
+  try {
+    const res = await fetch(`${base}/context?q=${encodeURIComponent("语义查询")}`, { headers: auth });
+    assert.equal(res.status, 200);
+    await res.json();
+    assert.deepEqual(calls, ["语义查询"], "the route must hand the query to the injected embedder");
+  } finally {
+    close();
+  }
+});
+
+test("GET /context survives a throwing embedder (rule-tier degradation, never 500)", async () => {
+  const { base, auth, close } = await setup({
+    embedder: { ready: true, embedSingle: async () => { throw new Error("model offline"); } }
+  });
+  try {
+    await saveMemory(base, auth, { type: "decision", title: "降级存照", content: "嵌入挂了也要有注入", importance: 5 });
+    const res = await fetch(`${base}/context?q=任意`, { headers: auth });
+    assert.equal(res.status, 200, "embed failure must degrade to the rule tier");
+    const body = await res.json();
+    assert.ok(body.items.some((m) => m.title === "降级存照"));
+  } finally {
+    close();
+  }
+});
+
+test("GET /context times out a hung embedder and degrades (embedTimeoutMs guard)", async () => {
+  // CodeRabbit on #371：embedder 挂起（不抛错，典型为第三方 ollama/openai 端点
+  // 无响应）不能占住 HTTP 连接——超时按嵌入缺失降级规则档。测试用 50ms 短超时
+  // 避免慢测试；生产默认 3000 由工厂选项约束（同 strictPort，不进 config schema）。
+  const { base, auth, close } = await setup({
+    embedTimeoutMs: 50,
+    embedder: { ready: true, embedSingle: () => new Promise(() => {}) }
+  });
+  try {
+    await saveMemory(base, auth, { type: "decision", title: "挂起存照", content: "嵌入悬挂也要有注入", importance: 5 });
+    const started = Date.now();
+    const res = await fetch(`${base}/context?q=任意`, { headers: auth });
+    assert.equal(res.status, 200, "hung embedder must not hang the route");
+    const body = await res.json();
+    assert.ok(body.items.some((m) => m.title === "挂起存照"), "timed-out embed falls back to the rule tier");
+    assert.ok(Date.now() - started < 3000, "response must not wait on the hung embedder");
+  } finally {
+    close();
+  }
+});
+
+test("strictPort: busy port rejects instead of hopping; default path still hops", async () => {
+  // daemon 语义锁(#363):strictPort 下配置端口被占 = 配置错误,明确失败 ——
+  // 顺延会让把 URL 写死的第三方客户端静默打到错误端口。占口用裸 net server
+  // (OS 分配,不与并行测试抢固定号)。
+  const { default: net } = await import("node:net");
+  const blocker = net.createServer();
+  await new Promise((resolve) => blocker.listen(0, "127.0.0.1", resolve));
+  const busyPort = blocker.address().port;
+
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  try {
+    const strict = createStandaloneApi({ service, store, config: {}, settings, logger: null, port: busyPort, strictPort: true });
+    await assert.rejects(strict.ready, (err) => err?.code === "EADDRINUSE");
+
+    // 默认路径(不传 strictPort)行为不变:顺延成功;具体端口不断言(避免抢号)。
+    const hopping = createStandaloneApi({ service, store, config: {}, settings, logger: null, port: busyPort });
+    await hopping.ready;
+    assert.notEqual(hopping.port, busyPort, "default policy hops off a busy port");
+    hopping.server.close();
+  } finally {
+    blocker.close();
+    store.close();
+  }
+});

package/test/write-admission.test.js

@@ -17,6 +17,12 @@ import {
   ADMISSION_TRIGGER_SOURCE
 } from "../src/write-admission.js";
 import { POSITIVE_SAMPLES, NEGATIVE_SAMPLES, SAMPLE_VALUES, referenceScan } from "./helpers/write-admission-samples.js";
+// #164 A2 的真判据 + 真配置：这一组测的是**接线**（index.js 那条路径的等价物），
+// 判据自己的验收在 test/sensitive-scan.test.js。config 用真 schema 而不是手搓对象，
+// 钉住「键名/嵌套形状与生产一致」——手搓的 `{ sensitiveScanEnabled: true }` 在键名
+// 写错时照样过，真 config 才会红。
+import { Config } from "../src/config.js";
+import { createSensitiveScan } from "../src/sensitive-scan.js";
 
 // #254 写入准入（第一阶段：只计量，不拦截）。
 // 本批次没有阈值、没有拦截分支，验收看两件事：默认路径零行为变化（无会话身份的
@@ -551,3 +557,112 @@ test("接线：被拒时 memory_save 返回 action=denied 与可行动的 reason
   assert.ok(ok.id, "正常路径仍然返回 id");
 });
 
+// --- #164 A2 接线：判据自己的闸 × 闸门的 enforce -------------------------------
+// 这一组是 index.js 那条装配路径的等价物：真 config（Config({})）+ createSensitiveScan
+// 工厂 + 写入准入。三层开关的语义由此钉住——判据关（默认）不参与、判据开而 enforce 关
+// 只留审计、两个都开才拦。判据本身的假阳/漏放验收在 test/sensitive-scan.test.js。
+
+/** 用真 `Config` 解析默认值，再叠加测试要覆盖的那几个键。 */
+function a2Store(overrides = {}) {
+  const cfg = Config(overrides);
+  const store = createStore(":memory:");
+  const writeAdmission = createWriteAdmission({
+    store,
+    config: cfg,
+    sensitiveScan: createSensitiveScan({ config: cfg })
+  });
+  const service = createService({ store, mirror: null, config: cfg, writeAdmission });
+  return { store, service, cfg };
+}
+
+const SECRET_ROW = {
+  type: "project",
+  title: "调试记录",
+  content: `临时代码里贴了 ${SAMPLE_VALUES.githubPat}，回头删掉`
+};
+
+test("A2 默认关：写有密钥的行照常落库，且连拒绝面都不该出现", () => {
+  const { store, service } = a2Store();
+  const result = service.saveWithDedupe({ ...SECRET_ROW, _sessionKey: "s" });
+  assert.equal(result.action, "created", "判据默认关时这条路径与 #332 逐字段一致");
+  assert.equal(rowCount(store), 1);
+  // metadata 里不该多出任何 deny/decision 键——「默认关零行为变化」是验收第 1 条，
+  // 多一个恒为 allow 的键就把它从事实变成需要解释的说法（同上面 #254 那条）。
+  const row = admissionRows(store, "s")[0];
+  assert.equal(row.metadata.deny, undefined);
+  assert.equal(row.metadata.decision, undefined);
+});
+
+test("A2 观察档：判据开、enforce 关 → 写入照常，审计行带 kind 与 enforced=false", () => {
+  const { store, service } = a2Store({ sensitiveScanEnabled: true, writeAdmission: { enabled: true } });
+  const result = service.saveWithDedupe({ ...SECRET_ROW, _sessionKey: "s" });
+  assert.equal(result.action, "created", "#164 口径：默认仅告警");
+  assert.equal(rowCount(store), 1);
+  const deny = admissionRows(store, "s")[0].metadata.deny;
+  assert.equal(deny.reason, "sensitive");
+  assert.equal(deny.kind, "github_token");
+  assert.equal(deny.enforced, false, "仅告警档的指纹：deny 非空、enforced=false、写入仍发生");
+});
+
+test("A2 拦截档：判据开 + enforce 开 → 拒了、没落库、审计标 enforced", () => {
+  const { store, service } = a2Store({
+    sensitiveScanEnabled: true,
+    writeAdmission: { enabled: true, enforce: true }
+  });
+  const result = service.saveWithDedupe({ ...SECRET_ROW, _sessionKey: "s" });
+  assert.equal(result.action, "denied");
+  assert.equal(result.reason, "sensitive");
+  assert.equal(rowCount(store), 0, "被拒的写入一条都不该落库");
+  const deny = admissionRows(store, "s")[0].metadata.deny;
+  assert.equal(deny.kind, "github_token");
+  assert.equal(deny.enforced, true);
+});
+
+test("A2 与第 1 级空白判据互不依赖：只开 A2 不会把空白写入拦下", () => {
+  // 两个键是两批判据的闸（空白/噪声 vs 密钥/PII），分开是为了能单独观察 A2 的
+  // 命中分布——绑在一个开关上就没法只看这一类的假阳率。
+  const { store, service } = a2Store({ sensitiveScanEnabled: true });
+  const blank = service.saveWithDedupe({ _sessionKey: "s", type: "project", title: "...", content: "" });
+  assert.equal(blank.action, "created", "A2 开着不等于第 1 级判据也开");
+  assert.equal(admissionRows(store, "s")[0].metadata.deny, undefined);
+  // 反过来：只开第 1 级（writeAdmission.enabled）、A2 关，密钥行照常落库。
+  const { store: s2, service: svc2 } = a2Store({ writeAdmission: { enabled: true } });
+  assert.equal(svc2.saveWithDedupe({ ...SECRET_ROW, _sessionKey: "s" }).action, "created");
+  assert.equal(s2.list({ limit: 10 }).length, 1);
+});
+
+test("A2 跑在闸门里：只开 sensitiveScanEnabled（闸门关）时扫描器根本不参与", () => {
+  // 判据的唯一调用点是 write-admission 的 firstLevelHit，而闸门要
+  // writeAdmission.enabled 打开才走第 1 级判据。所以「本键开着」不等于「会扫」——
+  // 配置注释与面板文案都按这条写，否则用户以为单开本键就能拿到 A2 的命中分布。
+  const { store, service } = a2Store({ sensitiveScanEnabled: true });
+  const result = service.saveWithDedupe({ ...SECRET_ROW, _sessionKey: "s" });
+  assert.equal(result.action, "created", "闸门没开时 A2 不参与判定");
+  assert.equal(rowCount(store), 1, "写入照常落库");
+  const rows = admissionRows(store, "s");
+  assert.ok(rows.length > 0, "闸门仍走计量路径（去重 / g2 不受第 1 级开关影响）");
+  assert.ok(rows.every((row) => row.metadata.deny === undefined), "一条 deny 审计都没有：第 1 级判据整体没跑");
+});
+
+test("A2 负样本在真装配下一条都不误杀（含敏感词但没有值）", () => {
+  const { store, service } = a2Store({
+    sensitiveScanEnabled: true,
+    writeAdmission: { enabled: true, enforce: true }
+  });
+  for (const sample of NEGATIVE_SAMPLES) {
+    const result = service.saveWithDedupe({
+      _sessionKey: `sess-${sample.id}`,
+      type: "project",
+      title: sample.title,
+      content: sample.content
+    });
+    assert.equal(result.action, "created", `${sample.id} 被误杀（${sample.why}）`);
+  }
+  assert.equal(rowCount(store), NEGATIVE_SAMPLES.length);
+  for (const sample of NEGATIVE_SAMPLES) {
+    for (const row of admissionRows(store, `sess-${sample.id}`)) {
+      assert.equal(row.metadata.deny, undefined, `${sample.id} 不该带任何拒绝面`);
+    }
+  }
+});
+