@modusensus/dsh-mneme 0.9.0 → 0.9.2

package/test/pipeline-observations.test.js

@@ -0,0 +1,157 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, existsSync, readFileSync, appendFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  observationDir, validateObservationLine, saveObservations,
+  loadObservations, toolMismatches
+} from "../src/pipeline-observations.js";
+
+// P3 核心三件事的锁：
+//   ① 观察旁挂（丙）：append-only、幂等、🔴 不许命令原文进观察行
+//   ② toolMismatches：人确认 done 但声明 tool 没出现 → 提议修表
+//   ③ unsure/没答不进判据（那不是「做了但没看到」，是「没确认」）
+
+const tmp = mkdtempSync(join(tmpdir(), "mo-p3-"));
+test.after(() => { rmSync(tmp, { recursive: true, force: true }); });
+
+const PIPE = {
+  id: "demo",
+  steps: [
+    { id: "P6", title: "跑测试", tool: "npm test" },
+    { id: "V2", title: "推分支", tool: "git push" },
+    { id: "T4", title: "过闸门", tool: "node scripts/publish-gate.mjs" },
+    { id: "V1", title: "人过目", tool: "" }               // 纯人判步骤，无从矛盾
+  ]
+};
+
+test("observationDir：项目键分桶，空键拒绝", () => {
+  assert.equal(observationDir({ memoryDir: "D:/mem", projectKey: "proj-a1b2" }), join("D:/mem", "observations", "proj-a1b2"));
+  assert.equal(observationDir({ projectKey: "" }), null);
+  assert.equal(observationDir({}), null);
+});
+
+test("observationDir：~ / ~/ 前缀展开到主目录（config 默认值是波浪线路径，不展开 readdir 永远落空）", () => {
+  // candidates.js 的 expandHome 同构先例；不带 ~ 的路径原样通过
+  assert.equal(observationDir({ memoryDir: "D:/mem", projectKey: "p" }), join("D:/mem", "observations", "p"));
+  const fromTilde = observationDir({ memoryDir: "~/.dsh/memory", projectKey: "p" });
+  assert.ok(!fromTilde.startsWith("~"), `tilde must be expanded, got: ${fromTilde}`);
+  assert.ok(fromTilde.endsWith(join(".dsh", "memory", "observations", "p")), fromTilde);
+  const fromTildeSlash = observationDir({ memoryDir: "~/mem", projectKey: "p" });
+  assert.ok(!fromTildeSlash.startsWith("~"), fromTildeSlash);
+});
+
+test("🔴 隐私闸：命令原文/参数/分段出现在观察行里一律拒收", () => {
+  // 完整命令行含绝对路径（路径含本机用户名），这是第二道闸：上游漏了这里也不放行
+  for (const bad of [
+    { key: "npm test", count: 1, command: "npm test 2>&1" },
+    { key: "npm test", count: 1, args: { a: 1 } },
+    { key: "npm test", count: 1, segments: ["npm test"] },
+    { key: "", count: 1 },
+    { key: "npm test", count: 0 },
+    { key: "npm test", count: 1.5 },
+    { key: "npm test", count: 1, flags: "not-array" },
+    null, "x", 42
+  ]) {
+    const r = validateObservationLine(bad);
+    assert.equal(r.ok, false, JSON.stringify(bad) + " 不该通过");
+  }
+  // 合法形状（flags 可选）
+  assert.equal(validateObservationLine({ key: "npm test", count: 3 }).ok, true);
+  assert.equal(validateObservationLine({ key: "git status", count: 1, flags: ["--porcelain"] }).ok, true);
+});
+
+test("saveObservations：append-only + 按 confirmAt 幂等", () => {
+  const dir = join(tmp, "obs-1");
+  const acts = [{ key: "npm test", count: 5 }, { key: "git status", count: 2, flags: ["--porcelain"] }];
+  const r1 = saveObservations({ dir, pipelineId: "demo", confirmAt: "2026-10-17T01:00:00.000Z", activities: acts });
+  assert.equal(r1.ok, true);
+  assert.equal(r1.lines, 2);
+  assert.equal(existsSync(r1.file), true);
+
+  // 同一 confirmAt 再写 → 幂等，不追加
+  const r2 = saveObservations({ dir, pipelineId: "demo", confirmAt: "2026-10-17T01:00:00.000Z", activities: acts });
+  assert.equal(r2.duplicate, true);
+  assert.equal(r2.lines, 0);
+  assert.equal(readFileSync(r1.file, "utf8").trim().split("\n").length, 1, "文件只有一行");
+
+  // 不同 confirmAt → 追加
+  saveObservations({ dir, pipelineId: "demo", confirmAt: "2026-10-17T02:00:00.000Z", activities: acts });
+  assert.equal(readFileSync(r1.file, "utf8").trim().split("\n").length, 2);
+});
+
+test("saveObservations：dryRun 只校验不落盘", () => {
+  const dir = join(tmp, "obs-dry");
+  const r = saveObservations({ dir, pipelineId: "demo", confirmAt: "2026-10-17T03:00:00.000Z", activities: [{ key: "npm test", count: 1 }], dryRun: true });
+  assert.equal(r.ok, true);
+  assert.equal(existsSync(r.file), false, "dryRun 不许写文件");
+});
+
+test("saveObservations：坏行整体拒绝，不写半截", () => {
+  const dir = join(tmp, "obs-bad");
+  const r = saveObservations({
+    dir, pipelineId: "demo", confirmAt: "2026-10-17T04:00:00.000Z",
+    activities: [{ key: "npm test", count: 1 }, { key: "git add src/x.js", count: 1 }]
+  });
+  // "git add src/x.js" 是合法 key 形状吗？——是。真正被拒的是带原文的：
+  // 这里第二条换成显式违规形状再测
+  assert.equal(r.ok, true);
+
+  const r2 = saveObservations({
+    dir, pipelineId: "demo", confirmAt: "2026-10-17T05:00:00.000Z",
+    activities: [{ key: "npm test", count: 1, command: "npm test" }]
+  });
+  assert.equal(r2.ok, false, "带命令原文的行必须整体拒");
+  assert.match(r2.reason, /forbidden-field/);
+});
+
+test("loadObservations：读回 + 坏行计数不静默", () => {
+  const dir = join(tmp, "obs-load");
+  saveObservations({ dir, pipelineId: "demo", confirmAt: "2026-10-17T06:00:00.000Z", activities: [{ key: "npm test", count: 3 }] });
+  // 手工塞一行坏 JSON + 一行形状不对的
+  appendFileSync(join(dir, "demo.jsonl"), "{broken\n", "utf8");
+  appendFileSync(join(dir, "demo.jsonl"), JSON.stringify({ contract: "wrong/v9", activities: [] }) + "\n", "utf8");
+  const { records, unreadable } = loadObservations(dir, "demo");
+  assert.equal(records.length, 1);
+  assert.equal(unreadable, 2, "坏行要计数，不许静默");
+});
+
+test("🔴 toolMismatches：人确认 done 但声明的 tool 没出现 → 提议修表", () => {
+  const r = toolMismatches({
+    pipeline: PIPE,
+    confirmedDone: new Set(["P6", "V1"]),
+    activities: [{ key: "node --test", count: 9 }, { key: "git status", count: 4 }]
+  });
+  assert.equal(r.ok, true);
+  assert.equal(r.items.length, 1, "P6 声明 npm test 但没出现 → 唯一不符");
+  assert.equal(r.items[0].stepId, "P6");
+  assert.equal(r.items[0].declared, "npm test");
+  assert.deepEqual(r.items[0].observedTop, ["node --test ×9", "git status ×4"]);
+  // V1 无 tool 声明 → 无从矛盾，不该出现
+});
+
+test("🔴 多锚点（a / b）任一出现即算对上", () => {
+  const pipe = { id: "x", steps: [{ id: "P1", title: "看历史", tool: "git log / gh pr list" }] };
+  const hit = toolMismatches({ pipeline: pipe, confirmedDone: new Set(["P1"]), activities: [{ key: "gh pr list", count: 2 }] });
+  assert.equal(hit.items.length, 0, "第二个锚点出现了 → 不算不符");
+  const miss = toolMismatches({ pipeline: pipe, confirmedDone: new Set(["P1"]), activities: [{ key: "git status", count: 2 }] });
+  assert.equal(miss.items.length, 1);
+});
+
+test("🔴 unsure 与没答不进判据（没确认 ≠ 做了但没看到）", () => {
+  const r = toolMismatches({
+    pipeline: PIPE,
+    confirmedDone: new Set([]),          // 什么都没确认
+    activities: [{ key: "git status", count: 1 }]
+  });
+  assert.equal(r.items.length, 0, "没人说 done，就不该有任何「不符」提议");
+});
+
+test("坏输入不抛", () => {
+  assert.equal(toolMismatches({ pipeline: null, confirmedDone: new Set(), activities: [] }).reason, "no-pipeline");
+  assert.equal(toolMismatches({ pipeline: PIPE, confirmedDone: [], activities: [] }).reason, "bad-confirmed");
+  assert.equal(toolMismatches({ pipeline: PIPE, confirmedDone: new Set(), activities: "x" }).reason, "bad-activities");
+  assert.equal(saveObservations({}).reason, "no-dir");
+  assert.equal(loadObservations(null, "demo").records.length, 0);
+});

