@modusensus/dsh-mneme 0.8.13 → 0.8.14

package/test/scope-strict.test.js

@@ -316,6 +316,30 @@ test("entity: / attr: 的 scope 闸在触达之前：出局的行不被回温，
   assert.equal(store.getById(theirs.id).last_accessed_at ?? null, null, "出局行不该被回温");
 });
 
+test("injectCandidates：strictScope 硬过滤必须晚于图召回合并（graphHint 不能把出局行带回来）", async () => {
+  // 回归锁（CodeRabbit on #371 的可达性分析，#17 A3 的图召回分支）：entityRecall
+  // 本身不做 scope 门控，硬过滤原本长在图合并**之前**——过滤出局的显式他域行会
+  // 被图召回重新打上 graphHint 带回候选池，graphInjectHint 开时即作为线索行进入
+  // 注入块（宿主注入与 /context 同受影响）。硬过滤移到图合并之后、pin 池之前封死。
+  // 夹具注意：只挂 theirs 一条——挂满全 battery 会让每行都成 graphHint 行、被
+  // graphInjectBudget=1 的线索预算挤到失真（写这条测试时踩过）。
+  const { store, service } = setup({
+    scopeEnabled: true, strictScope: true, entityRecallEnabled: true, graphInjectHint: true
+  });
+  const rows = saveScopeBattery(store);
+  linkToEntity(store, "阿尔托", [rows.theirs]);
+
+  const asMe = service.injectCandidates({ query: "阿尔托", maxItems: 5, scope: { agent_scope: "me", workspace_scope: null } });
+  const titles = asMe.map((m) => m.title);
+  assert.ok(!titles.includes("theirs"), "图召回不得把显式他域行带进注入块");
+  assert.ok(titles.includes("global"), "未挂联的可见行照常经规则路进块（排除真空假绿）");
+
+  // 正向对照：原主人自己取，显式行仍在（作为线索行或普通行均可——否则是
+  // 「谁都看不到」的假绿）。
+  const asOther = service.injectCandidates({ query: "阿尔托", maxItems: 5, scope: { agent_scope: "other", workspace_scope: null } });
+  assert.ok(asOther.some((m) => m.title === "theirs"), "命中当前 agent 的显式行必须可见");
+});
+
 test("scope 闸先于 topK 截断：出局的候选不占名额（topK=1 仍有可见结果）", async () => {
   // 回归锁（评审发现）：先 slice 再 filter 的话，排在前面那条被闸掉的候选会占住唯一的
   // 槽位，明明还有可见匹配却返回空数组。用 topK=1 把次序钉死——排序不动，只是闸门要插

package/test/serve-bin.test.js

@@ -0,0 +1,121 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createSettings } from "../src/settings.js";
+
+// serve bin 冒烟 + 多进程共存锁(daemon 唯一的真新风险点):daemon 子进程与测试进程
+// 同时打开同一 memory.db(WAL + busy_timeout 本就为此设计),互写互读。spawn 必须
+// 异步(maintenance.test.js 的教训:同步 spawn 会堵住本进程事件循环);Windows 下
+// child.kill() 是硬终止,不断言信号路径,只断言可达性与退出。
+
+const BIN = fileURLToPath(new URL("../bin/dsh-mneme-serve.mjs", import.meta.url));
+
+function wait(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+async function waitFor(fn, timeoutMs, what) {
+  const deadline = Date.now() + timeoutMs;
+  let lastErr;
+  while (Date.now() < deadline) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+    }
+    await wait(150);
+  }
+  throw new Error(`timeout waiting for ${what}: ${lastErr?.message ?? lastErr}`);
+}
+
+test("serve bin: 值旗标缺值直接报错退出(--port 后无值不能落成 Number(true)=1)", { timeout: 30000 }, async () => {
+  // CodeRabbit on #364:--port 紧跟另一个旗标或结束时,旧解析把它存成 true,
+  // Number(true)=1 通过校验 → 静默改绑端口 1(EACCES 误导排错方向)。
+  const child = spawn(process.execPath, [BIN, "--memory-dir", mkdtempSync(join(tmpdir(), "mneme-serve-arg-")), "--port"], {
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  let stderr = "";
+  child.stderr.on("data", (d) => { stderr += d; });
+  const [code] = await new Promise((resolve) => {
+    child.on("exit", (c) => resolve([c]));
+  });
+  assert.notEqual(code, 0, "missing value must exit non-zero");
+  assert.ok(stderr.includes("缺少参数值"), `stderr should name the missing value, got: ${stderr.slice(-200)}`);
+});
+
+test("serve bin: spawn 冒烟;daemon 与宿主进程同库互写互读", { timeout: 120000 }, async () => {
+  const dir = mkdtempSync(join(tmpdir(), "mneme-serve-bin-"));
+
+  // 预置 token:测试进程先开一次库写进 kv external_api,daemon 复用之 —— 同时验证
+  // 「与宿主面板/CLI 共用同一凭证」这条零配置承诺在真子进程里成立。
+  const seedStore = createStore(join(dir, "memory.db"));
+  const seedSettings = createSettings(seedStore.db);
+  const TOKEN = "serve-bin-test-token-0123456789abcdef";
+  seedSettings.setExternalApi({ token: TOKEN });
+  const peer = createService({ store: seedStore, mirror: null, config: {} });
+  peer.saveWithDedupe({ type: "project", title: "peer 进程直写", content: "测试进程经 createStore 写入", importance: 3 });
+
+  // --embed off:CI 无 runtime payload,绝不能触发取件;多进程共存与语义无关
+  const child = spawn(process.execPath, [BIN, "--memory-dir", dir, "--port", "0", "--embed", "off"], {
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  let stdout = "";
+  let stderr = "";
+  child.stdout.on("data", (d) => { stdout += d; });
+  child.stderr.on("data", (d) => { stderr += d; });
+
+  try {
+    // stdout 唯一机器可读行:listening 行(解析实际端口)
+    await waitFor(() => {
+      if (child.exitCode !== null) {
+        throw new Error(`daemon exited early (code ${child.exitCode}): ${stderr.slice(-400)}`);
+      }
+      if (!stdout.includes("listening on http://")) throw new Error("no listening line yet");
+      return true;
+    }, 20000, "listening line");
+    const port = Number(stdout.match(/:(\d+)/)[1]);
+    const base = `http://127.0.0.1:${port}`;
+    const auth = { authorization: `Bearer ${TOKEN}` };
+
+    await waitFor(async () => {
+      const res = await fetch(`${base}/health`);
+      assert.equal(res.status, 200);
+      return true;
+    }, 10000, "daemon /health");
+
+    // 双向可见性 ①:测试进程直写 → daemon HTTP 检索可见
+    await waitFor(async () => {
+      const res = await fetch(`${base}/search?q=${encodeURIComponent("peer 进程直写")}`, { headers: auth });
+      assert.equal(res.status, 200);
+      const body = await res.json();
+      assert.ok((body.items ?? []).some((m) => m.title === "peer 进程直写"));
+      return true;
+    }, 10000, "peer write visible via daemon");
+
+    // 双向可见性 ②:daemon HTTP 写 → 测试进程 service 同步检索可见
+    const save = await fetch(`${base}/memories`, {
+      method: "POST",
+      headers: { ...auth, "content-type": "application/json" },
+      body: JSON.stringify({ type: "project", title: "daemon HTTP 写入", content: "serve 进程经数据面写入", importance: 3 })
+    });
+    assert.ok(save.status === 201 || save.status === 200, `daemon save status ${save.status}`);
+    assert.ok(
+      peer.search("daemon HTTP 写入", { limit: 5 }).some((m) => m.title === "daemon HTTP 写入"),
+      "daemon-side write must be visible to the other process immediately"
+    );
+  } finally {
+    child.kill();
+    await new Promise((r) => {
+      if (child.exitCode !== null) r();
+      else child.on("exit", r);
+    });
+    try { seedStore.close(); } catch { /* 同上 */ }
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* win 文件锁偶发,残留临时目录无害 */ }
+  }
+});

package/test/serve.test.js

@@ -0,0 +1,196 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createServeRuntime } from "../src/serve.js";
+
+// daemon 装配面锁(test/serve-bin.test.js 另有真子进程 + 多进程共存):
+// in-process 起真 HTTP(port 0,OS 分配),fetch 走 health / 401 / save / search /
+// token 持久化复用全链路。锁的是「daemon 数据面 = api-standalone 同一工厂」这一契约。
+// 基础用例一律 embed:"off"——不碰取件与模型 init,CI 确定性;向量走注入假 embedder。
+
+function tmpDir() {
+  return mkdtempSync(join(tmpdir(), "mneme-serve-"));
+}
+
+/** 确定性 4 维伪嵌入:同词相关、异词近正交,足以让向量路径产生非零命中。 */
+function fakeEmbedder() {
+  return {
+    ready: true,
+    modelHash: "fake-hash-1",
+    dimension: 4,
+    embedSingle: async (text) => {
+      const v = [0, 0, 0, 0];
+      for (let i = 0; i < text.length; i++) v[i % 4] += text.charCodeAt(i) % 7;
+      const n = Math.hypot(v[0], v[1], v[2], v[3]) || 1;
+      return v.map((x) => x / n);
+    }
+  };
+}
+
+async function waitFor(fn, timeoutMs, what) {
+  const deadline = Date.now() + timeoutMs;
+  let lastErr;
+  while (Date.now() < deadline) {
+    try { return await fn(); } catch (err) { lastErr = err; }
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  throw new Error(`timeout waiting for ${what}: ${lastErr?.message ?? lastErr}`);
+}
+
+test("serve: /health 免鉴权,业务路由无 token 401", async () => {
+  const dir = tmpDir();
+  const rt = await createServeRuntime({ memoryDir: dir, port: 0, embed: "off" });
+  await rt.api.ready;
+  try {
+    const base = `http://127.0.0.1:${rt.api.port}`;
+    const health = await fetch(`${base}/health`);
+    assert.equal(health.status, 200);
+    assert.deepEqual(await health.json(), { ok: true });
+
+    const noAuth = await fetch(`${base}/search?q=x`);
+    assert.equal(noAuth.status, 401);
+    assert.deepEqual(await noAuth.json(), { error: "unauthorized" });
+  } finally {
+    rt.dispose();
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* win 文件锁偶发 */ }
+  }
+});
+
+test("serve: save → search 走通;token 持久化 kv;二次启动复用同一 token;检索回执落 recall_runs", async () => {
+  const dir = tmpDir();
+  const rt = await createServeRuntime({ memoryDir: dir, port: 0, embed: "off" });
+  await rt.api.ready;
+  const base = `http://127.0.0.1:${rt.api.port}`;
+  const auth = { authorization: `Bearer ${rt.api.token}` };
+
+  // 全新目录:首次启动生成 token
+  assert.equal(rt.tokenExisted, false);
+
+  const save = await fetch(`${base}/memories`, {
+    method: "POST",
+    headers: { ...auth, "content-type": "application/json" },
+    body: JSON.stringify({ type: "preference", title: "serve 冒烟偏好", content: "回复保持简短", importance: 4 })
+  });
+  assert.equal(save.status, 201);
+
+  const search = await fetch(`${base}/search?q=${encodeURIComponent("简短")}`, { headers: auth });
+  assert.equal(search.status, 200);
+  const searchBody = await search.json();
+  assert.ok((searchBody.items ?? []).some((m) => m.title === "serve 冒烟偏好"));
+
+  // token 持久化在 kv external_api(与 DSH 面板/CLI 共用同一凭证通道)
+  assert.equal(rt.settings.getExternalApi().token, rt.api.token);
+
+  // 检索回执:recorder 已接(index.js:294-309 同款),recall_runs 不缺数 —— #363 回帖
+  // 向 bridge 承诺过「第三方检索的复用统计不受影响」,这条就是该承诺的回归锁。
+  const recallRows = rt.store.db.prepare("SELECT COUNT(*) AS n FROM recall_runs").get();
+  assert.ok(recallRows.n >= 1, "recall_runs should record the search above");
+
+  rt.dispose();
+
+  // 二次启动同目录:token 复用不重新生成(firstBoot 提示只在真正首次出现)
+  const rt2 = await createServeRuntime({ memoryDir: dir, port: 0, embed: "off" });
+  await rt2.api.ready;
+  try {
+    assert.equal(rt2.tokenExisted, true);
+    assert.equal(rt2.api.token, rt.api.token);
+  } finally {
+    rt2.dispose();
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* 同上 */ }
+  }
+});
+
+test("serve: dispose 后端口可复用(同端口连起两轮不踩 strictPort)", async () => {
+  const dir = tmpDir();
+  const rt = await createServeRuntime({ memoryDir: dir, port: 0, embed: "off" });
+  await rt.api.ready;
+  const port = rt.api.port;
+  // dispose 现为 async:等 server.close 回调(在途请求排干)后再重绑
+  await rt.dispose();
+  // 端口释放可能有内核级迟滞,重试绑定而不是假设立即可用
+  let rebound = null;
+  for (let i = 0; i < 10 && !rebound; i++) {
+    try {
+      const rt2 = await createServeRuntime({ memoryDir: dir, port, embed: "off" });
+      await rt2.api.ready;
+      rebound = rt2;
+    } catch (err) {
+      if (err?.code !== "EADDRINUSE") throw err;
+      await new Promise((r) => setTimeout(r, 100));
+    }
+  }
+  try {
+    assert.ok(rebound, "port should be rebindable after dispose");
+    assert.equal(rebound.api.port, port);
+  } finally {
+    await rebound?.dispose();
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* 同上 */ }
+  }
+});
+
+test("serve: 注入假 embedder → 写入即嵌入,vector 轴接管检索;auto 检索可用", async () => {
+  const dir = tmpDir();
+  const fake = fakeEmbedder();
+  const rt = await createServeRuntime({ memoryDir: dir, port: 0, embed: "off", embedder: fake });
+  await rt.api.ready;
+  try {
+    // 覆盖注入生效:semantic 被绕过,embedder 直接挂 service
+    assert.equal(rt.semantic, null);
+
+    const base = `http://127.0.0.1:${rt.api.port}`;
+    const auth = { authorization: `Bearer ${rt.api.token}` };
+    const save = await fetch(`${base}/memories`, {
+      method: "POST",
+      headers: { ...auth, "content-type": "application/json" },
+      body: JSON.stringify({ type: "project", title: "向量注入冒烟", content: "daemon 侧写入即嵌入", importance: 3 })
+    });
+    assert.equal(save.status, 201);
+
+    // 写入侧嵌入是异步排队的:轮询到 vector 轴命中为止。auto 模式不断言 mode 字段 ——
+    // 标题同词命中时融合合并对象是 keyword 行,上游 mneme 的 auto 报告语义如此
+    // (vector:true 标记只在纯向量来源上保留),那是上游行为,不是 daemon 契约。
+    await waitFor(async () => {
+      const res = await fetch(`${base}/search?q=${encodeURIComponent("向量注入冒烟")}&mode=vector`, { headers: auth });
+      assert.equal(res.status, 200);
+      const body = await res.json();
+      assert.equal(body.mode, "vector", "mode=vector must report the vector axis");
+      assert.ok((body.items ?? []).some((m) => m.title === "向量注入冒烟"));
+      return true;
+    }, 8000, "vector-axis search");
+
+    const autoRes = await fetch(`${base}/search?q=${encodeURIComponent("向量注入冒烟")}&mode=auto`, { headers: auth });
+    assert.equal(autoRes.status, 200);
+    assert.ok(((await autoRes.json()).items ?? []).some((m) => m.title === "向量注入冒烟"));
+
+    // /context 全链路（issue #370）：daemon 与宿主外部访问共用同一工厂，注入
+    // 候选端点一并带出——同一 embedder 句柄喂查询向量，injectCandidates 走通。
+    const ctxRes = await fetch(`${base}/context?q=${encodeURIComponent("向量注入冒烟")}`, { headers: auth });
+    assert.equal(ctxRes.status, 200);
+    const ctxBody = await ctxRes.json();
+    assert.ok((ctxBody.items ?? []).some((m) => m.title === "向量注入冒烟"));
+    // #217 注入分账：injectCandidates 的曝光型访问事件落 recall_runs
+    // （mode='inject'），第三方的注入统计与宿主注入同表同口径。
+    const injectRuns = rt.store.db.prepare("SELECT count(*) AS c FROM recall_runs WHERE mode = 'inject'").get().c;
+    assert.ok(injectRuns >= 1, "injection access must be receipted in recall_runs (#217)");
+  } finally {
+    rt.dispose();
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* 同上 */ }
+  }
+});
+
+test("serve: 非法 embed provider 拒装配;embed=off 时 semantic 为 null", async () => {
+  const dir = tmpDir();
+  await assert.rejects(
+    createServeRuntime({ memoryDir: dir, port: 0, embed: "bogus" }),
+    /invalid embed provider/
+  );
+  const rt = await createServeRuntime({ memoryDir: dir, port: 0, embed: "off" });
+  try {
+    assert.equal(rt.semantic, null, "off path must not assemble a semantic pipeline");
+  } finally {
+    rt.dispose();
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* 同上 */ }
+  }
+});

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();
+  }
+});