@modusensus/dsh-mneme 0.8.16 → 0.9.1

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,45 @@ 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。
+// v0.9.0 复验修订：首屏加 group.mo（M.O. 独立组），可点项预算 8→9。这不是
+// 悄悄放宽——是产品主人点名「别藏在里面」：M.O. 独立成组却仍折在「全部
+// 设置」后等于换个地方继续藏。≤8 原为 #427 自设软预算，owner 豁免一项。
+test("settings card folds everything beyond the first screen behind All settings (issue #427)", () => {
+  // ① 首屏层组成：三组都要在（basic 总开关 / mo 座位闸门 / scope 必答题），
+  // 且 basic 的成员是从 core/dream 移走的。
+  assert.ok(/const FEATURE_FIRST_SCREEN = \["group\.basic", "group\.mo", "group\.scope"\];/.test(clientSource),
+    "the first screen must be exactly the basic, mo 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 +1645,446 @@ 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})`);
+});
+
+// 回归锁（v0.9.0 复验轮沉淀）：面板的两种「静默消失」假绿形状一起钉住。
+// ① i18n 缺定义：既有的「每键恰好两次」锁只统计**字典里存在**的键，一个只有
+//   用法、零字典行的键在计数里整个消失——本轮就查出 4 个这种键（zoom.value 自
+//   基线即断）。所以这里反向查：每一处用法都必须能找到定义行。三种用法形状：
+//   字面量 t("k")、模板 t(`memory.features.${g.key}`) 按 FEATURE_GROUPS 的组键
+//   展开、模板 t(`memory.features.${k}`) 按各 items 旗标键展开（boolRow 的
+//   name/hint 各一路）。不做全量动态键解析——拼接形态的键在此设防范围外。
+// ② 图标名未注册：Icon 对查不到的名字 return null（无回退、无告警），闸门照绿
+//   而屏幕上图标没了。本轮 star 入口就是这么哑掉的。这里钉「每个用到的名字都在
+//   ICON_PATHS 注册表里」+ 提取与注册表的最低数量（防正则空转的静默绿）。
+test("panel copy and icons must not silently vanish (missing dict lines, unregistered icon names)", () => {
+  const defined = (key) => clientSource.includes('"' + key + '":');
+
+  // ①-a 字面量用法（右括号紧贴字符串，排除 "前缀" + 变量 拼接形态）
+  const usedKeys = new Set();
+  for (const m of clientSource.matchAll(/\bt\("([a-zA-Z0-9_.]+)"\)/g)) usedKeys.add(m[1]);
+  assert.ok(usedKeys.size >= 300, `the literal scan must actually see the panel's t() calls (saw ${usedKeys.size})`);
+  // ①-b 模板展开：组键 与 旗标键（label + .hint 两路）
+  const groupKeys = [...clientSource.matchAll(/key: "(group\.[a-z]+)"/g)].map((m) => m[1]);
+  assert.ok(groupKeys.length >= 5, `FEATURE_GROUPS must be parseable (saw ${groupKeys.length} groups)`);
+  for (const g of groupKeys) usedKeys.add("memory.features." + g);
+  const flagKeys = [...new Set([...clientSource.matchAll(/items: \[((?:[^\]]|\n)*)\]/g)]
+    .flatMap((m) => [...m[1].matchAll(/"([a-zA-Z0-9_.]+)"/g)].map((x) => x[1])))];
+  assert.ok(flagKeys.length >= 20, `group items must be parseable (saw ${flagKeys.length})`);
+  for (const k of flagKeys) { usedKeys.add("memory.features." + k); usedKeys.add("memory.features." + k + ".hint"); }
+
+  const missing = [...usedKeys].filter((k) => !defined(k)).sort();
+  assert.deepEqual(missing, [], `用而无典的 i18n 键（界面会裸奔出键名）：${missing.join(", ")}`);
+
+  // ② 图标名：注册表形状（顶层对象、六空格缩进）+ Icon 表达式与 feedRow 首参的提取
+  const registered = new Set([...clientSource.matchAll(/^\s{6}([a-zA-Z]+): \[\[/gm)].map((m) => m[1]));
+  assert.ok(registered.size >= 10, `the ICON_PATHS registry must be parseable (saw ${registered.size})`);
+  const iconNames = new Set();
+  for (const m of clientSource.matchAll(/h\(Icon, \{ name: ([^}]+?) [,}]/g)) {
+    const expr = m[1];
+    const direct = expr.match(/^"([a-zA-Z]+)"$/);
+    if (direct) { iconNames.add(direct[1]); continue; }
+    // 只取三元分支的纯字母串；"===" 比较对象前面是运算符不是 ? : ，不会误伤
+    for (const b of expr.matchAll(/[?:]\s*"([a-zA-Z]+)"/g)) iconNames.add(b[1]);
+  }
+  for (const m of clientSource.matchAll(/feedRow\(\s*"([a-zA-Z]+)"/g)) iconNames.add(m[1]);
+  assert.ok(iconNames.size >= 8, `icon usage must be parseable (saw ${iconNames.size})`);
+  const noIcon = [...iconNames].filter((n) => !registered.has(n)).sort();
+  assert.deepEqual(noIcon, [], `Icon 静默 return null 的未注册名：${noIcon.join(", ")}`);
+});
+
+// 人格定义页（beta）面板面回归：形状沿用 A4 的「分组 + i18n 双语 occurrences ≥ 2
+// + 关键接线」断言风格（只做源码断言，不挂 React 渲染环境）。
+test("persona page ships settings card, master switch and i18n (beta v1)", () => {
+  // 开关进 FEATURE_GROUPS 的 enhance 组（行为开关非座位闸门）
+  assert.ok(
+    /group\.enhance", items: \[(?:[^\]]|\n)*"personaEnabled"\]/.test(clientSource),
+    "FEATURE_GROUPS group.enhance must carry personaEnabled"
+  );
+  // i18n 键中英双语齐备（occurrences ≥ 2 模式；label + .hint 两路由字典锁统一覆盖）
+  for (const key of [
+    "memory.features.personaEnabled",
+    "memory.features.personaEnabled.hint",
+    "memory.settings.persona",
+    "memory.settings.personaHint",
+    "memory.settings.personaName",
+    "memory.settings.personaPersonality",
+    "memory.settings.personaReplyStyle",
+    "memory.settings.personaSave",
+    "memory.settings.personaSaved",
+    "memory.settings.personaEnabledToggle",
+    "memory.settings.personaView",
+    "memory.settings.personaViewHint",
+    "memory.settings.personaViewEmpty"
+  ]) {
+    const occurrences = clientSource.split(`"${key}"`).length - 1;
+    assert.ok(occurrences >= 2, `i18n key ${key} must exist in both zh and en (got ${occurrences})`);
+  }
+  // 设置卡接线：保存走 PUT /persona、卡内开关改 enabled 即保存、只读卡渲染
+  assert.ok(clientSource.includes('apiFetch("/api/dsh-mneme/persona"'), "persona card must talk to /persona");
+  assert.ok(clientSource.includes("method: \"PUT\""), "persona save must PUT");
+  assert.ok(clientSource.includes("t(\"memory.settings.personaView\")"), "read-only injected-view card must exist");
+  // 双闸门提示：hint 文案必须说明「总闸与卡内开关同时打开才生效」
+  assert.ok(
+    clientSource.includes("memory.features.personaEnabled.hint"),
+    "the master-switch hint must document the two-gate semantics"
+  );
+});
+
+// v1.2 多卡回归：卡列表 CRUD 可见、字段标签渲染为可见元素（v1.1 反馈：
+// aria-label 看不见）、保存失败必须冒可见错误（v1 静默 catch 吞 404 教训）。
+test("persona card is multi-card with visible field labels and save-failure error", () => {
+  for (const key of [
+    "memory.settings.personaDefaultCard",
+    "memory.settings.personaAdd",
+    "memory.settings.personaAddPlaceholder",
+    "memory.settings.personaEditingDefault",
+    "memory.settings.personaEditingFor",
+    "memory.settings.personaDeleteCard",
+    "memory.settings.personaSaveFailed",
+    "memory.settings.personaEnabledOn",
+    "memory.settings.personaEnabledOff"
+  ]) {
+    const occurrences = clientSource.split(`"${key}"`).length - 1;
+    assert.ok(occurrences >= 2, `i18n key ${key} must exist in both zh and en (got ${occurrences})`);
+  }
+  // 多卡接线：加卡/删卡/切换/保存全链函数存在
+  for (const fn of ["addPersonaCard", "removePersonaCard", "savePersonaCards", "setPersonaEditing"]) {
+    assert.ok(clientSource.includes(fn), `multi-card wiring must include ${fn}`);
+  }
+  // 可见字段标签：三个字段名的 t() 调用出现在 label 元素（mneme-featnumlabel）
+  const labelBlock = clientSource.match(/mneme-featnumlabel[^]{0,120}personaName/);
+  assert.ok(labelBlock, "persona field labels must be visible (featnumlabel class), not aria-only");
+  // 保存失败提示：personaError 状态有渲染路径（非仅 setState）
+  assert.ok(clientSource.includes("t(\"memory.settings.personaSaveFailed\")"), "save failure must render an error line");
+});
+
+// 回归锁（复验实测踩中）：面板「检测更新」的状态名必须与后端 classify
+// （src/version-check.js）逐字对齐。此前前端误写 "latest"/"up_to_date"（后端
+// 从未返回过），检测成功也掉进 error 兜底——按钮永远报「检测失败」。
+// 这条缝两端各有测试（version-check.test.js 测 classify、面板测试测渲染），
+// 但契约本身没人管。锁三件事：①前端比较的字面量是后端真实返回值；②后端
+// classify 的返回集合没有前端漏接的成员；③apiFetch 的路由路径与后端注册一致。
+test("update-check status names match the backend classify contract verbatim", () => {
+  const vcSource = readFileSync(join(root, "src/version-check.js"), "utf8");
+  // ① 后端 classify 的全部返回字面量
+  const backendStatuses = new Set(
+    [...vcSource.matchAll(/return "([a-z-]+)";/g)].map((m) => m[1])
+  );
+  assert.ok(backendStatuses.has("up-to-date") && backendStatuses.has("outdated") && backendStatuses.has("ahead") && backendStatuses.has("unknown"),
+    `classify must return the known status set (saw ${[...backendStatuses].join(", ")})`);
+  // ② 前端 checkResultText 比较的每个状态名都必须 ∈ 后端集合（防再发明新名）
+  const iStart = clientSource.indexOf("function checkResultText");
+  assert.ok(iStart > 0, "checkResultText must exist");
+  // 函数块取到下一个同级 function 声明为止：indexOf("}") 会切在首个 if 的
+  // 右括号，比较分支被截断成 1 个（2026-10-17 实测）。
+  const iEnd = clientSource.slice(iStart).search(/\n {6}function /);
+  const block = clientSource.slice(iStart, iEnd > 0 ? iStart + iEnd : undefined);
+  const compared = [...block.matchAll(/updateInfo\.status === "([a-zA-Z_-]+)"/g)].map((m) => m[1]);
+  assert.ok(compared.length >= 2, `the panel must compare real statuses (saw ${compared.length})`);
+  const unknown = [...new Set(compared)].filter((s) => !backendStatuses.has(s));
+  assert.deepEqual(unknown, [], `前端比较了后端不会返回的状态名（检测成功也会显示失败）：${unknown.join(", ")}`);
+  // ③ 路由契约：前端 fetch 的路径必须与后端注册的 exact path 一致
+  assert.ok(clientSource.includes('apiFetch("/api/dsh-mneme/version-check")'),
+    "the panel must call the registered version-check route");
+  const apiSource = readFileSync(join(root, "src/api.js"), "utf8");
+  assert.ok(apiSource.includes('path: "/api/dsh-mneme/version-check"'),
+    "the backend must register the version-check route");
+});

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