@modusensus/dsh-mneme 0.9.0 → 0.9.1

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), []);
+});

package/test/pipeline-command.test.js

@@ -0,0 +1,243 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { parseMoRunInput, createMoRunHandler, registerMoRunCommand, MO_RUN_COMMAND } from "../src/pipeline-command.js";
+
+// 这组测试守的是 `/mo-run` 的回执质量。命令回执是这个功能**唯一的对外窗口**
+// （面板侧还没做），所以最要紧的性质是：**失败必须说清是哪种失败**，
+// 尤其「一条观察都没认出来」绝不能被含糊成「完成」。
+
+test("解析：三种子命令 + 默认看状态 + 不认识的词给用法", () => {
+  assert.deepEqual(parseMoRunInput("start dsh-mneme-release"), { action: "start", pipelineId: "dsh-mneme-release" });
+  assert.deepEqual(parseMoRunInput("stop"), { action: "stop" });
+  assert.deepEqual(parseMoRunInput("status"), { action: "status" });
+  // 不带参数 = 看状态：最安全的默认，不会误开窗
+  assert.deepEqual(parseMoRunInput(""), { action: "status" });
+  assert.deepEqual(parseMoRunInput("   "), { action: "status" });
+  assert.deepEqual(parseMoRunInput(null), { action: "status" });
+  assert.equal(parseMoRunInput("whatever").action, "help");
+  // 大小写不敏感，id 里带空格也能取全
+  assert.deepEqual(parseMoRunInput("START a b"), { action: "start", pipelineId: "a b" });
+});
+
+/** 造一个受控的假记录器，回执里只看它返回的东西怎么被翻译。 */
+function fakeRecorder({ start, stop, status, confirm } = {}) {
+  return {
+    start: start ?? (() => ({ ok: true, pipelineId: "demo", steps: 3 })),
+    stop: stop ?? (() => ({ ok: true, pipelineId: "demo", steps: 2 })),
+    // P2 起 stop 不再落盘，默认返回"待确认"
+    status: status ?? (() => ({ open: false })),
+    confirm: confirm ?? (() => ({ ok: true, pipelineId: "demo", steps: 1, notDone: [], unsure: [], unanswered: [] }))
+  };
+}
+
+const invocation = (rawInput) => ({ rawInput, agent: { session: { id: "s1" } } });
+
+test("start 成功：说清开了哪条、几步", () => {
+  const h = createMoRunHandler({ recorder: fakeRecorder(), language: () => "zh" });
+  const r = h(invocation("start demo"));
+  assert.equal(r.kind, "success");
+  assert.match(r.text, /已开窗/);
+  assert.match(r.text, /demo/);
+  assert.match(r.text, /3 步/);
+});
+
+test("start 已开着窗口：给的是「先 stop」，而不是静默顶掉", () => {
+  const h = createMoRunHandler({
+    recorder: fakeRecorder({ start: () => ({ ok: false, reason: "already-open", pipelineId: "old" }) }),
+    language: () => "zh"
+  });
+  const r = h(invocation("start demo"));
+  assert.match(r.text, /already|已经开着|旧|old|先/);
+});
+
+test("start 找不到工作流：把可用清单给出来（别让人猜）", () => {
+  const h = createMoRunHandler({
+    recorder: fakeRecorder({ start: () => ({ ok: false, reason: "pipeline-not-found", available: ["a", "b"] }) }),
+    language: () => "zh"
+  });
+  const r = h(invocation("start nope"));
+  assert.match(r.text, /a/);
+  assert.match(r.text, /b/);
+});
+
+test("start 读不出来与没有这条是两种话——不许合并成同一句", () => {
+  const unreadable = createMoRunHandler({
+    recorder: fakeRecorder({ start: () => ({ ok: false, reason: "pipeline-unreadable", detail: "坏 JSON" }) }),
+    language: () => "zh"
+  });
+  const notFound = createMoRunHandler({
+    recorder: fakeRecorder({ start: () => ({ ok: false, reason: "pipeline-not-found", available: [] }) }),
+    language: () => "zh"
+  });
+  assert.notEqual(unreadable(invocation("start demo")).text, notFound(invocation("start demo")).text);
+  assert.match(unreadable(invocation("start demo")).text, /坏 JSON/);
+});
+
+test("P2：stop 产出待确认清单，明说「还没有写账」并给出步骤表", () => {
+  const h = createMoRunHandler({
+    recorder: fakeRecorder({
+      stop: () => ({
+        ok: true, state: "awaiting-confirmation", notCommands: 5, truncated: false,
+        activities: [{ key: "npm test", count: 3, flags: [] }],
+        proposal: {
+          pipelineId: "demo",
+          steps: [
+            { id: "P6", title: "跑测试", declared: "npm test", hintCount: 2 },
+            { id: "V2", title: "推分支", declared: "git push", hintCount: 0 }
+          ]
+        }
+      })
+    }),
+    language: () => "zh"
+  });
+  const r = h(invocation("stop"));
+  assert.match(r.text, /还没有写账/, "必须明确说这一版不自动落盘");
+  assert.match(r.text, /P6/, "步骤表要给出来供人勾");
+  assert.match(r.text, /V2/);
+  assert.match(r.text, /confirm/, "要给出怎么写确认");
+  assert.match(r.text, /npm test ×3/, "观察到的动作清单也要给");
+});
+
+test("P2：confirm 成功 → 报步数，并把「没做」「不确定」「没提到」分开", () => {
+  const h = createMoRunHandler({
+    recorder: fakeRecorder({
+      confirm: () => ({ ok: true, pipelineId: "demo", steps: 1, notDone: ["V2"], unsure: [], unanswered: ["A3"] })
+    }),
+    language: () => "zh"
+  });
+  const r = h(invocation("confirm P6"));
+  assert.equal(r.kind, "success");
+  assert.match(r.text, /记入账本/);
+  assert.match(r.text, /V2/);
+  assert.match(r.text, /A3/);
+});
+
+test("P2：confirm 的关键一条——什么都没确认时明说没落盘，不许含糊成完成", () => {
+  const h = createMoRunHandler({
+    recorder: fakeRecorder({
+      confirm: () => ({ ok: false, reason: "no-answers", notDone: 0, unsure: 1, unanswered: 1 })
+    }),
+    language: () => "zh"
+  });
+  const r = h(invocation("confirm P6:?"));
+  assert.equal(r.kind, "error");
+  assert.match(r.text, /没有落盘/, "必须明确说没写账");
+});
+
+test("P2：confirm 解析——`P6` 表示做了，`V2:-` 没做，`A3:?` 不确定", () => {
+  const seen = [];
+  const h = createMoRunHandler({
+    recorder: fakeRecorder({ confirm: (arg) => { seen.push(arg.answers); return { ok: true, pipelineId: "d", steps: 1, notDone: [], unsure: [], unanswered: [] }; } }),
+    language: () => "zh"
+  });
+  h(invocation("confirm P6 V2:- A3:?"));
+  assert.deepEqual(seen[0], { P6: "done", V2: "notDone", A3: "unsure" });
+  // 非法标记不放进结果（不是「没做」，是「没答」）
+  h(invocation("confirm P6:xyz"));
+  assert.deepEqual(seen[1], {});
+  // 逗号也当分隔符
+  h(invocation("confirm P6,V2"));
+  assert.deepEqual(seen[2], { P6: "done", V2: "done" });
+});
+
+test("P2：没待确认清单时 confirm 说清先做什么", () => {
+  const h = createMoRunHandler({
+    recorder: fakeRecorder({ confirm: () => ({ ok: false, reason: "nothing-to-confirm" }) }),
+    language: () => "zh"
+  });
+  const r = h(invocation("confirm P6"));
+  assert.match(r.text, /没有待确认/);
+  assert.match(r.text, /mo-run start/);
+});
+
+test("P2：非法回答/未知步骤各自说清", () => {
+  const bad = createMoRunHandler({
+    recorder: fakeRecorder({ confirm: () => ({ ok: false, reason: "bad-answer-value", stepId: "P6", value: "yes" }) }),
+    language: () => "zh"
+  });
+  assert.match(bad(invocation("confirm P6:yes")).text, /不合法/);
+
+  const unknown = createMoRunHandler({
+    recorder: fakeRecorder({ confirm: () => ({ ok: false, reason: "unknown-step", stepId: "NOPE" }) }),
+    language: () => "zh"
+  });
+  assert.match(unknown(invocation("confirm NOPE")).text, /NOPE/);
+});
+
+test("stop 没有开着窗口 / 写盘失败：各自说清，不混为一谈", () => {
+  const none = createMoRunHandler({
+    recorder: fakeRecorder({ stop: () => ({ ok: false, reason: "no-open-window" }) }),
+    language: () => "zh"
+  });
+  const failed = createMoRunHandler({
+    recorder: fakeRecorder({ stop: () => ({ ok: false, reason: "write-failed", detail: "磁盘满" }) }),
+    language: () => "zh"
+  });
+  assert.match(none(invocation("stop")).text, /没有开着窗口/);
+  assert.match(failed(invocation("stop")).text, /磁盘满/);
+  assert.notEqual(none(invocation("stop")).text, failed(invocation("stop")).text);
+});
+
+test("status：要能分辨「关着」「开着」「等你确认」三种状态", () => {
+  const closed = createMoRunHandler({ recorder: fakeRecorder({ status: () => ({ open: false }) }), language: () => "zh" });
+  assert.match(closed(invocation("status")).text, /没有开着/);
+
+  const awaiting = createMoRunHandler({ recorder: fakeRecorder({ status: () => ({ open: false, awaitingConfirmation: true, pipelineId: "demo", steps: 3 }) }), language: () => "zh" });
+  assert.match(awaiting(invocation("status")).text, /等你在确认|确认/, "等待确认是一个独立状态");
+
+  const open = createMoRunHandler({
+    recorder: fakeRecorder({
+      status: () => ({ open: true, pipelineId: "demo", startedAt: "2026-10-16T12:00:00.000Z", bufferedEvents: 7, recorded: ["P6"], unattributed: 1, ambiguous: 0, truncated: false })
+    }),
+    language: () => "zh"
+  });
+  const r = open(invocation("status"));
+  assert.match(r.text, /demo/);
+  assert.match(r.text, /7 条事件/);
+  assert.match(r.text, /P6/);
+});
+
+test("英文实例：同一组结果翻成英文，不落回中文", () => {
+  const h = createMoRunHandler({
+    recorder: fakeRecorder({ confirm: () => ({ ok: false, reason: "no-answers", notDone: 0, unsure: 1, unanswered: 1 }) }),
+    language: () => "en"
+  });
+  const r = h(invocation("confirm P6:?"));
+  assert.match(r.text, /nothing was persisted/i);
+});
+
+test("注册默认关：旗标不是 true 时一个命令都不注册", () => {
+  const registered = [];
+  const ctx = { commands: { register: (c) => { registered.push(c); return () => {}; } } };
+  assert.equal(registerMoRunCommand({ ctx, recorder: fakeRecorder(), enabled: false }), null);
+  assert.equal(registerMoRunCommand({ ctx, recorder: fakeRecorder(), enabled: undefined }), null);
+  assert.equal(registered.length, 0, "默认关时不许注册");
+});
+
+test("注册打开：命令名走小写字母起头的约定，且带描述与用法提示", () => {
+  const registered = [];
+  const ctx = { commands: { register: (c) => { registered.push(c); return () => {}; } } };
+  const dispose = registerMoRunCommand({ ctx, recorder: fakeRecorder(), enabled: true, language: () => "zh" });
+  assert.equal(typeof dispose, "function");
+  assert.equal(registered.length, 1);
+  assert.equal(registered[0].name, MO_RUN_COMMAND);
+  assert.match(registered[0].name, /^[a-z][a-z0-9_-]*$/);
+  assert.ok(registered[0].description);
+  assert.ok(registered[0].input?.hint);
+  assert.equal(typeof registered[0].handler, "function");
+});
+
+test("没有命令注册表时不硬注册（返回 null，由装配方决定要不要降级）", () => {
+  assert.equal(registerMoRunCommand({ ctx: {}, recorder: fakeRecorder(), enabled: true }), null);
+  assert.equal(registerMoRunCommand({ ctx: null, recorder: fakeRecorder(), enabled: true }), null);
+});
+
+test("handler 抛异常也不许把异常抛进宿主：退化成用法提示", () => {
+  const h = createMoRunHandler({
+    recorder: { start: () => { throw new Error("炸了"); }, stop: () => {}, status: () => {} },
+    language: () => "zh"
+  });
+  const r = h(invocation("start demo"));
+  assert.equal(r.kind, "error");
+  assert.ok(r.text);
+});

