@modusensus/dsh-mneme 0.8.16 → 0.9.0

package/test/client.test.js

@@ -839,8 +839,9 @@ test("stale route values are marked and explained at the row level (issue #191)"
     "the en stale hint must cover provider-absence too, not only the model case"
   );
   // 4. issue #215：三条路由各自透传自己的档位键——routeSelects 按路由行
-  // 传入键名、从生效配置取值；sleep 无回退重试，档位被拒时测试是事前唯一
-  // 的暴露口。
+  // 传入键名、从生效配置取值。（曾在此断言「sleep 无回退重试，测试是事前
+  // 唯一的暴露口」：该前提自 939fbfc 起就不成立——sleep/梦/蒸馏都走
+  // withEffortFallback，档位被拒会丢字段重试，测试从不是唯一暴露口。）
   assert.ok(
     /const routeSelects = \(providerKey, modelKey, testState, setTestState, effortKey\) => \{/.test(clientSource)
       && /const effort = effortKey \? \(eff\[effortKey\] \|\| ""\) : ""/.test(clientSource),
@@ -860,6 +861,31 @@ test("stale route values are marked and explained at the row level (issue #191)"
   );
 });
 
+// 探针降级的如实呈现（issue #215 后续）：后端档位被拒时不再 502，而是丢字段
+// 重试成功 + effortDropped:true。面板必须把「连通了、但不是按你配的档位」讲出来
+// ——静默成功和静默失败一样有害：前者让人以为档位生效，后者把人赶去换 Provider。
+test("panel surfaces a downgraded connectivity test instead of a silent success or a red failure", () => {
+  // 1. 只有后端明确置位才算降级（旧后端无字段 → 不误报）
+  assert.ok(
+    /dropped: j\.effortDropped === true/.test(clientSource),
+    "the panel must read effortDropped strictly (=== true) so an older backend never renders a phantom downgrade"
+  );
+  // 2. 降级文案只在成功行追加，失败行不得出现（失败就是失败，别混进降级措辞）
+  assert.ok(
+    /\(testState\.ok && testState\.dropped \? " · " \+ t\("memory\.features\.modelTestDowngraded"\) : ""\)/.test(clientSource),
+    "the downgrade note must be appended only on the success line"
+  );
+  // 3. 双语词表各一条（按行首的 "key": "…" 计数，与上面的全键计数锁同口径；
+  //    用 split 会把渲染处的 t("…") 一起数进来，那是 3 次不是 2 次）
+  const tableRows = clientSource.match(/^\s*"memory\.features\.modelTestDowngraded"\s*:\s*"/gm) || [];
+  assert.equal(tableRows.length, 2, `memory.features.modelTestDowngraded must be declared exactly twice in the tables (zh + en), got ${tableRows.length}`);
+  // 4. 那条陈旧前提不得复活：面板不得再声称 sleep/梦 侧无回退重试
+  assert.ok(
+    !/无回退重试|无回退|no fallback retry/.test(clientSource),
+    "the panel must not re-assert the stale 'no fallback retry' claim that withEffortFallback already covers"
+  );
+});
+
 // 帮助与反馈入口（v0.8）：设置页底部三个反馈链接——GitHub 新建 issue 预填
 // （环境信息）、邮件反馈、浏览已知问题。纯前端链接零后端成本；插件版本从
 // /info 拉取（version 只读，不铺任何 token/凭据）。公开链接不得带个人邮箱。
@@ -986,6 +1012,41 @@ test("scope isolation ships panel switches and provenance surfaces (A4)", () =>
   assert.ok(clientSource.includes('t("memory.explorer.detail.occurred")'), "drawer must render occurred row");
 });
 
