@modusensus/dsh-mneme 0.13.0 → 0.14.0-beta.2

package/test/pipeline-observations.test.js

@@ -1,157 +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);
-});
+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

@@ -1,127 +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);
-});
+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);
+});