@modusensus/dsh-mneme 0.8.16 → 0.9.1

package/test/persona-settings.test.js

@@ -0,0 +1,145 @@
+// Persona settings (user_settings "persona" key) — v1.2 多卡模型。
+// Locks: legacy v1 single-object reads as default; byAgent cards round-trip;
+// corruption returns empty store without throwing; unknown fields dropped.
+// Whitelist lock guards the #254-style pit: a flag missing from
+// FEATURE_FLAG_BOOLEANS would make the panel toggle silently ineffective.
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createSettings } from "../src/settings.js";
+
+function setup() {
+  const store = createStore(":memory:");
+  const settings = createSettings(store.db);
+  return { store, settings };
+}
+
+test("persona defaults to empty store; default card round-trips via single-object form", () => {
+  const { store, settings } = setup();
+  assert.deepEqual(settings.getPersona(), { default: {}, byAgent: {} });
+  const input = {
+    name: "Amarre",
+    personality: "轻松幽默，讲解用类比",
+    replyStyle: "先给结论再解释",
+    enabled: false,
+    provenance: { sourceMemoryIds: [], generatedAt: "", reviewedByUser: false }
+  };
+  settings.setPersona(input);
+  const got = settings.getPersona();
+  assert.deepEqual(got.default, input);
+  assert.deepEqual(got.byAgent, {});
+  store.close();
+});
+
+test("default card write drops unknown fields", () => {
+  const { store, settings } = setup();
+  settings.setPersona({ name: "Amarre", sneaky: "field" });
+  const got = settings.getPersona();
+  assert.equal(got.default.name, "Amarre");
+  assert.equal("sneaky" in got.default, false);
+  store.close();
+});
+
+test("persona read of corrupt JSON returns empty store without throwing", () => {
+  const { store, settings } = setup();
+  settings.setPersona({ name: "seed" });
+  // 直改底层键模拟损坏（面板口径：坏值显示为空、可重写，不抛错）
+  store.db.prepare("UPDATE user_settings SET value = ? WHERE key = 'persona'").run("not json at all");
+  assert.deepEqual(settings.getPersona(), { default: {}, byAgent: {} });
+  store.close();
+});
+
+test("persona read of non-object JSON (array/number) returns empty store", () => {
+  const { store, settings } = setup();
+  store.db.prepare("INSERT INTO user_settings (key, value) VALUES ('persona', '[1,2]')").run();
+  assert.deepEqual(settings.getPersona(), { default: {}, byAgent: {} });
+  store.db.prepare("UPDATE user_settings SET value = '42' WHERE key = 'persona'").run();
+  assert.deepEqual(settings.getPersona(), { default: {}, byAgent: {} });
+  store.close();
+});
+
+test("setPersona tolerates non-object input (writes empty persona)", () => {
+  const { store, settings } = setup();
+  settings.setPersona(null);
+  assert.deepEqual(settings.getPersona(), { default: {}, byAgent: {} });
+  settings.setPersona("nope");
+  assert.deepEqual(settings.getPersona(), { default: {}, byAgent: {} });
+  store.close();
+});
+
+// ---- v1.2 多卡模型：{ default, byAgent }，旧单对象读作 default 兼容 ----------
+
+test("v1 legacy single-object persona reads as default (zero migration)", () => {
+  const { store, settings } = setup();
+  // 直写 v1 形（单对象）模拟存量库
+  store.db.prepare("INSERT INTO user_settings (key, value) VALUES ('persona', ?)")
+    .run(JSON.stringify({ name: "Amarre", personality: "轻松幽默", enabled: true }));
+  const got = settings.getPersona();
+  assert.equal(got.default.name, "Amarre");
+  assert.equal(got.default.enabled, true);
+  assert.deepEqual(got.byAgent, {});
+  store.close();
+});
+
+test("byAgent card round-trips via setPersonaFor/getPersonaFor", () => {
+  const { store, settings } = setup();
+  settings.setPersonaFor("zephyr", { name: "泽菲尔", personality: "冷危占有", enabled: true });
+  assert.deepEqual(settings.getPersonaFor("zephyr"), { name: "泽菲尔", personality: "冷危占有", enabled: true });
+  // default 仍在且未被影响
+  assert.deepEqual(settings.getPersona().default, {});
+  // 卡列表含 zephyr
+  assert.deepEqual(settings.listPersonas(), ["zephyr"]);
+  store.close();
+});
+
+test("getPersonaFor falls back to default when id card missing or disabled", () => {
+  const { store, settings } = setup();
+  settings.setPersona({ name: "Amarre", enabled: true }); // 单对象形写 default
+  settings.setPersonaFor("zephyr", { name: "泽菲尔", enabled: false }); // 卡存在但关
+  // 未注册身份 → default
+  assert.equal(settings.getPersonaFor("unknown-bot").name, "Amarre");
+  // 身份卡存在但 enabled=false → 落 default（兜底优先，不注入半张卡）
+  assert.equal(settings.getPersonaFor("zephyr").name, "Amarre");
+  // 身份缺失（null/空串）→ default
+  assert.equal(settings.getPersonaFor(null).name, "Amarre");
+  assert.equal(settings.getPersonaFor("").name, "Amarre");
+  store.close();
+});
+
+test("setPersona single-object form merges default and keeps byAgent", () => {
+  const { store, settings } = setup();
+  settings.setPersonaFor("zephyr", { name: "泽菲尔", enabled: true });
+  settings.setPersona({ name: "Amarre-新", enabled: true }); // 单对象形
+  const got = settings.getPersona();
+  assert.equal(got.default.name, "Amarre-新");
+  assert.equal(got.byAgent.zephyr.name, "泽菲尔", "byAgent must survive a legacy-form write");
+  store.close();
+});
+
+test("removePersona deletes byAgent card but default is protected", () => {
+  const { store, settings } = setup();
+  settings.setPersonaFor("zephyr", { name: "泽菲尔", enabled: true });
+  assert.equal(settings.removePersona("zephyr"), true);
+  assert.deepEqual(settings.listPersonas(), []);
+  assert.equal(settings.removePersona("default"), false, "default card cannot be removed");
+  assert.equal(settings.removePersona("ghost"), false);
+  store.close();
+});
+
+test("corrupt multi-card JSON reads as empty store without throwing", () => {
+  const { store, settings } = setup();
+  settings.setPersona({ name: "seed" });
+  store.db.prepare("UPDATE user_settings SET value = ? WHERE key = 'persona'").run("broken {");
+  assert.deepEqual(settings.getPersona(), { default: {}, byAgent: {} });
+  store.close();
+});
+
+test("personaEnabled is in the feature-flag boolean whitelist", () => {
+  const { store, settings } = setup();
+  // 写侧逐键校验的合并写：未知键抛 TypeError，白名单键可用——
+  // 这条锁防「白名单漏登记 → 面板开关静默失效」（#254 同型坑）。
+  settings.setFeatureFlags({ personaEnabled: true });
+  assert.equal(settings.getFeatureFlags().personaEnabled, true);
+  assert.throws(() => settings.setFeatureFlags({ notARealFlag: true }), TypeError);
+  store.close();
+});