+// Issue #427：设置面板把折叠线从「冷门」挪到「新手之外」。锁四件事：
+// ①首屏层 = 常用组（3 总开关）+ 作用域组——scope 留在首屏是因为「它记的东西
+// 会不会被别的会话看到」是新用户的必答题，藏进折叠等于没答；②其余组整组收进
+// 「全部设置」（第一层折叠），「高级」降为它内部的第二层；③每条开关挂
+// 「默认 / 已改」徽标，信号取自 overrides（键不在其中 = 仍是 config schema
+// 默认值），面板自判、不加后端字段；④分组与折叠键中英成对。验收口径：首屏
+// 可点项 = 3 总开关 + autoInject 的 2 个子开关 + scope 2 开关 + 「全部设置」
+// 按钮 = 8（≤ 8），由 ①② 的组成正则共同钉死，不另数 DOM。
+test("settings card folds everything beyond the first screen behind All settings (issue #427)", () => {
+  // ① 首屏层组成：两组都要在，且 basic 的成员是从 core/dream 移走的。
+  assert.ok(/const FEATURE_FIRST_SCREEN = \["group\.basic", "group\.scope"\];/.test(clientSource),
+    "the first screen must be exactly the basic and scope groups");
+  assert.ok(/key: "group\.basic", items: \["autoInject", "autoSummarize", "autoDream"\]/.test(clientSource),
+    "group.basic must carry exactly the three master switches");
+  assert.ok(!/key: "group\.core", items: \["autoInject/.test(clientSource) && !/key: "group\.dream", items: \["autoDream/.test(clientSource),
+    "basic members must be MOVED out of their old groups (render-once), not filtered at render time");
+  // ② 两层折叠的接线：restGroups 只在 showAll 展开后渲染；「高级」按钮出现在
+  // 「全部设置」之后（同一渲染分支内），showAdv 展开的条目走第二层。
+  assert.ok(/showAll && h\(react\.Fragment, null,\s*restGroups\.map\(renderGroup\)/.test(clientSource),
+    "the remaining groups must render only behind the All settings fold");
+  const allBtn = clientSource.indexOf('t("memory.features.allToggle")');
+  const advBtn = clientSource.indexOf('t("memory.features.advancedToggle")');
+  assert.ok(allBtn >= 0 && advBtn > allBtn, "the advanced fold must be nested after All settings");
+  assert.equal(clientSource.match(/const FEATURE_ADVANCED_BOOLS = \[([^\]]*)\];/)[1].split(",").filter((s) => s.trim()).length, 7,
+    "the advanced second tier must hold exactly the 7 rarer switches the label promises");
+  // ③ 徽标：两类各一套中英文案；判定读 overrides 本地判，不引入后端字段。
+  for (const key of ["memory.features.tagDefault", "memory.features.tagChanged",
+    "memory.features.group.basic", "memory.features.allToggle", "memory.features.advancedToggle"]) {
+    const occurrences = clientSource.split("\"" + key + "\"").length - 1;
+    assert.ok(occurrences >= 2, `i18n key ${key} must exist in both zh and en (got ${occurrences})`);
+  }
+  assert.ok(clientSource.includes("Object.prototype.hasOwnProperty.call(ovr, k)"),
+    "the default/changed badge must be decided from overrides, not a new backend field");
+});
+
 // v0.8.0 冲突集中处理：状态页的待确认冲突队列（reason + 双方内容对比 +
 // 保留 A/B/仅标记动作），resolveConflictPending 的第一个前端出口。双语齐备。
 test("conflict queue ships a central review surface on the status tab", () => {
@@ -1580,3 +1641,301 @@ test("client bundle parses: 面板产物必须是合法 JS（无重复声明等
   const result = spawnSync(process.execPath, ["--check", join(root, "lib/client.js")], { encoding: "utf8" });
   assert.equal(result.status, 0, `lib/client.js 解析失败：\n${result.stderr || result.stdout}`);
 });
+
+// #399 的两个留存键（distillRecords.enabled / retentionDays）此前只有后端
+// 白名单与 docs/CONFIGURATION.md 的「面板可启停」，面板里根本没有这一行——
+// 文档承诺了一个够不着的开关。补上 UI 之后，这条锁住四件容易被「简化」掉的事：
+//   ① 两个键真的进了渲染清单（enabled 在组里、retentionDays 在数值清单里）；
+//   ② 数值项的草稿必须从 effective 初始化——漏掉这一句，行会永远显示空值，
+//      用户以为配置丢了（#191 的睡眠路由键踩过同一个坑，见 :738 那条注释）；
+//   ③ 天数行必须由父开关门控（关着不留存，改天数没有意义）；
+//   ④ 非整数在本地就被挡下并把草稿退回生效值——留着非法文本会让人以为改成功了。
+test("distill retention switches are reachable from the panel (#399)", () => {
+  // 认「组里有没有」不要用 `"key"]` 这种子串——`eff["distillRecords.enabled"]`
+  // 也长这样，把组里那一项删掉它照样命中（变异验证实测：删项后仍全绿）。
+  // 必须把 core 组的 items 数组抠出来单独看。
+  const coreGroup = clientSource.match(/key: "group\.core", items: \[([\s\S]*?)\]/);
+  assert.ok(coreGroup, "the core group must be declared");
+  assert.ok(
+    coreGroup[1].includes('"distillRecords.enabled"'),
+    "distillRecords.enabled must be an item of the core group, not merely referenced elsewhere"
+  );
+  assert.ok(
+    /const FEATURE_NUMBERS = \["distillRecords\.retentionDays"\]/.test(clientSource),
+    "retentionDays must be in the numeric key list"
+  );
+  assert.ok(
+    /for \(const key of FEATURE_NUMBERS\) numDraft\[key\] = String\(e\[key\] \?\? ""\);/.test(clientSource)
+      && /setNums\(numDraft\);/.test(clientSource),
+    "the numeric draft must be seeded from effective on mount, or the row always renders empty"
+  );
+  assert.ok(
+    /const distillSub = eff\["distillRecords\.enabled"\] && h\("div", \{ className: "mneme-featsub" \},\s*\n\s*numRow\("distillRecords\.retentionDays"\)/.test(clientSource),
+    "the retention-days row must be gated on the parent switch and live in its sub-block"
+  );
+  // 定义了不等于接线了：把 distillSub 从组尾子块里摘掉，上面每条断言照样全绿
+  // （变异验证实测：摘掉后仍全绿）。子块是在 items.map 之后按组尾追加的，所以必须确认
+  // 它真的出现在那一个渲染点上。
+  const coreTail = clientSource.match(/g\.key === "group\.core" && h\(react\.Fragment, null, ([^)]*)\)/);
+  assert.ok(coreTail, "the core group must append its sub-blocks at the group tail");
+  assert.ok(
+    /\bdistillSub\b/.test(coreTail[1]),
+    "distillSub must be rendered at the core group tail, not merely declared above"
+  );
+  assert.ok(
+    /if \(!\/\^\\d\+\$\/\.test\(raw\)\) \{\s*\n\s*setNums\(\(c\) => \(\{ \.\.\.c, \[key\]: String\(eff\[key\] \?\? ""\) \}\)\);\s*\n\s*return;\s*\n\s*\}/.test(clientSource),
+    "a non-integer draft must be rejected locally and reverted to the effective value"
+  );
+  for (const key of [
+    "memory.features.distillRecords.enabled",
+    "memory.features.distillRecords.enabled.hint",
+    "memory.features.distillRecords.retentionDays",
+    "memory.features.distillRecords.retentionDays.hint"
+  ]) {
+    const occurrences = clientSource.split(`"${key}"`).length - 1;
+    assert.ok(occurrences >= 2, `i18n key ${key} must exist in both zh and en (got ${occurrences})`);
+  }
+});
+
+test("a rejected feature write is visible and reverts the draft", () => {
+  // 锁的是「保存失败从不显示」：错误提示原先只有一个座位、且带 `!state` 条件
+  // （首屏加载失败才渲染）——state 一到手，此后每次写入失败都静默，输入框里
+  // 留着没保存的值。整数项把「越界」变成可达路径后，人能在面板上看到 99999
+  // 却以为它生效了。
+  // 认「座位存在」不能只看 setSaveError 出现几次（函数里调它、渲染处读它，
+  // 两处都在就算命中），要把写入路径与渲染路径分别钉住。
+  assert.ok(
+    clientSource.includes('const [saveError, setSaveError] = useState("");'),
+    "save failures need their own state slot"
+  );
+  // 渲染座位必须在主卡片里（描述行之后、运行时块之前），而不是被 !state 挡住。
+  const descAt = clientSource.indexOf('h("div", { className: "mneme-set-desc" }, t("memory.features.desc"))');
+  const seatAt = clientSource.indexOf('saveError && h("div", { className: "mneme-mainterr" }, saveError)');
+  const provAt = clientSource.indexOf("h(RuntimeProvisionBlock, { t })");
+  assert.ok(descAt > 0 && seatAt > descAt, "the save-error seat must live in the main card body");
+  assert.ok(provAt > seatAt, "the seat must sit in the card header area, before the runtime block");
+  const earlyReturn = clientSource.match(/if \(error && !state\) return[\s\S]{0,300}?error\)\);/);
+  assert.ok(earlyReturn, "the load-failure early return must still be there");
+  assert.ok(!earlyReturn[0].includes("saveError"), "the save-error seat must not ride the load-failure branch");
+
+  // 写入路径：服务端 400 的 body 带着键名与范围（api.js 那条 400 的设计），
+  // 要读出来；失败要能被调用方看见，所以返回值必须是真假。
+  const putBody = clientSource.match(/const put = async \(patch\) => \{([\s\S]*?)\r?\n      \};/);
+  assert.ok(putBody, "put must be declared");
+  assert.ok(putBody[1].includes("const detail = await res.json()"), "the server error body must be read");
+  assert.ok(putBody[1].includes('throw new Error(detail || ("HTTP " + res.status));'), "the body must win over the bare status");
+  assert.ok(putBody[1].includes("return true;") && putBody[1].includes("return false;"), "put must report success");
+  assert.ok(putBody[1].includes("setSaveError(`"), "a rejected write must set the visible error");
+
+  // 两个提交路径都要在同一处退回生效值：只报错不退，框里的值仍与在用的值分家。
+  assert.ok(clientSource.includes("put({ [key]: raw }).then((ok) => {"), "a rejected string draft must be revertible");
+  assert.ok(clientSource.includes("put({ [key]: Number(raw) }).then((ok) => {"), "a rejected number draft must be revertible");
+  assert.ok((clientSource.split("if (!ok) setStrs(").length - 1) >= 1, "the string draft must revert on rejection");
+  assert.ok((clientSource.split("if (!ok) setNums(").length - 1) >= 1, "the number draft must revert on rejection");
+
+  const occurrences = clientSource.split('"memory.features.saveFailed"').length - 1;
+  assert.ok(occurrences >= 2, `i18n key memory.features.saveFailed must exist in both zh and en (got ${occurrences})`);
+});
+
+// ── M.O.（Modus Operandi）面板的数据面 ────────────────────────────────────────
+// 第一版面板拿硬编码的 PIPELINE_MOCK 验证形状与交互（服务端管线当时还没落地）。
+// 接上真数据之后那份常量必须消失：留着它，面板随时可能退回展示一份并不存在的
+// 工作流——而这正是这一刀要修掉的东西。这里锁「没有」比锁「有什么」更要紧。
+test("M.O. panel carries no mock pipeline data", () => {
+  assert.equal(
+    clientSource.includes("PIPELINE_MOCK"),
+    false,
+    "the hardcoded PIPELINE_MOCK must be gone now that the panel reads the server"
+  );
+});
+
+// 四个座位——会话头图标、会话头浮层、右栏 tab、对话行结算卡——必须读同一份投影。
+// 分家的事故长这样：会话头说有 3 条候选、右栏说有 5 条，而两个数字都对、没人查得出来。
+// 所以缓存只许有一处（usePipeline），其余要么从它取，要么经 PipelineBrowser 取。
+test("M.O. seats share a single pipeline document", () => {
+  assert.equal(
+    (clientSource.match(/function usePipeline\(/g) || []).length,
+    1,
+    "usePipeline must be defined exactly once — one cache, every seat"
+  );
+  const bodyOf = (name) => {
+    const start = clientSource.indexOf(`function ${name}(`);
+    assert.ok(start > -1, `${name} must exist`);
+    const next = clientSource.slice(start + 1).indexOf("\n    function ");
+    return clientSource.slice(start, next > -1 ? start + 1 + next : clientSource.length);
+  };
+  for (const seat of ["PipelineHeaderEntry", "TurnRunCard"]) {
+    assert.ok(
+      bodyOf(seat).includes("usePipeline(project, null)"),
+      `${seat} must read the shared pipeline document`
+    );
+  }
+  // 另两个座位不再自己调 hook：它们把 project 交给 PipelineBrowser，由它按 openId 决定
+  // 读清单还是读某一条。hook 不能条件调用，所以这道分叉必须落在**组件之间**而不是
+  // 一个组件里的 if/else——后者会在点开那一下炸成「Rendered more hooks than during
+  // the previous render」，而那是运行期才看得见的错。
+  assert.ok(
+    bodyOf("PipelinePane").includes("h(PipelineBrowser, { t, project })"),
+    "PipelinePane must delegate to PipelineBrowser"
+  );
+});
+
+// 清单与图**同屏**。这条锁的形状换过两次，两次的教训都写在这里，免得再翻回去：
+//   一进来就是图 —— 没有名字、没有落点，要的是一串有名字的条目；
+//   清单 ⟷ 图两屏来回切 —— 条目有了，但画布藏在一次点击后面、界面上没有任何提示，
+//                          反馈连着两次说「看不到画布和节点」。
+// 所以锁的是：清单行渲染名字/作用域/规模，**且** 图与清单在同一个组件里同时出现。
+test("M.O. browser shows the named list and the canvas on one screen", () => {
+  const bodyOf = (name) => {
+    const start = clientSource.indexOf(`function ${name}(`);
+    assert.ok(start > -1, `${name} must exist`);
+    const next = clientSource.slice(start + 1).indexOf("\n    function ");
+    return clientSource.slice(start, next > -1 ? start + 1 + next : clientSource.length);
+  };
+  const list = bodyOf("PipelineWorkflowList");
+  assert.ok(list.includes("row.title || row.id"), "each row must show a name");
+  assert.ok(list.includes("memory.actions.scope.project"), "each row must show its scope");
+  assert.ok(list.includes("memory.actions.list.meta"), "each row must show its size");
+  const browser = bodyOf("PipelineBrowser");
+  assert.ok(browser.includes("PipelineWorkflowList"), "the named list must be on screen");
+  assert.ok(
+    browser.includes("h(PipelineView, { t, data: detailDoc })"),
+    "the canvas must be on the SAME screen — not behind a click"
+  );
+  assert.ok(browser.includes("rows.length ? rows[0].id : null"), "the first workflow must be expanded by default");
+});
+
+// 面板读的是服务端投影，不是本地算的：工作流本体住仓库、投影住服务端，
+// 面板只负责画。路由一旦改了名字、或者项目根忘了带，这条会先红。
+test("M.O. panel reads the server projection", () => {
+  assert.match(
+    clientSource,
+    /"\/api\/dsh-mneme\/pipeline" \+/,
+    "the panel must fetch the pipeline route"
+  );
+  // 项目根是**客户端从会话读出来带过去的**，不是服务端猜的：插件侧的 ctx 上没有 cwd
+  // （只有 logger / llm / reflect / webServer / inject / commands），猜不出来。
+  assert.ok(
+    clientSource.includes('params.push("project=" + encodeURIComponent(project))'),
+    "the panel must pass the session's project root to the route"
+  );
+  assert.ok(
+    clientSource.includes("function sessionProject(ctx, sessionId)"),
+    "the session cwd lookup must exist and stay named"
+  );
+  // 两条来源的先后：会话列表快照（byId[sessionId].cwd）是宿主给客户端的公开形状，
+  // sessions.get() 是宿主侧写法、客户端不一定有。顺序反了不会报错，只会让面板静悄悄
+  // 退回全局层——那跟「本项目还没有工作流」长得一模一样，是最难查的一类错。
+  // 而且两条必须各兜各的异常：一条抛了不能把另一条也带走，否则同样表现成「项目未知」。
+  const sessionProjectBody = clientSource.slice(
+    clientSource.indexOf("function sessionProject("),
+    clientSource.indexOf("function layoutDag(")
+  );
+  assert.ok(
+    sessionProjectBody.indexOf("sessions.list.getSnapshot") <
+      sessionProjectBody.indexOf("typeof sessions.get"),
+    "the host's public shape (list snapshot) must be tried before the host-side accessor"
+  );
+  const betweenLookups = sessionProjectBody.slice(
+    sessionProjectBody.indexOf("sessions.list.getSnapshot"),
+    sessionProjectBody.indexOf("typeof sessions.get")
+  );
+  assert.ok(
+    betweenLookups.includes("catch (err)"),
+    "each lookup must carry its own catch — a throwing accessor must not take out the next one"
+  );
+});
+
+// 右栏 tab 的正文单独包了一层具名组件，而不是把 hook 直接塞进 slots.register 的回调里：
+// 那个回调是不是当组件渲染由宿主决定，赌错就是「Rendered more hooks than during the
+// previous render」这种只在运行时炸、测试看不见的错。
+test("right-pane tab renders a named component instead of a bare hook callback", () => {
+  assert.match(clientSource, /function PipelinePane\(/, "PipelinePane must exist");
+  assert.ok(
+    clientSource.includes(
+      "}, (props) => h(PipelinePane, { t, project: sessionProject(ctx, props && props.sessionId) }));"
+    ),
+    "the tab callback must delegate to the named PipelinePane component, with the session's project"
+  );
+});
+
+// 「仓库里还没有工作流」与「一条运行记录都没有」是两句不同的话，都得中英齐全——
+// i18n 掉一边，界面上就是一行 key 裸奔。作用域那三句尤其不能缺：清单行上「项目」
+// 与「全局」是唯一的来源提示，缺了它，人分不清手里这条是本项目的还是跟着插件来的。
+test("M.O. empty-state, list and scope copy exist in both languages", () => {
+  for (const key of [
+    "memory.actions.empty.title",
+    "memory.actions.empty.body",
+    "memory.actions.noRuns",
+    "memory.actions.zoom.in",
+    "memory.actions.zoom.out",
+    "memory.actions.zoom.fit",
+    "memory.actions.list.heading",
+    "memory.actions.list.count",
+    "memory.actions.list.meta",
+    "memory.actions.scope.project",
+    "memory.actions.scope.global",
+    "memory.actions.scope.none",
+    "memory.actions.broken"
+  ]) {
+    const hits = (clientSource.match(new RegExp(`"${key.replace(/\./g, "\\.")}":`, "g")) || []).length;
+    assert.equal(hits, 2, `${key} must exist in both zh and en (got ${hits})`);
+  }
+});
+
+// 画布能放大缩小。锁的重点不是「有没有缩放」，而是滚轮那一条必须**自己挂非被动监听**：
+// React 的 onWheel 挂在 root 上且是 passive 的，preventDefault 会被浏览器忽略，
+// 于是 Ctrl+滚轮既缩放画布又缩放整页，谁也没拦住——这个错本地测不出来，只在真浏览器里响。
+test("M.O. canvas zooms: buttons plus a non-passive, modifier-gated wheel listener", () => {
+  const bodyOf = (name) => {
+    const start = clientSource.indexOf(`function ${name}(`);
+    assert.ok(start > -1, `${name} must exist`);
+    const next = clientSource.slice(start + 1).indexOf("\n    function ");
+    return clientSource.slice(start, next > -1 ? start + 1 + next : clientSource.length);
+  };
+  const view = bodyOf("PipelineView");
+  assert.ok(view.includes("PipelineZoomBar"), "the zoom control must be rendered");
+  assert.ok(view.includes("{ passive: false }"), "the wheel listener must be non-passive, or preventDefault is ignored");
+  assert.ok(view.includes("ev.ctrlKey") && view.includes("ev.metaKey"), "plain wheel must stay a scroll, not a zoom");
+  assert.ok(view.includes('width: (zoom * 100) + "%"'), "zoom must change the layout width so the container can scroll to it");
+  const bar = bodyOf("PipelineZoomBar");
+  assert.ok(bar.includes("memory.actions.zoom.in"), "zoom in must be reachable by button, not only by wheel");
+  assert.ok(bar.includes("memory.actions.zoom.out"), "zoom out must be reachable by button");
+});
+
+// 「tab 的类型」与「tab 的正文」必须是两件互不相干的事，而且类型注册要幂等。
+// 为什么会栽（2026-10-16 真机上现形）：宿主对重复的类型 id 会抛
+// （sidebarRight: tab type id "…" is already registered），而类型注册挂在宿主服务上、
+// 插件重挂（刷新 / 热重载 / 会话重建）时**留着**，正文座位却是挂插件 scope、随插件回收的。
+// 两件事原来同一个 try —— 第二次挂载时那一抛把正文一起带走，界面上只剩宿主的 fallback
+// 「这类内容还没有可用的查看方式」，错误只在浏览器控制台里，界面上零痕迹。
+test("M.O. tab type registration is idempotent and isolated from the pane body", () => {
+  const typeAt = clientSource.indexOf("id: PIPELINE_ACTIONS_TAB_ID,");
+  const bodyAt = clientSource.indexOf('ctx.slots.inject("sidebar.right.pane.tab"');
+  assert.ok(typeAt > -1, "the tab type registration must exist");
+  assert.ok(bodyAt > typeAt, "the pane body registration must exist, after the type");
+  assert.ok(
+    clientSource.includes("tabs.get(PIPELINE_ACTIONS_TAB_ID)"),
+    "the type registration must be idempotent — a re-mount must not re-register the id"
+  );
+  assert.ok(
+    clientSource.slice(typeAt, bodyAt).includes("catch (err)"),
+    "the type registration must carry its own catch — its failure must not take out the pane body"
+  );
+});
+
+// 回归锁：M.O. 段里每个 .mneme-pipe-* 类名在样式表里只许有**一条**规则。
+// 为什么会栽在这里（2026-10-16，真机上才现形）：新写的详情屏容器与既有的「节点详情」面板
+// 撞了同名 .mneme-pipe-detail —— 后写的 flex:1 赢下冲突，先写的 max-height:180px; overflow:auto
+// 却留着，于是详情屏被钉在 180px、里面的画布 flex:1 分到 0 像素，屏幕上只剩空白加一条滚动条。
+// 只查颜色的 contrast.test.js 抓不到这类撞车；它只有在屏幕上看才现形，所以要在这里钉住。
+test("M.O. class names do not collide in the stylesheet", () => {
+  const declared = new Map();
+  for (const m of clientSource.matchAll(/"\.mneme-pipe-([a-z0-9-]+)\{/g)) {
+    declared.set(m[1], (declared.get(m[1]) || 0) + 1);
+  }
+  const dupes = [...declared].filter(([, n]) => n > 1).map(([k, n]) => `.mneme-pipe-${k}×${n}`);
+  assert.deepEqual(dupes, [], `duplicate .mneme-pipe-* rule(s): ${dupes.join(", ")}`);
+  // 扫描量也得钉：正则一旦匹配不到东西，上面那条会静默变绿（例如样式表被整块挪走）。
+  assert.ok(declared.size >= 20, `the scan must actually see the pipeline stylesheet (saw ${declared.size})`);
+});

package/test/continuity.test.js

@@ -331,3 +331,87 @@ test("#249 N3：存量库启动即建表（幂等迁移），重开后提案还
     rmSync(dir, { recursive: true, force: true });
   }
 });
+
+test("#249 N3：边缘只认「真的落地」——start 与带错的 end 都不算", async () => {
+  const store = createStore(":memory:");
+  const ctx = mockCtx();
+  const rescue = createContinuityRescue(ctx, store);
+  const session = fakeSession("s1", [userEvent(1, "指令")]);
+  const step = () => ctx.fire("agent/pre-step", { agent: { session } }, async () => ({ kind: "enter", messages: [] }));
+
+  // 宿主的压缩插件在**每一步**都试一次压缩（pre-step 里的 compactIfNeeded），所以
+  // `compaction/start` 只在说「有人试过」。按「试过就救」记账，触发器就变成「每步一次」。
+  ctx.fire("session/event", session, { type: "compaction/start", seq: 3, data: { compactionId: "c1", turn: 1 } });
+  assert.deepEqual((await step()).messages, [], "试过压缩不算边缘——没有东西被折叠，就没有东西要抢救");
+
+  // 失败路也会发 end（同一份源码：失败路 append 带 error），所以带 error 的 end 同样不算。
+  // 本机实测：1,287 次 start / 1,287 次 end 全部带 error —— 按旧口径，这一整段每一步都在救。
+  ctx.fire("session/event", session, { type: "compaction/end", seq: 4, data: { compactionId: "c1", turn: 1, error: "422: dsh_compaction_refused" } });
+  assert.deepEqual((await step()).messages, [], "压缩失败 → 历史没被折叠 → 不抢救");
+  assert.equal(store.countContinuityProposals(), 0, "两半都不动作：提案也不该落");
+  rescue.dispose();
+});
+
+test("#249 N3：三种「真落地」都算边缘——summary / 无错 end / prune", async () => {
+  const LANDED = [
+    ["compaction/summary（宿主压缩成功才落）", { type: "compaction/summary", data: { compactionId: "c", turn: 1 } }],
+    ["compaction/end 不带 error（成功路）", { type: "compaction/end", data: { compactionId: "c", turn: 1 } }],
+    ["compaction/prune（表面真的变短）", { type: "compaction/prune", data: { shadowedRange: { start: 1, end: 1 }, shadowedSeqs: [1], shadowedTokenCount: 100 } }]
+  ];
+  for (const [label, event] of LANDED) {
+    const ctx = mockCtx();
+    const rescue = createContinuityRescue(ctx, createStore(":memory:"));
+    const session = fakeSession("s1", [userEvent(1, "指令")]);
+    ctx.fire("session/event", session, { ...event, seq: 9 });
+    const decision = await ctx.fire("agent/pre-step", { agent: { session } }, async () => ({ kind: "enter", messages: [] }));
+    assert.equal(decision.messages.length, 1, `${label} 是「历史真被折叠」的信号，要抢救`);
+    rescue.dispose();
+  }
+});
+
+test("#249 N3：失败尝试不产生注入洪流，真折叠才抢救（实测形状）", async () => {
+  const store = createStore(":memory:");
+  const ctx = mockCtx();
+  const rescue = createContinuityRescue(ctx, store);
+  const events = [userEvent(1, "把 N3 实现完")];
+  const nodes = [1];
+  const session = fakeSession("s1", events, nodes);
+  let seq = 100;
+  let injected = 0;
+  // 宿主把追加的消息落进会话（表面 + 日志）——判重按表面，这一步必须照实模拟，否则
+  // 「不变不重复」永远不生效，测出来的是判重缺席的样子。
+  const step = async () => {
+    const decision = await ctx.fire("agent/pre-step", { agent: { session } }, async () => ({ kind: "enter", messages: [] }));
+    for (const message of decision.messages) {
+      seq += 1;
+      events.push({ type: "user/message", seq, data: { content: message.content, source: message.source } });
+      nodes.push(seq);
+      injected += 1;
+    }
+    return decision;
+  };
+
+  // 实测里最常见的形状（本机 1,591 步 / 1,230 次尝试）：一步步试压缩、次次失败。
+  // 每步都推进一条 assistant/message，于是快照文本每步都不同——「不变不重复」挡不住它，
+  // 挡得住它的只有「这段历史到底有没有被折叠」这一个判断。改前口径在这里会注入 50 次。
+  for (let i = 0; i < 50; i += 1) {
+    seq += 1;
+    events.push(assistantEvent(seq, `第 ${i} 步的回复`));
+    seq += 1;
+    ctx.fire("session/event", session, { type: "compaction/start", seq, data: { compactionId: `c${i}`, turn: i } });
+    seq += 1;
+    ctx.fire("session/event", session, { type: "compaction/end", seq, data: { compactionId: `c${i}`, turn: i, error: "422: dsh_compaction_refused" } });
+    await step();
+  }
+  assert.equal(injected, 0, "50 次失败尝试 → 0 次注入（改前 50 次：每一步都救了一次没被折叠的历史）");
+
+  // 真的折叠了一次 → 恰好抢救一次。
+  seq += 1;
+  events.push(assistantEvent(seq, "接着写回归测试"));
+  seq += 1;
+  ctx.fire("session/event", session, { type: "compaction/prune", seq, data: { shadowedRange: { start: 1, end: 1 }, shadowedSeqs: [1], shadowedTokenCount: 100 } });
+  await step();
+  assert.equal(injected, 1, "表面真的变短了 → 抢救一次");
+  assert.equal(store.getContinuityProposal("s1", KIND).current_work, "把 N3 实现完", "落库那一半照常");
+  rescue.dispose();
+});

package/test/embed-ready-poll.test.js

@@ -0,0 +1,94 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+
+// 这条锁防的是一类「上限形同不存在」的回归：上限判断如果排在会抛错的那次读取
+// 后面，轮询就永远不会停手。
+//
+// service.js 的 setEmbedder 为异步初始化的 embedder 起了个轮询：每 100ms 读一次
+// `emb.ready`，读到 true 或撞上 EMBED_READY_POLL_LIMIT(=30) 就停
+// （注释原文 "~3s ceiling; never poll forever"）。但 `ready` 是个 getter
+// —— embedding.js 的 OpenAI embedder 直接读库 —— 于是写成
+//     if (emb.ready === true || attempts >= EMBED_READY_POLL_LIMIT) { stop(); }
+// 的整条 `||` 会在左半边当场中断，右半边的天花板永远轮不到：stopEmbedReadyPolling()
+// 不执行，定时器活过上限，并且每 100ms 抛一次未捕获异常。
+//
+// 实测现场（2026-10-14，加蒸馏留存的装配级用例时撞上）：fiber.dispose() 走完
+// index.js 的 disposer（末尾一句就是 store.close()）之后，每次读 ready 都抛
+// "database is not open" [ERR_INVALID_STATE]，5s 内读了 46 次 —— 天花板 31 被
+// 击穿，node --test 进程因此不再退出。一个只在启动时读一次库的 getter，能把
+// 宿主的事件循环钉死；而现有测试全都「装配完不拆」，所以从 v0.7.1 起一直没人碰到。
+//
+// 时序照真实卸载顺序复现：安装时未就绪（轮询启动）→ store.close()（此后每次读
+// ready 都抛）→ 等超过天花板 → 看它停没停手、报了几次。
+const POLL_LIMIT = 30; // 与 src/service.js 的 EMBED_READY_POLL_LIMIT 同值，改那边要改这里
+const POLL_MS = 100;
+const CEILING_READS = 1 + POLL_LIMIT; // setEmbedder 自己读一次，之后每个 tick 一次
+const SETTLE_MS = 400; // 静默这么久没新读取，就认为定时器已经停手
+const DEADLINE_MS = 30000; // 上限：等到这里还没静默就按超时处理
+
+// 等「读取次数不再增长」。不能用「睡够 POLL_MS*30 + 600ms 再断言」——
+// 全量 npm test 是多文件并行跑的，CPU 一挤，30 个 tick 未必在 3.6s 内跑完，
+// 断言就会读到 30 而不是 31（2026-10-15 rebase 后在全量跑里实测撞到一次，
+// 单跑 3/3 通过、紧接着全量跑两遍也全绿——纯粹的负载抖动）。
+// 静默判定是可靠的：定时器周期 100ms，而越过上限后 stopEmbedReadyPolling()
+// 会 clearInterval，此后 reads 恒不再变，两者不会混淆。
+async function waitUntilSettled(getReads) {
+  const started = Date.now();
+  let last = getReads();
+  let lastChange = Date.now();
+  while (Date.now() - started < DEADLINE_MS) {
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    const now = getReads();
+    if (now !== last) {
+      last = now;
+      lastChange = Date.now();
+      continue;
+    }
+    if (Date.now() - lastChange >= SETTLE_MS) return now;
+  }
+  return getReads();
+}
+
+test("the embedder ready poll stops at its ceiling even when reading ready throws", async () => {
+  const warns = [];
+  const store = createStore(":memory:");
+  const service = createService({
+    store,
+    mirror: null,
+    config: {},
+    logger: { warn: (...args) => warns.push(args) }
+  });
+
+  let reads = 0;
+  let closed = false;
+  const embedder = {
+    get ready() {
+      reads++;
+      if (closed) {
+        // 与 embedding.js 的 OpenAI embedder 同形：getter 内部经 settings 读库。
+        store.db.prepare("SELECT count(*) AS c FROM memories").get();
+      }
+      return false; // 始终「未就绪」：轮询会一直跑下去，除非天花板真的生效
+    }
+  };
+
+  service.setEmbedder(embedder);
+  assert.equal(reads, 1, "setEmbedder 先读一次 ready，决定要不要起轮询");
+
+  closed = true;
+  store.close(); // 卸载路径的最后一步
+
+  await waitUntilSettled(() => reads);
+  const atCeiling = reads;
+
+  assert.equal(
+    atCeiling,
+    CEILING_READS,
+    `读 ready 抛错也必须按上限停手（实际读了 ${atCeiling} 次，上限 ${CEILING_READS}）`
+  );
+  assert.equal(reads, atCeiling, "越过天花板之后不许再有读取：定时器必须已经清掉");
+  assert.equal(warns.length, 1, "读不出来只报一次，别把 3s 上限变成 30 条刷屏");
+  assert.match(String(warns[0][0]), /embedder ready probe failed/);
+});

package/test/entities.test.js

@@ -533,7 +533,9 @@ test("extractor passes provider/model/reasoningEffort through to callLLM options
   const config = { entityExtractionProvider: "openai", entityExtractionModel: "gpt-x", entityExtractionReasoning: "high" };
   const result = await extractEntities({ id: "m1", content: "Vite 是前端构建工具" }, { store, config, callLLM });
   assert.equal(result.ok, true);
-  assert.deepEqual(captured, { provider: "openai", model: "gpt-x", reasoningEffort: "high" });
+  // memoryId 是 #405 加的归属通道（审计行靠它记 related_memory_ids），与 #109 的
+  // provider/model/reasoningEffort 走同一条 options 缝；形状锁保持精确相等。
+  assert.deepEqual(captured, { provider: "openai", model: "gpt-x", reasoningEffort: "high", memoryId: "m1" });
   store.close();
 });
 
@@ -542,7 +544,16 @@ test("extractor omits empty provider/model and 'none' reasoning from options", a
   let captured = "unset";
   const callLLM = async (_m, options) => { captured = options; return JSON.stringify({ entities: [], relations: [] }); };
   await extractEntities({ id: "m2", content: "空文本" }, { store, config: {}, callLLM });
-  assert.deepEqual(captured, {}, "no provider/model/reasoning keys when unset");
+  assert.deepEqual(captured, { memoryId: "m2" }, "no provider/model/reasoning keys when unset");
+  store.close();
+});
+
+test("#405: extractor omits memoryId when the memory has no id (no fabricated attribution)", async () => {
+  const store = openStore();
+  let captured = "unset";
+  const callLLM = async (_m, options) => { captured = options; return JSON.stringify({ entities: [], relations: [] }); };
+  await extractEntities({ content: "无 id 的记忆" }, { store, config: {}, callLLM });
+  assert.deepEqual(captured, {}, "an id-less memory leaves the attribution channel empty");
   store.close();
 });