package/test/pipeline-observe.test.js

@@ -0,0 +1,127 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { commandFromToolCall, outcomeOfToolResult, pairObservations } from "../src/pipeline-observe.js";
+
+// 这组测试守的是「会话事件 → 观察」这一层的三条纪律。它们都来自接线前的实测：
+// 真实会话里的工具名是 pwsh/read/glob，而工作流写的是 npm/git/gh 命令行——两者不重叠。
+
+test("命令执行器：从 pwsh 的参数里抽出命令行（实测唯一能对上的通路）", () => {
+  assert.deepEqual(
+    commandFromToolCall("pwsh", '{"command":"npm test","description":"跑测试"}'),
+    { tool: "pwsh", command: "npm test" }
+  );
+  // 对象形状与 JSON 串形状都要认：宿主两种都出现过。
+  assert.deepEqual(
+    commandFromToolCall("pwsh", { command: "git push origin main" }),
+    { tool: "pwsh", command: "git push origin main" }
+  );
+  assert.equal(commandFromToolCall("bash", '{"cmd":"npm run sync"}').command, "npm run sync");
+});
+
+test("非命令执行器一律不给观察：read/glob/grep 是代理日常动作，不是工作流的一步", () => {
+  // 硬把 read 的文件路径拼成「命令行」去匹配，只会制造噪声——噪声的代价是凭空染色。
+  assert.equal(commandFromToolCall("read", '{"file_path":"C:\\\\x\\\\y.md"}'), null);
+  assert.equal(commandFromToolCall("glob", '{"pattern":"**/*.js"}'), null);
+  assert.equal(commandFromToolCall("grep", '{"pattern":"foo"}'), null);
+  assert.equal(commandFromToolCall("write", '{"content":"hello"}'), null);
+});
+
+test("是执行器但抽不出命令行：不猜，返回 null（形状变了也不硬凑）", () => {
+  assert.equal(commandFromToolCall("pwsh", '{"description":"忘了给命令"}'), null);
+  assert.equal(commandFromToolCall("pwsh", "不是 JSON"), null);
+  assert.equal(commandFromToolCall("pwsh", "[]"), null);
+  assert.equal(commandFromToolCall("", '{"command":"npm test"}'), null);
+  assert.equal(commandFromToolCall("pwsh", '{"command":"   "}'), null);
+});
+
+test("成败三态：只有布尔才算数，「不知道」不许折叠成「失败」", () => {
+  assert.equal(outcomeOfToolResult({ data: { message: { isError: false } } }), true);
+  assert.equal(outcomeOfToolResult({ data: { message: { isError: true } } }), false);
+  // 拿不到 isError 时留 null——当成 false 会给这一步打上不该有的 refuted 标记。
+  assert.equal(outcomeOfToolResult({ data: { message: {} } }), null);
+  assert.equal(outcomeOfToolResult({ data: {} }), null);
+  assert.equal(outcomeOfToolResult({}), null);
+  // 旧形状：isError 挂在 content 的 tool-result 块上。
+  assert.equal(outcomeOfToolResult({ data: { message: { content: [{ type: "tool-result", isError: true }] } } }), false);
+  assert.equal(outcomeOfToolResult({ data: { message: { content: [{ type: "tool-result", isError: false }] } } }), true);
+});
+
+test("配对靠 callId，且只有拿到结果的调用才产观察", () => {
+  const events = [
+    { type: "tool/call", at: "2026-10-16T12:00:00.000Z", data: { callId: "c1", name: "pwsh", arguments: '{"command":"npm test"}' } },
+    { type: "tool/result", data: { callId: "c1", message: { isError: false } } },
+    { type: "tool/call", at: "2026-10-16T12:00:05.000Z", data: { callId: "c2", name: "pwsh", arguments: '{"command":"git push"}' } },
+    { type: "tool/result", data: { callId: "c2", message: { isError: true } } }
+  ];
+  const { observations, dangling, notCommands } = pairObservations(events);
+  assert.equal(observations.length, 2);
+  assert.deepEqual(observations[0], { tool: "pwsh", command: "npm test", ok: true, at: "2026-10-16T12:00:00.000Z" });
+  assert.equal(observations[1].ok, false, "失败要如实带出来");
+  assert.equal(dangling.length, 0);
+  assert.equal(notCommands, 0);
+});
+
+test("调了但没结果：进 dangling，既不产观察也不假装失败", () => {
+  // 「中断了」既不是成功也不是失败；拿它当一次成功使用是编造。
+  const { observations, dangling } = pairObservations([
+    { type: "tool/call", data: { callId: "c9", name: "pwsh", arguments: '{"command":"npm publish"}' } }
+  ]);
+  assert.equal(observations.length, 0);
+  assert.equal(dangling.length, 1);
+  assert.match(dangling[0].why, /没有等到结果/);
+});
+
+test("没有 callId 的调用不硬凑配对，如实进 dangling", () => {
+  const { observations, dangling } = pairObservations([
+    { type: "tool/call", data: { name: "pwsh", arguments: '{"command":"npm test"}' } }
+  ]);
+  assert.equal(observations.length, 0);
+  assert.equal(dangling.length, 1);
+  assert.match(dangling[0].why, /没有 callId/);
+});
+
+test("非命令工具的调用计入 notCommands，不产观察也不出错", () => {
+  const { observations, notCommands } = pairObservations([
+    { type: "tool/call", data: { callId: "r1", name: "read", arguments: '{"file_path":"x.md"}' } },
+    { type: "tool/result", data: { callId: "r1", message: { isError: false } } },
+    { type: "tool/call", data: { callId: "p1", name: "pwsh", arguments: '{"command":"npm test"}' } },
+    { type: "tool/result", data: { callId: "p1", message: { isError: false } } }
+  ]);
+  assert.equal(notCommands, 1);
+  assert.equal(observations.length, 1);
+  assert.equal(observations[0].command, "npm test");
+});
+
+test("坏输入不抛：空、非数组、缺字段一律返回空结果", () => {
+  for (const bad of [null, undefined, [], [{}], [{ type: "tool/call" }], [{ type: "tool/result" }], [0, "x"]]) {
+    const r = pairObservations(bad);
+    assert.equal(Array.isArray(r.observations), true);
+    assert.equal(Array.isArray(r.dangling), true);
+    assert.equal(typeof r.notCommands, "number");
+  }
+});
+
+test("观察能直接喂给执行窗口：两个模块的契约对得上", async () => {
+  const { openRun } = await import("../src/pipeline-exec.js");
+  const { validatePipeline } = await import("../src/pipeline.js");
+  const p = validatePipeline({
+    id: "demo", name: "演示", project: "a/b", version: 0, status: "active", done: "走完",
+    trigger: [{ kind: "phrase", value: "走一遍" }],
+    steps: [{
+      id: "P6", phase: "准备", title: "跑测试", when: "改完", do: "npm test",
+      who: "main", tool: "npm test", done: "全绿", risk: "R0", needs: [], why: "因为"
+    }]
+  }, "demo.json");
+
+  const { observations } = pairObservations([
+    { type: "tool/call", at: "2026-10-16T12:00:00.000Z", data: { callId: "c1", name: "pwsh", arguments: '{"command":"npm test"}' } },
+    { type: "tool/result", data: { callId: "c1", message: { isError: false } } }
+  ]);
+
+  const run = openRun({ pipeline: p, now: () => new Date("2026-10-16T12:00:10.000Z") });
+  for (const obs of observations) run.observe(obs);
+  const closed = run.close();
+
+  assert.deepEqual(closed.run.steps.map((s) => s.id), ["P6"], "实测链路：事件 → 观察 → 归属 → 一步进账");
+  assert.equal(closed.run.steps[0].refuted, false);
+});