package/test/pipeline-activities.test.js

@@ -0,0 +1,155 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { businessCommandOf, activityKey, tallyActivities } from "../src/pipeline-activities.js";
+
+// 这组测试守两件事：
+//   ① 分组结果落在「人能扫」的量级（业务命令才进清单，shell 语法不进）
+//   ② 🔴 隐私硬规则：位置参数一律丢弃——回执要显示在界面上，而完整命令行里
+//      几乎必然含绝对路径（路径里含本机用户名）。这一条比功能本身重要。
+
+test("业务命令：抽出 {动词, 子命令, 旗标}", () => {
+  assert.deepEqual(businessCommandOf("git status"), { verb: "git", sub: "status", flags: [] });
+  assert.deepEqual(businessCommandOf("git push origin main"), { verb: "git", sub: "push", flags: [] });
+  assert.deepEqual(businessCommandOf("gh pr merge --rebase"), { verb: "gh", sub: "pr", flags: ["--rebase"] });
+  assert.deepEqual(businessCommandOf("npm test"), { verb: "npm", sub: "test", flags: [] });
+  // 子命令可空
+  assert.deepEqual(businessCommandOf("npm"), { verb: "npm", sub: "", flags: [] });
+});
+
+test("🔴 隐私硬规则：位置参数一律丢弃，只留动词/子命令/旗标", () => {
+  // 实测里真实出现过这种形状：路径含本机用户名。回执绝不能把它带出去。
+  const r = businessCommandOf('set-location "c:\\users\\somebody\\desktop\\proj"; git commit -m "x"');
+  // 整段里第一个可识别的是 set-location（不在名单）→ 由分段器处理；这里直接测 git commit
+  assert.equal(businessCommandOf("git commit -m \"修好了\"").verb, "git");
+  assert.deepEqual(businessCommandOf("git commit -m \"修好了\"").flags, ["-m"]);
+  // 位置参数（文件名、分支名、路径）一个都不该出现在结果里
+  const withPath = businessCommandOf("git add src/foo.js C:/Users/name/x.md");
+  assert.equal(JSON.stringify(withPath).includes("Users"), false, "路径绝不能出现在结果里");
+  assert.equal(JSON.stringify(withPath).includes("foo.js"), false, "文件名是位置参数，该丢");
+});
+
+test("🔴 旗标里的路径参数也要挡住（--file=C:/x 这种）", () => {
+  const r = businessCommandOf("git commit --file=C:/Users/name/msg.txt -m x");
+  assert.equal(JSON.stringify(r).includes("Users"), false, "带路径的旗标不许原样带出");
+  // 纯旗标照常留
+  assert.deepEqual(businessCommandOf("gh pr list --state all").flags.includes("--state"), true);
+});
+
+test("非业务命令一律不产清单项（shell 语法不是活动）", () => {
+  // 实测里密度最高的就是这些——它们不是"做了什么"，是句子成分
+  for (const noise of [
+    'write-output "=== 检查 ==="',
+    "select-object -first 10",
+    "foreach-object { $_ }",
+    "echo hello",
+    "}",
+    "if (test-path x) { }",
+    "$erroractionpreference='continue'",
+    "cd C:/some/dir"
+  ]) {
+    assert.equal(businessCommandOf(noise), null, `${noise} 不该进清单`);
+  }
+});
+
+test("分段：一条命令里的多个业务动作分别计入", () => {
+  const r = tallyActivities([{ command: 'cd C:/x; git status; echo "---"; npm test' }]);
+  const keys = r.activities.map((a) => a.key).sort();
+  assert.deepEqual(keys, ["git status", "npm test"], "cd 与 echo 应被排除");
+  assert.equal(r.shellNoise, 2, "shell 噪音要单独计数，不能与业务动作混为一谈");
+  assert.equal(r.totalSegments, 4);
+});
+
+test("计数与排序：按出现次数降序，同次数按名字", () => {
+  const r = tallyActivities([
+    { command: "git status" },
+    { command: "npm test; git status" },
+    { command: "git status && gh pr list" }
+  ]);
+  assert.equal(r.activities[0].key, "git status");
+  assert.equal(r.activities[0].count, 3);
+  assert.equal(r.businessSegments, 5);
+});
+
+test("旗标并集：同一动作的不同旗标合并展示，且截断", () => {
+  const r = tallyActivities([
+    { command: "gh pr merge --rebase" },
+    { command: "gh pr merge --squash" }
+  ]);
+  assert.equal(r.activities.length, 1);
+  assert.equal(r.activities[0].count, 2);
+  assert.deepEqual(r.activities[0].flags.sort(), ["--rebase", "--squash"]);
+});
+
+test("🔴 回归：脚本路径不得被当成子命令（端到端实测抓到的真 bug）", () => {
+  // 实测里出现过 `node d:\dsh\.dsh\_tmp-mo-probe.mjs` —— 原实现把整条路径当 sub，
+  // 于是回执里带出本机路径（可能含用户名）。这正是隐私红线要挡的东西。
+  const r = businessCommandOf('node d:\\dsh\\.dsh\\_tmp-probe.mjs');
+  assert.equal(r.verb, "node");
+  assert.equal(JSON.stringify(r).includes("dsh"), false, "路径绝不能出现在结果里");
+  assert.equal(r.sub, "", "路径不是子命令，宁可留空");
+  // 相对路径同理
+  const r2 = businessCommandOf("node test/pipeline-nudge.test.js --test");
+  assert.equal(r2.sub, "", "文件名不是子命令");
+  assert.deepEqual(r2.flags, ["--test"]);
+});
+
+test("🔴 回归：`git -C <path> log` 要扫到 log，而不是把 `-C` 的值当子命令", () => {
+  // 实测出现过 `git (join-path -C --oneline --porcelain` 这种读不懂的清单行。
+  const r = businessCommandOf('git -C C:/some/dir log --oneline -3');
+  assert.equal(r.verb, "git");
+  assert.equal(r.sub, "log", "子命令在 -C 的值之后，必须扫描而不是取第一个");
+  assert.equal(JSON.stringify(r).includes("some"), false, "路径不许带出");
+});
+
+test("子命令形状窄：含 $、括号、引号、长串的一律不算", () => {
+  for (const bad of ["$p", "$(Get-Item", "C:/x/y", "d:\\a", "averyveryverylongsubcommandname", "'\"", "{", "@{"]) {
+    const r = businessCommandOf(`git ${bad} status`);
+    // 要么扫不到（sub 空），要么扫到 status；无论如何不能是那个坏值
+    assert.equal(r.sub === bad.toLowerCase(), false, `${bad} 不该被当成子命令`);
+  }
+});
+
+test("旗标里带 = 或路径的一律丢（--file=C:/x 这种）", () => {
+  const r = businessCommandOf("git commit --file=C:/Users/name/msg.txt -m x");
+  assert.equal(JSON.stringify(r).includes("Users"), false);
+  assert.deepEqual(r.flags, ["-m"], "带值/路径的旗标整个丢掉");
+});
+
+test("重定向与引号不影响识别", () => {
+  assert.deepEqual(businessCommandOf('npm test 2>&1 | Select-String "x"'), { verb: "npm", sub: "test", flags: [] });
+  assert.equal(businessCommandOf("'git' 'status'").verb, "git");
+});
+
+test("坏输入不抛：空、非串、缺字段一律安全返回", () => {
+  for (const bad of [null, undefined, "", "   ", 0, {}]) {
+    assert.equal(businessCommandOf(bad), null);
+  }
+  for (const bad of [null, undefined, [], [{}], [{ command: null }], [0, "x"]]) {
+    const r = tallyActivities(bad);
+    assert.deepEqual(r.activities, []);
+    assert.equal(typeof r.shellNoise, "number");
+  }
+  assert.equal(activityKey(null), "");
+});
+
+test("产出可读：key 是 `动词 子命令`，trim 过", () => {
+  assert.equal(activityKey({ verb: "git", sub: "status" }), "git status");
+  assert.equal(activityKey({ verb: "npm", sub: "" }), "npm");
+});
+
+test("没有子命令时用第一个旗标当键：node --test 与 node --check 不能并成一行", () => {
+  // 端到端实测里 16 次 node 调用被并成一条 —— 但它们语义不同（跑测试 vs 查语法）。
+  const r = tallyActivities([
+    { command: "node --test x.test.js" },
+    { command: "node --test y.test.js" },
+    { command: "node --check src/foo.js" }
+  ]);
+  const keys = r.activities.map((a) => a.key).sort();
+  assert.deepEqual(keys, ["node --check", "node --test"], "旗标区分语义，该分开");
+  assert.equal(r.activities.find((a) => a.key === "node --test").count, 2);
+});
+
+test("旗标只当补充：有子命令时键仍以子命令为准", () => {
+  const k = activityKey({ verb: "git", sub: "status", flags: ["-C", "--porcelain"] });
+  assert.equal(k, "git status", "-C 后面本来跟着被丢弃的路径，不该挤进键里");
+});