package/test/pipeline-confirm.test.js

@@ -0,0 +1,148 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { buildProposal, normalizeAnswers, runFromAnswers } from "../src/pipeline-confirm.js";
+import { validatePipeline } from "../src/pipeline.js";
+
+// 这组测试守的是 P2 的核心语义：**机器不猜，人确认才写账**。
+// 最要紧的三条：
+//   ① 提案不改动任何东西（纯函数）
+//   ② unsure / 没回答 ≠ notDone——前者什么都不写，后者记 skipped
+//   ③ 一步都没确认走过 → 不产 run（账本契约不许零步），而不是伪造一条空的
+
+function makePipeline() {
+  return validatePipeline({
+    id: "demo", name: "演示", project: "a/b", version: 0, status: "active", done: "走完",
+    trigger: [{ kind: "phrase", value: "走一遍" }],
+    steps: [
+      { id: "P6", phase: "p", title: "跑测试", when: "w", do: "d", who: "main", tool: "npm test", done: "dn", risk: "R0", needs: [], why: "y" },
+      { id: "V2", phase: "p", title: "推分支", when: "w", do: "d", who: "main", tool: "git push", done: "dn", risk: "R2", needs: ["P6"], why: "y" }
+    ]
+  }, "demo.json");
+}
+
+test("提案：列出流程步骤与观察到的动作，但**不预选任何一步**", () => {
+  const p = makePipeline();
+  const prop = buildProposal({
+    pipeline: p,
+    activities: [{ key: "npm test", count: 5, flags: [] }, { key: "git status", count: 3, flags: ["--porcelain"] }]
+  });
+  assert.equal(prop.ok, true);
+  assert.deepEqual(prop.steps.map((s) => s.id), ["P6", "V2"]);
+  // 步骤里带的是"作者写的 tool 原文"，给对照用；没有任何自动勾选
+  assert.equal(prop.steps[0].declared, "npm test");
+  assert.equal(prop.steps[0].hintCount, 0, "没给候选时次数是 0");
+  assert.deepEqual(prop.activities.map((a) => a.key), ["npm test", "git status"]);
+});
+
+test("提案：候选只作提示（一个次数），不预选、不带命令行原文", () => {
+  const p = makePipeline();
+  const prop = buildProposal({ pipeline: p, hints: { P6: 3 } });
+  assert.equal(prop.steps[0].hintCount, 3);
+  // 关键：hintCount 只说明"见到过相近命令"，没有任何字段表示"已经确认"
+  assert.equal("answer" in prop.steps[0], false);
+  assert.equal("selected" in prop.steps[0], false);
+  // 也不存命令行原文——原文含绝对路径（路径含本机用户名），而这条会进回执
+  assert.equal(JSON.stringify(prop).includes("command"), false);
+});
+
+test("提案：没有工作流时如实拒绝", () => {
+  assert.equal(buildProposal({ pipeline: null }).reason, "no-pipeline");
+  assert.equal(buildProposal({ pipeline: { id: "x" } }).reason, "no-pipeline");
+});
+
+test("校验回答：只认三类值，非法值一律拒（静默当「没发生」是编造）", () => {
+  const p = makePipeline();
+  assert.equal(normalizeAnswers({ P6: "done" }, p).ok, true);
+  const bad = normalizeAnswers({ P6: "yes" }, p);
+  assert.equal(bad.ok, false);
+  assert.equal(bad.reason, "bad-answer-value");
+  const unknown = normalizeAnswers({ NOPE: "done" }, p);
+  assert.equal(unknown.reason, "unknown-step");
+  assert.equal(normalizeAnswers(null, p).reason, "bad-answers");
+  assert.equal(normalizeAnswers([], p).reason, "bad-answers");
+});
+
+test("✅ 核心语义：done → uses；notDone → skipped；unsure/没答 → 什么都不写", () => {
+  const p = makePipeline();
+  const r = runFromAnswers({
+    pipeline: p,
+    answers: { P6: "done" },   // V2 没回答
+    now: () => new Date("2026-10-17T00:00:00.000Z")
+  });
+  assert.equal(r.kind, "run");
+  assert.deepEqual(r.run.steps.map((s) => s.id), ["P6"], "没回答的步骤不许进账");
+  assert.equal(r.run.steps[0].skipped, false);
+  assert.deepEqual(r.unanswered, ["V2"], "没答的要如实列出来");
+  assert.equal(r.run.by, "human", "人确认的账，by 应当是人");
+});
+
+test("✅ 核心语义：unsure 与 notDone 决不能混——前者不写，后者记 skipped", () => {
+  const p = makePipeline();
+  const unsure = runFromAnswers({ pipeline: p, answers: { P6: "done", V2: "unsure" } });
+  assert.deepEqual(unsure.run.steps.map((s) => s.id), ["P6"], "unsure 不进账");
+  assert.deepEqual(unsure.unsure, ["V2"]);
+
+  const notDone = runFromAnswers({ pipeline: p, answers: { P6: "done", V2: "notDone" } });
+  const v2 = notDone.run.steps.find((s) => s.id === "V2");
+  assert.equal(v2.skipped, true, "人明确说没做，才记 skipped");
+  assert.match(v2.note, /人确认/);
+  // 这条区分的意义：跳过计数正是 RETIRE_AFTER_SKIPS 提议删步的依据，
+  // 把"忘了勾"记成"被跳过"就会多出错误提议。
+  assert.notDeepEqual(unsure.run.steps.length, notDone.run.steps.length);
+});
+
+test("全部 notDone 仍是一条合法记录（人确认「这次一步都没做」是有信息的）", () => {
+  const p = makePipeline();
+  const r = runFromAnswers({ pipeline: p, answers: { P6: "notDone", V2: "notDone" } });
+  // 这不叫"零步"——它明确记录了"这两步这次都没做"，是一条完整的、全跳过的 run。
+  // 真正进 nothing 的是「什么都没确认」（见下一条）。
+  assert.equal(r.kind, "run");
+  assert.deepEqual(r.run.steps.map((s) => s.id), ["P6", "V2"]);
+  assert.equal(r.run.steps.every((s) => s.skipped === true), true);
+  assert.deepEqual(r.notDone, ["P6", "V2"]);
+});
+
+test("什么都没确认（全 unsure）：不产 run——这才是真正的「零步」", () => {
+  const p = makePipeline();
+  const r = runFromAnswers({ pipeline: p, answers: { P6: "unsure", V2: "unsure" } });
+  assert.equal(r.kind, "nothing");
+  assert.equal(r.reason, "no-steps-confirmed");
+  assert.equal("run" in r, false, "不许伪造一条空 run");
+  assert.deepEqual(r.unsure, ["P6", "V2"]);
+  assert.deepEqual(r.notDone, []);
+});
+
+test("空回答也是 nothing（没答 ≠ 都没做）", () => {
+  const p = makePipeline();
+  const r = runFromAnswers({ pipeline: p, answers: {} });
+  assert.equal(r.kind, "nothing");
+  assert.deepEqual(r.unanswered, ["P6", "V2"]);
+  assert.deepEqual(r.notDone, [], "没人说没做，就不该出现在 notDone 里");
+});
+
+test("非法回答进不来：runFromAnswers 会把它变成 error，而不是悄悄少记一步", () => {
+  const p = makePipeline();
+  const r = runFromAnswers({ pipeline: p, answers: { P6: "done", V2: "nope" } });
+  assert.equal(r.kind, "error");
+  assert.equal(r.reason, "bad-answer-value");
+  assert.equal("run" in r, false);
+});
+
+test("产出的 run 能过账本 normalizer（两个契约对得上）", async () => {
+  const { normalizeRun } = await import("../src/pipeline-runs.js");
+  const p = makePipeline();
+  const r = runFromAnswers({ pipeline: p, answers: { P6: "done", V2: "notDone" } });
+  const normalized = normalizeRun(r.run);
+  assert.equal(normalized.steps.length, 2);
+  assert.equal(normalized.steps[0].skipped, false);
+  assert.equal(normalized.steps[1].skipped, true);
+  assert.equal(normalized.by, "human");
+});
+
+test("坏输入不抛", () => {
+  const p = makePipeline();
+  for (const bad of [null, undefined, [], "x", 0]) {
+    assert.equal(runFromAnswers({ pipeline: p, answers: bad }).kind, "error");
+  }
+  assert.equal(runFromAnswers({ pipeline: null, answers: {} }).kind, "error");
+});