package/test/pipeline-r1r2.test.js

@@ -0,0 +1,149 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { validatePipeline, suggestRetirements } from "../src/pipeline.js";
+
+// R1/R2 + P3 投影的判据锁。
+// 核心不变量：**四类提议互不吞并**（07 号文的教训——第一版 if/else if，
+// 绕行把跳过吃掉了）。每类有自己的触发条件，可以并存，谁也不许吃掉谁。
+
+function makePipeline(steps) {
+  return validatePipeline({
+    id: "demo", name: "演示", project: "a/b", version: 0, status: "active", done: "走完",
+    trigger: [{ kind: "phrase", value: "走一遍" }],
+    steps
+  }, "demo.json");
+}
+
+const BASE_STEP = {
+  phase: "p", when: "w", do: "d", who: "main", done: "dn", risk: "R0", why: "y"
+};
+const step = (id, extra = {}) => ({ id, title: id, tool: "", needs: [], ...BASE_STEP, ...extra });
+
+const RUN = (at, steps) => ({ at, by: "human", triggeredBy: "demo", steps });
+
+test("R2：optional 步骤被跳 3 次 → optional-skip-ok 信息项，绝不提议删", () => {
+  const p = makePipeline([step("OPT", { optional: true, tool: "npm run lint" })]);
+  const runs = [1, 2, 3].map((i) => RUN(`2026-10-0${i}T00:00:00Z`, [{ id: "OPT", at: "x", skipped: true }]));
+  const out = suggestRetirements(p, { runs });
+  const kinds = out.map((s) => s.kind);
+  assert.equal(kinds.includes("drop-step"), false, "可选步骤绝不能被提议删");
+  assert.equal(kinds.includes("optional-skip-ok"), true, "给一条信息项供人留意");
+});
+
+test("R2：必经步骤被跳 3 次 → drop-step 与 rework-path 并存（两种读法都给人）", () => {
+  const p = makePipeline([step("REQ", { tool: "npm test" })]);
+  const runs = [1, 2, 3].map((i) => RUN(`2026-10-0${i}T00:00:00Z`, [{ id: "REQ", at: "x", skipped: true }]));
+  const out = suggestRetirements(p, { runs });
+  // 必经的一步总被跳：既可能是「这步多余」（删），也可能是「流程写错」（修图）。
+  // 两种读法同时给——07 号文教训的反面：不许 if/else 吞掉任何一种。
+  assert.equal(out.some((s) => s.kind === "rework-path" && s.because.includes("必经")), true);
+  assert.equal(out.some((s) => s.kind === "drop-step"), true, "从未 uses 的必经步骤，删步候选也在");
+});
+
+test("drop-step 只给「必经且从未 uses 且被跳够数」的步骤", () => {
+  // never used：账本里只有 skipped 行、无 uses
+  const p = makePipeline([step("GHOST", { tool: "gh pr merge --rebase" })]);
+  const runs = [1, 2, 3].map((i) => RUN(`2026-10-0${i}T00:00:00Z`, [{ id: "GHOST", at: "x", skipped: true }]));
+  const out = suggestRetirements(p, { runs });
+  // 与 rework-path 并存（必经被跳也成立），但 drop-step 必须在
+  assert.equal(out.some((s) => s.kind === "drop-step" && s.stepId === "GHOST"), true, "写进清单但从不执行 → 才是删步候选");
+  // 而 optional 同形状不给 drop-step
+  const p2 = makePipeline([step("G2", { optional: true, tool: "x" })]);
+  const out2 = suggestRetirements(p2, { runs });
+  assert.equal(out2.some((s) => s.kind === "drop-step"), false);
+});
+
+test("R1：前置违规一次就报——done 了后继但 needs 前置整条缺失", () => {
+  const p = makePipeline([
+    step("A", { tool: "npm test" }),
+    step("B", { tool: "git push", needs: ["A"] })
+  ]);
+  // 只做了 B，A 连行都没有 → 违规
+  const runs = [RUN("2026-10-17T00:00:00Z", [{ id: "B", at: "x" }])];
+  const out = suggestRetirements(p, { runs });
+  const v = out.filter((s) => s.kind === "violation-precedence");
+  assert.equal(v.length, 1, "一次就报，不攒次数");
+  assert.equal(v[0].stepId, "B");
+  assert.match(v[0].because, /A/);
+});
+
+test("R1：前置做过（哪怕 skipped）不算违规；多前置断在缺的那条边上", () => {
+  const p = makePipeline([
+    step("A"), step("C"),
+    step("B", { needs: ["A", "C"] })
+  ]);
+  // A 做了、C 被跳过 → 前置都「有着落」，不违规
+  const ok = suggestRetirements(p, { runs: [RUN("t1", [{ id: "A", at: "x" }, { id: "C", at: "x", skipped: true }, { id: "B", at: "x" }])] });
+  assert.equal(ok.filter((s) => s.kind === "violation-precedence").length, 0);
+  // A 做了、C 整条没有 → 恰好一条，点名 C
+  const bad = suggestRetirements(p, { runs: [RUN("t2", [{ id: "A", at: "x" }, { id: "B", at: "x" }])] });
+  const v = bad.filter((s) => s.kind === "violation-precedence");
+  assert.equal(v.length, 1);
+  assert.match(v[0].because, /C/);
+});
+
+test("🔴 四类互不吞并：同一 run 里能并存的都出现", () => {
+  const p = makePipeline([
+    step("OPT", { optional: true }),
+    step("GHOST", { tool: "x" }),
+    step("A", { tool: "npm test" }),
+    step("B", { tool: "git push", needs: ["A"] })
+  ]);
+  const runs = [
+    // OPT 被跳（optional-skip-ok）；GHOST 被跳（drop-step 候选）；
+    // B done 而 A 缺（violation-precedence）
+    RUN("t1", [{ id: "OPT", at: "x", skipped: true }, { id: "GHOST", at: "x", skipped: true }, { id: "B", at: "x" }]),
+    RUN("t2", [{ id: "OPT", at: "x", skipped: true }, { id: "GHOST", at: "x", skipped: true }, { id: "B", at: "x" }]),
+    RUN("t3", [{ id: "OPT", at: "x", skipped: true }, { id: "GHOST", at: "x", skipped: true }, { id: "B", at: "x" }])
+  ];
+  const kinds = suggestRetirements(p, { runs }).map((s) => s.kind);
+  for (const k of ["optional-skip-ok", "drop-step", "violation-precedence", "rework-path"]) {
+    assert.equal(kinds.includes(k), true, `缺 ${k}`);
+  }
+});
+
+test("P3 投影：声明 tool 从未出现在观察里 + 被确认做过 → fix-step-tool", () => {
+  const p = makePipeline([
+    step("P6", { tool: "npm test" }),
+    step("V2", { tool: "git push", needs: ["P6"] })
+  ]);
+  const runs = [RUN("t1", [{ id: "P6", at: "x" }])]; // 人确认 P6 做了
+  const observed = { latest: { activities: [{ key: "node --test", count: 9 }, { key: "git status", count: 4 }] } };
+  const out = suggestRetirements(p, { runs, observed });
+  const f = out.filter((s) => s.kind === "fix-step-tool");
+  assert.equal(f.length, 1, "P6 声明 npm test 未出现 → 一条");
+  assert.equal(f[0].stepId, "P6");
+  assert.deepEqual(f[0].observedTop, ["node --test ×9", "git status ×4"]);
+});
+
+test("P3 投影：多锚点任一命中即对上；optional/无 tool/未确认过 全部不进判据", () => {
+  const p = makePipeline([
+    step("P1", { tool: "git log / gh pr list" }),
+    step("V1", { tool: "" }),
+    step("OPT", { optional: true, tool: "npm run lint" })
+  ]);
+  const runs = [RUN("t1", [{ id: "P1", at: "x" }, { id: "V1", at: "x" }, { id: "OPT", at: "x" }])];
+  // 观察里有 gh pr list → P1 对上；观察为空 → V1/OPT 也不该报（V1 无声明、OPT 可选）
+  const out = suggestRetirements(p, { runs, observed: { latest: { activities: [{ key: "gh pr list", count: 2 }] } } });
+  assert.equal(out.filter((s) => s.kind === "fix-step-tool").length, 0);
+  // 换成啥都没有的观察：P1 的两个锚点都没出现 → 报
+  const out2 = suggestRetirements(p, { runs, observed: { latest: { activities: [{ key: "docker ps", count: 1 }] } } });
+  const f = out2.filter((s) => s.kind === "fix-step-tool");
+  assert.equal(f.length, 1);
+  assert.equal(f[0].stepId, "P1");
+});
+
+test("P3 投影：没传 observed 时行为与旧版完全一致（零回归）", () => {
+  const p = makePipeline([step("A", { tool: "npm test" }), step("B", { needs: ["A"] })]);
+  const runs = [RUN("t1", [{ id: "OPT0", at: "x", skipped: true }])];
+  const a = suggestRetirements(p, { runs });
+  const b = suggestRetirements(p, { runs, observed: null });
+  assert.deepEqual(a, b);
+});
+
+test("坏输入不抛", () => {
+  const p = makePipeline([step("A")]);
+  assert.doesNotThrow(() => suggestRetirements(p, { runs: null }));
+  assert.doesNotThrow(() => suggestRetirements(p, { runs: [{}] }));
+  assert.doesNotThrow(() => suggestRetirements(p, { runs: [{ at: null, steps: null }] }));
+});