package/test/pipeline-attribution.test.js

@@ -0,0 +1,175 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  normalizeCommand,
+  commandParts,
+  attributionCandidates,
+  unattributableSteps,
+  normalizeObservation
+} from "../src/pipeline-attribution.js";
+
+// 这组测试守的是 M.O. 的**归属规则**：把宿主的一次工具动作映射到「可能是工作流的哪一步」。
+// 它最要紧的性质不是「能匹配上」，而是**认不出来时绝不许猜**——误匹配会让错误的步骤
+// 被染成可信，而漏匹配只是少一条账。所以下面失败的用例和成功的用例一样重要。
+
+function pipeline(steps) {
+  return {
+    id: "demo",
+    steps: steps.map((s) => ({
+      id: s.id,
+      tool: s.tool ?? "",
+      who: s.who ?? "main",
+      gate: s.gate === true
+    }))
+  };
+}
+
+// ── 归一化 ────────────────────────────────────────────────────────────────────
+
+test("归一化：大小写、占位符、多余空白都不影响比较", () => {
+  assert.equal(normalizeCommand("  NPM   Test  "), "npm test");
+  // 占位符是给人的读法，不是字面量——留着它会让 `git push <tag>` 谁都匹配不上。
+  assert.equal(normalizeCommand("git push <tag>"), "git push");
+  assert.equal(normalizeCommand("node script.mjs <版本>"), "node script.mjs");
+});
+
+test("占位符去掉而不是换成通配：不许宽到能匹配一切", () => {
+  // 若把 <tag> 换成 .*，下面这条就会命中——那是把「推 tag」与「推分支」混为一谈。
+  const p = pipeline([{ id: "T2", tool: "git push <tag>" }]);
+  const c = attributionCandidates({ command: "git push --force origin main" }, p);
+  assert.equal(c.every((x) => x.confidence !== "exact"), true, "占位符不该让任意参数都算「完全一致」");
+});
+
+test("并列命令按分隔符拆开，但路径里的斜杠不能把命令切碎", () => {
+  assert.deepEqual(commandParts("git log / gh pr list"), ["git log", "gh pr list"]);
+  assert.deepEqual(commandParts("npm run badge:sync"), ["npm run badge:sync"]);
+  // 这一段是防回归的关键：脚本路径里的 `/` 两侧无空白，不该被当分隔符。
+  assert.deepEqual(commandParts("node dsh-mneme/scripts/publish-gate.mjs <版本>"),
+    ["node dsh-mneme/scripts/publish-gate.mjs"]);
+});
+
+// ── 匹配 ──────────────────────────────────────────────────────────────────────
+
+test("完全一致：命令与步骤里写的对得上，给 exact 候选", () => {
+  const p = pipeline([{ id: "P6", tool: "npm test" }]);
+  const c = attributionCandidates({ command: "npm test" }, p);
+  assert.equal(c.length, 1);
+  assert.equal(c[0].stepId, "P6");
+  assert.equal(c[0].confidence, "exact");
+});
+
+test("抗噪：同前缀但不同子命令的步骤不该成为候选", () => {
+  // 真实工作流里 `git` 出现 5 次、`gh pr` 出现 4 次。若按「第一个词相同」匹配，
+  // 一次 `npm test` 会把所有 npm 步骤都报成候选——噪声盖过信号，人看一眼就放弃了。
+  const p = pipeline([
+    { id: "P5", tool: "npm run badge:sync" },
+    { id: "P6", tool: "npm test" }
+  ]);
+  const c = attributionCandidates({ command: "npm test" }, p);
+  assert.deepEqual(c.map((x) => x.stepId), ["P6"], "只该报真正对得上那一条");
+});
+
+test("词前缀才算 weak：同一步多带了参数应被认出来", () => {
+  const p = pipeline([{ id: "P3", tool: "gh pr create" }]);
+  const c = attributionCandidates({ command: "gh pr create --base main --title 补开发版" }, p);
+  assert.equal(c.length, 1);
+  assert.equal(c[0].confidence, "weak", "人写的是步骤名，agent 跑的是带参命令行——这该认出来");
+  assert.match(c[0].why, /gh pr create/);
+});
+
+test("命令头相同但参数对不上：给 weak 候选，并如实说明差在哪", () => {
+  const p = pipeline([{ id: "V2", tool: "git push" }]);
+  const c = attributionCandidates({ command: "git push --delete origin lane" }, p);
+  assert.equal(c.length, 1);
+  assert.equal(c[0].confidence, "weak");
+  // 理由里必须能看出「步骤写的是什么、这次是什么」，否则人没法判断该不该认。
+  assert.match(c[0].why, /git push/);
+  assert.match(c[0].why, /--delete/);
+});
+
+test("认不出来就是空数组——不许猜", () => {
+  const p = pipeline([{ id: "P6", tool: "npm test" }, { id: "T2", tool: "git tag" }]);
+  assert.deepEqual(attributionCandidates({ command: "docker compose up" }, p), []);
+  // 拼不出命令行时同样返回空，而不是退回「第一条」。
+  assert.deepEqual(attributionCandidates({ tool: "bash" }, p), []);
+});
+
+test("同一档多条候选全部返回，不替人挑一条", () => {
+  const p = pipeline([
+    { id: "A1", tool: "npm test" },
+    { id: "A2", tool: "npm test" }
+  ]);
+  const c = attributionCandidates({ command: "npm test" }, p);
+  assert.deepEqual(c.map((x) => x.stepId), ["A1", "A2"], "两条步骤长得一样时该由人消歧，机器不许自己选");
+  assert.equal(c.every((x) => x.confidence === "exact"), true);
+});
+
+test("空 tool 的步骤结构性地无法归属：不参与匹配，而不是匹配成「什么都能中」", () => {
+  const p = pipeline([{ id: "P4", tool: "" }, { id: "P6", tool: "npm test" }]);
+  const c = attributionCandidates({ command: "npm test" }, p);
+  assert.deepEqual(c.map((x) => x.stepId), ["P6"]);
+  assert.deepEqual(attributionCandidates({ command: "任意命令" }, pipeline([{ id: "P4", tool: "" }])), []);
+});
+
+test("exact 排在 weak 前面（给人看时先看最可能的那档）", () => {
+  // 同一次动作能同时命中两种档位时，exact 必须在前——人从第一条开始看，
+  // 把最可能的排在后面等于逼人先读完噪声。
+  const p = pipeline([
+    { id: "W", tool: "git push" },              // 这次跑的是 `git push --force`，只算 weak
+    { id: "E", tool: "git push --delete origin lane" } // 这次跑的正是它，exact
+  ]);
+  const c = attributionCandidates({ command: "git push --delete origin lane" }, p);
+  assert.equal(c[0].stepId, "E");
+  assert.equal(c[0].confidence, "exact");
+  assert.equal(c[1].stepId, "W");
+  assert.equal(c[1].confidence, "weak");
+});
+
+test("弱匹配受得住真实工作流的规模：一次 git push 不会把六条 git 步骤全报出来", () => {
+  // 真实那条 19 步的工作流里 git 系命令有 5 条。这条是抗噪的规模版回归锁。
+  const real = pipeline([
+    { id: "P1", tool: "git log / gh pr list" },
+    { id: "V2", tool: "git push" },
+    { id: "T1", tool: "git diff" },
+    { id: "T2", tool: "git tag / git push <tag>" },
+    { id: "F3", tool: "git push --delete / git worktree remove" }
+  ]);
+  const c = attributionCandidates({ command: "git push origin main" }, real);
+  const ids = c.map((x) => x.stepId);
+  // `git log` / `git diff` / `git push --delete` 都不算 `git push`（后者参数方向相反：
+  // 步骤写的是「git push --delete」，这次是「git push origin main」，谁也不是谁的前缀）。
+  assert.equal(ids.includes("P1"), false, "git log 不该被当成 git push");
+  assert.equal(ids.includes("T1"), false, "git diff 不该被当成 git push");
+  assert.equal(ids.includes("F3"), false, "git push --delete 与 git push origin main 是不同的两步");
+  // 只剩真的以 `git push` 起头、只是多带了参数的那两条。
+  assert.deepEqual(ids.sort(), ["T2", "V2"]);
+  assert.ok(ids.length < real.steps.length, "候选数必须少于总步数，否则等于没筛");
+});
+
+// ── 结构性不可归属 ────────────────────────────────────────────────────────────
+
+test("空 tool 的步骤被单独列出来：它是「为什么这一步永远没账」的答案", () => {
+  const p = pipeline([{ id: "P6", tool: "npm test" }, { id: "P4", tool: "" }]);
+  assert.deepEqual(unattributableSteps(p), ["P4"],
+    "没写 tool 的步骤永远不会拿到账——它与「还没跑过」必须分得开");
+  assert.deepEqual(unattributableSteps({ steps: [{ id: "X", tool: "   " }] }), ["X"], "空白 tool 同样不可归属");
+  assert.deepEqual(unattributableSteps(null), [], "坏输入返回空数组，不抛");
+});
+
+// ── 观察对象的形状 ────────────────────────────────────────────────────────────
+
+test("观察的三态 ok 必须保住：「失败」不能与「不知道」折叠成同一个值", () => {
+  assert.equal(normalizeObservation({ command: "npm test", ok: true }).ok, true);
+  assert.equal(normalizeObservation({ command: "npm test", ok: false }).ok, false);
+  // 宿主没给成败时留 null——把它当 false 会让「跑失败」与「没记录」不可分。
+  assert.equal(normalizeObservation({ command: "npm test" }).ok, null);
+  assert.equal(normalizeObservation({ tool: "bash" }), null, "拼不出命令行的观察不进归属");
+});
+
+test("坏输入都不抛：没有 pipeline、没有观察、空对象一律返回空数组", () => {
+  const p = pipeline([{ id: "A1", tool: "npm test" }]);
+  for (const bad of [null, undefined, {}, { command: "" }, 0]) {
+    assert.deepEqual(attributionCandidates(bad, p), [], `观察 ${JSON.stringify(bad)} 该返回空数组而不是抛`);
+  }
+  assert.deepEqual(attributionCandidates({ command: "x" }, null), []);
+});