@linkedclaw/cli 0.1.3 → 0.1.6

package/test/converge-review.test.ts

@@ -0,0 +1,135 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { computePaBodyHash, listCruxFiles, readStaging, stagingPathFor, writeStaging } from "../src/converge/staging.js";
+import { writeRunMeta } from "../src/converge/workspace.js";
+
+const RUN_ID = "clg_run_review001";
+const SOURCE_DEBATE_ID = "dbt_src001";
+const PA_AGENT_ID = "agt_pa001";
+const BODY = "# Synthesis\n\nSome synthesis.\n\n# Open questions\n\n(none)\n";
+
+let tmp: string;
+let stagingDir: string;
+
+beforeEach(() => {
+  tmp = mkdtempSync(join(tmpdir(), "lc-review-test-"));
+  stagingDir = join(tmp, "converged", "staging", RUN_ID);
+  writeRunMeta(stagingDir, {
+    run_id: RUN_ID,
+    source_debate_id: SOURCE_DEBATE_ID,
+    pa_agent_id: PA_AGENT_ID,
+    target_corpus: tmp,
+    owner_role: "a",
+  });
+});
+
+afterEach(() => {
+  rmSync(tmp, { recursive: true, force: true });
+});
+
+function writeDoc(cruxId: string, outcome: string, attested = false, userResponse = "") {
+  writeStaging(stagingPathFor(stagingDir, cruxId), {
+    frontmatter: {
+      debate_id: SOURCE_DEBATE_ID,
+      run_id: RUN_ID,
+      crux_id: cruxId,
+      sub_debate_chain: [],
+      latest_sub_debate_id: null,
+      source_crux_map_hash: "sha256:aabb",
+      generation_id: "gen_review001",
+      generated_at: "2026-04-30T10:00:00Z",
+      pa_body_hash: computePaBodyHash(BODY),
+      outcome: outcome as any,
+      bilateral_mandate_intact: true,
+      citations_a: [],
+      citations_b: [],
+      mod_progress_summary: {},
+      attested_by_user: attested,
+    },
+    userResponse,
+    body: BODY,
+  });
+}
+
+// Inline the review logic (mirrors converge.ts action body)
+function runReview(dir: string) {
+  const files = listCruxFiles(dir);
+  const cruxes: Array<Record<string, unknown>> = [];
+  for (const fn of files) {
+    const doc = readStaging(join(dir, fn));
+    const fm = doc.frontmatter;
+    cruxes.push({
+      crux_id: fm.crux_id,
+      outcome: fm.outcome,
+      bilateral_mandate_intact: fm.bilateral_mandate_intact,
+      attested_by_user: fm.attested_by_user,
+      latest_sub_debate_id: fm.latest_sub_debate_id,
+      has_user_response: (doc.userResponse || "").trim().length > 0,
+      next_action:
+        fm.outcome === "already_aligned" && !fm.attested_by_user ? "attest"
+        : fm.outcome === "needs_input" ? "clarify_or_accept"
+        : "accept_or_reject",
+    });
+  }
+  const alignedAwaitingAttest = cruxes.filter((c) => c.outcome === "already_aligned" && !c.attested_by_user);
+  return {
+    run_id: RUN_ID,
+    staging_dir: dir,
+    cruxes,
+    already_aligned_awaiting_attest: alignedAwaitingAttest.map((c) => c.crux_id),
+  };
+}
+
+describe("review: lists all staging cruxes with correct next_action", () => {
+  it("three docs → correct next_action per outcome", () => {
+    writeDoc("crux_001", "converged");
+    writeDoc("crux_002", "already_aligned", false); // not attested
+    writeDoc("crux_003", "needs_input");
+
+    const result = runReview(stagingDir);
+    expect(result.cruxes).toHaveLength(3);
+
+    const c001 = result.cruxes.find((c) => c.crux_id === "crux_001");
+    const c002 = result.cruxes.find((c) => c.crux_id === "crux_002");
+    const c003 = result.cruxes.find((c) => c.crux_id === "crux_003");
+
+    expect(c001?.next_action).toBe("accept_or_reject");
+    expect(c002?.next_action).toBe("attest");
+    expect(c003?.next_action).toBe("clarify_or_accept");
+  });
+
+  it("already_aligned_awaiting_attest includes unattested already_aligned only", () => {
+    writeDoc("crux_001", "converged");
+    writeDoc("crux_002", "already_aligned", false);
+    writeDoc("crux_003", "already_aligned", true); // attested
+
+    const result = runReview(stagingDir);
+    expect(result.already_aligned_awaiting_attest).toEqual(["crux_002"]);
+    expect(result.already_aligned_awaiting_attest).not.toContain("crux_003");
+  });
+
+  it("empty staging dir → empty cruxes, empty already_aligned_awaiting_attest", () => {
+    const result = runReview(stagingDir);
+    expect(result.cruxes).toHaveLength(0);
+    expect(result.already_aligned_awaiting_attest).toHaveLength(0);
+  });
+
+  it("has_user_response reflects whether _user_response is non-empty", () => {
+    writeDoc("crux_001", "needs_input", false, "My clarification here.");
+    writeDoc("crux_002", "needs_input", false, "");
+
+    const result = runReview(stagingDir);
+    const c1 = result.cruxes.find((c) => c.crux_id === "crux_001");
+    const c2 = result.cruxes.find((c) => c.crux_id === "crux_002");
+    expect(c1?.has_user_response).toBe(true);
+    expect(c2?.has_user_response).toBe(false);
+  });
+
+  it("returns run_id and staging_dir in result", () => {
+    const result = runReview(stagingDir);
+    expect(result.run_id).toBe(RUN_ID);
+    expect(result.staging_dir).toBe(stagingDir);
+  });
+});

package/test/converge-run.test.ts

@@ -0,0 +1,286 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { mkdtempSync, rmSync, existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { load as yamlLoad } from "js-yaml";
+
+// ─── shared test data ─────────────────────────────────────────────────────────
+
+const RUN_ID = "clg_run11223344";
+const SOURCE_DEBATE_ID = "dbt_source001";
+const PA_AGENT_ID = "agt_pa001";
+const USER_ID = "usr_ownerA001";
+const SUB_DEBATE_ID = "dbt_sub001";
+const CRUX_ID = "crux_abc";
+const COMMONS_LOG_CID = "clg_log00000001";
+const SUB_LOG_CID = "clg_log00000002";
+
+const SOURCE_CRUX_MAP_DATA = { cruxes: [{ crux_id: CRUX_ID, statement: "X is true" }], version: 1 };
+
+const RUN_EVENTS = [
+  {
+    seq: 1,
+    event_type: "run_started",
+    payload: {
+      source_crux_map_hash: "sha256:aabbccdd00000000000000000000000000000000000000000000000000000000",
+    },
+    appended_at: "2026-04-30T10:00:00Z",
+    signed_by: "sys",
+  },
+  {
+    seq: 2,
+    event_type: "sub_debate_dispatched",
+    payload: { crux_id: CRUX_ID, sub_debate_id: SUB_DEBATE_ID },
+    appended_at: "2026-04-30T10:01:00Z",
+    signed_by: "sys",
+  },
+  {
+    seq: 3,
+    event_type: "sub_debate_outcome_observed",
+    payload: { crux_id: CRUX_ID, outcome: "converged", bilateral_mandate_intact: true },
+    appended_at: "2026-04-30T10:05:00Z",
+    signed_by: "sys",
+  },
+];
+
+const SOURCE_EVENTS = [
+  {
+    seq: 1,
+    event_type: "crux_map",
+    payload: {
+      crux_map_data: SOURCE_CRUX_MAP_DATA,
+    },
+    appended_at: "2026-04-29T10:00:00Z",
+    signed_by: "sys",
+  },
+];
+
+const SUB_EVENTS = [
+  {
+    seq: 1,
+    event_type: "convergence_outcome",
+    payload: {
+      event_type: "convergence_outcome",
+      outcome: "converged",
+      bilateral_mandate_intact: true,
+      synthesis_text: "Both sides agree that X is true.",
+      open_questions: ["Is Y also true?"],
+      citations_a: [],
+      citations_b: [],
+      final_progress_signal: { phase: "synthesis" },
+    },
+    appended_at: "2026-04-30T10:04:00Z",
+    signed_by: "sys",
+  },
+];
+
+// ─── helpers ──────────────────────────────────────────────────────────────────
+
+function makeApiMock(overrides: Record<string, unknown> = {}) {
+  return {
+    getDebate: vi.fn(async (id: string) => {
+      if (id === SOURCE_DEBATE_ID) {
+        return { debate_id: SOURCE_DEBATE_ID, agent_a_id: "agt_a", agent_b_id: "agt_b", commons_log_id: COMMONS_LOG_CID, counterparty_user_id: "usr_ownerB", status: "active" };
+      }
+      if (id === SUB_DEBATE_ID) {
+        return { debate_id: SUB_DEBATE_ID, agent_a_id: "agt_a", agent_b_id: "agt_b", commons_log_id: SUB_LOG_CID, counterparty_user_id: null, status: "complete" };
+      }
+      return { debate_id: id, agent_a_id: "agt_a", agent_b_id: "agt_b", commons_log_id: "clg_x", counterparty_user_id: null, status: "active" };
+    }),
+    getCommonsLogEvents: vi.fn(async (cid: string) => {
+      if (cid === RUN_ID) return { events: RUN_EVENTS, next_offset: RUN_EVENTS.length };
+      if (cid === COMMONS_LOG_CID) return { events: SOURCE_EVENTS, next_offset: SOURCE_EVENTS.length };
+      if (cid === SUB_LOG_CID) return { events: SUB_EVENTS, next_offset: SUB_EVENTS.length };
+      return { events: [], next_offset: 0 };
+    }),
+    discoverPaAgentId: vi.fn(async () => PA_AGENT_ID),
+    findExistingMandate: vi.fn(async () => null),
+    issueMandate: vi.fn(async () => ({ mandate_id: "mnd_001", scope: [], expires_at: null, principal_agent_id: "agt_a", delegate_agent_id: PA_AGENT_ID })),
+    startRun: vi.fn(async () => ({ run_id: RUN_ID, commons_log_id: RUN_ID })),
+    acceptOwnerB: vi.fn(async () => ({ ok: true })),
+    appendCommonsLog: vi.fn(async () => ({ seq: 10 })),
+    ...overrides,
+  };
+}
+
+// Mock setup — we test the run command internals by directly calling helpers
+// from the modules rather than invoking the full CLI subprocess.
+// Import the modules we need after mocking.
+
+let tmp: string;
+
+beforeEach(() => {
+  tmp = mkdtempSync(join(tmpdir(), "lc-run-test-"));
+});
+
+afterEach(() => {
+  rmSync(tmp, { recursive: true, force: true });
+  vi.restoreAllMocks();
+});
+
+// ─── staging + hash helpers (unit-level, no API) ──────────────────────────────
+
+describe("Owner A first call: bootstraps workspace and writes meta", async () => {
+  const { writeRunMeta, readRunMeta } = await import("../src/converge/workspace.js");
+  const { computePaBodyHash } = await import("../src/converge/staging.js");
+
+  it("writeRunMeta / readRunMeta round-trip includes owner_role=a", () => {
+    writeRunMeta(tmp, {
+      run_id: RUN_ID,
+      source_debate_id: SOURCE_DEBATE_ID,
+      pa_agent_id: PA_AGENT_ID,
+      target_corpus: tmp,
+      owner_role: "a",
+    });
+    const meta = readRunMeta(tmp);
+    expect(meta?.run_id).toBe(RUN_ID);
+    expect(meta?.owner_role).toBe("a");
+  });
+
+  it("computePaBodyHash is deterministic", () => {
+    const body = "# Synthesis\n\nContent\n";
+    expect(computePaBodyHash(body)).toBe(computePaBodyHash(body));
+    expect(computePaBodyHash(body)).toMatch(/^sha256:[0-9a-f]{64}$/);
+  });
+});
+
+// ─── staging file write from outcome event ─────────────────────────────────────
+
+describe("Sync writes staging file with correct frontmatter", async () => {
+  const { writeStaging, stagingPathFor, readStaging } = await import("../src/converge/staging.js");
+  const { computePaBodyHash } = await import("../src/converge/staging.js");
+
+  it("staging file has run_id in path and correct pa_body_hash", () => {
+    const stagingDir = join(tmp, "converged", "staging", RUN_ID);
+    const op = SUB_EVENTS[0].payload as Record<string, unknown>;
+    const body = `# Synthesis\n\n${op.synthesis_text}\n\n# Open questions\n\n- ${(op.open_questions as string[])[0]}\n`;
+    const expectedHash = computePaBodyHash(body);
+    const path = stagingPathFor(stagingDir, CRUX_ID);
+    writeStaging(path, {
+      frontmatter: {
+        debate_id: SOURCE_DEBATE_ID,
+        run_id: RUN_ID,
+        crux_id: CRUX_ID,
+        sub_debate_chain: [SUB_DEBATE_ID],
+        latest_sub_debate_id: SUB_DEBATE_ID,
+        source_crux_map_hash: "sha256:aabb",
+        generation_id: `gen_${RUN_ID.slice(-8)}`,
+        generated_at: "2026-04-30T10:00:00Z",
+        pa_body_hash: expectedHash,
+        outcome: "converged",
+        bilateral_mandate_intact: true,
+        citations_a: [],
+        citations_b: [],
+        mod_progress_summary: { phase: "synthesis" },
+        attested_by_user: false,
+      },
+      userResponse: "",
+      body,
+    });
+    expect(existsSync(path)).toBe(true);
+    const loaded = readStaging(path);
+    expect(loaded.frontmatter.run_id).toBe(RUN_ID);
+    expect(loaded.frontmatter.pa_body_hash).toBe(expectedHash);
+    expect(path).toContain(RUN_ID);
+  });
+});
+
+// ─── _user_response ingestion ─────────────────────────────────────────────────
+
+describe("_user_response ingestion clears response and appends section", async () => {
+  const { writeStaging, readStaging, stagingPathFor } = await import("../src/converge/staging.js");
+
+  it("pre-seeded _user_response is cleared and body gets 'Previously clarified' block", () => {
+    const stagingDir = join(tmp, "converged", "staging", RUN_ID);
+    const path = stagingPathFor(stagingDir, CRUX_ID);
+    const initialBody = "# Synthesis\n\nInitial content.\n";
+    const userText = "I believe X needs more support.";
+
+    writeStaging(path, {
+      frontmatter: {
+        debate_id: SOURCE_DEBATE_ID,
+        run_id: RUN_ID,
+        crux_id: CRUX_ID,
+        sub_debate_chain: [SUB_DEBATE_ID],
+        latest_sub_debate_id: SUB_DEBATE_ID,
+        source_crux_map_hash: "sha256:aabb",
+        generation_id: "gen_11223344",
+        generated_at: "2026-04-30T10:00:00Z",
+        pa_body_hash: "sha256:xxxx",
+        outcome: "needs_input",
+        bilateral_mandate_intact: true,
+        citations_a: [],
+        citations_b: [],
+        mod_progress_summary: {},
+        attested_by_user: false,
+      },
+      userResponse: userText,
+      body: initialBody,
+    });
+
+    // Simulate ingestion: read, clear, append
+    const doc = readStaging(path);
+    expect(doc.userResponse).toBe(userText);
+    const text = doc.userResponse.trim();
+    doc.userResponse = "";
+    doc.body = doc.body.trimEnd() + `\n\n# Previously clarified (round 1)\n\n${text}\n`;
+    writeStaging(path, doc);
+
+    const after = readStaging(path);
+    expect(after.userResponse).toBe("");
+    expect(after.body).toContain("# Previously clarified (round 1)");
+    expect(after.body).toContain(userText);
+  });
+});
+
+// ─── source hash drift detection ─────────────────────────────────────────────
+
+describe("source-hash drift guard", async () => {
+  const { sha256OfCanonicalJson } = await import("../src/converge/hash.js");
+
+  it("detects when live hash differs from recorded hash", () => {
+    const recordedHash = "sha256:aabbccdd00000000000000000000000000000000000000000000000000000000";
+    const liveHash = sha256OfCanonicalJson(SOURCE_CRUX_MAP_DATA);
+    // These will differ since recordedHash is a placeholder
+    expect(liveHash).not.toBe(recordedHash);
+  });
+
+  it("live hash is stable for the same crux_map_data", () => {
+    const h1 = sha256OfCanonicalJson(SOURCE_CRUX_MAP_DATA);
+    const h2 = sha256OfCanonicalJson(SOURCE_CRUX_MAP_DATA);
+    expect(h1).toBe(h2);
+  });
+});
+
+// ─── idempotent mandate: findExistingMandate returns existing → issueMandate not called ──
+
+describe("Idempotent mandate issuance", () => {
+  it("does not call issueMandate when findExistingMandate returns existing", async () => {
+    const api = makeApiMock({
+      findExistingMandate: vi.fn(async () => ({
+        mandate_id: "mnd_existing",
+        scope: ["debate.create", "debate.accept"],
+        expires_at: null,
+        principal_agent_id: "agt_a",
+        delegate_agent_id: PA_AGENT_ID,
+      })),
+    });
+
+    const existingMandate = await api.findExistingMandate("agt_a", PA_AGENT_ID, ["debate.create", "debate.accept"]);
+    if (!existingMandate) {
+      await api.issueMandate("agt_a", PA_AGENT_ID, ["debate.create", "debate.accept"]);
+    }
+
+    expect(api.issueMandate).not.toHaveBeenCalled();
+  });
+
+  it("calls issueMandate when findExistingMandate returns null", async () => {
+    const api = makeApiMock();
+    const existing = await api.findExistingMandate("agt_a", PA_AGENT_ID, ["debate.create", "debate.accept"]);
+    if (!existing) {
+      await api.issueMandate("agt_a", PA_AGENT_ID, ["debate.create", "debate.accept"]);
+    }
+
+    expect(api.issueMandate).toHaveBeenCalledOnce();
+  });
+});

package/test/converge-staging.test.ts

@@ -0,0 +1,161 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  parseStaging,
+  dumpStaging,
+  readStaging,
+  writeStaging,
+  stagingPathFor,
+  listCruxFiles,
+  computePaBodyHash,
+  type StagingDoc,
+} from "../src/converge/staging.js";
+
+const SAMPLE_FM = {
+  debate_id: "dbt_001",
+  run_id: "clg_run00000001",
+  crux_id: "crux_abc",
+  sub_debate_chain: ["dbt_sub001"],
+  latest_sub_debate_id: "dbt_sub001",
+  source_crux_map_hash: "sha256:aabbcc",
+  generation_id: "gen_00000001",
+  generated_at: "2026-04-30T10:00:00Z",
+  pa_body_hash: "sha256:ddeeff",
+  outcome: "converged" as const,
+  bilateral_mandate_intact: true,
+  citations_a: [],
+  citations_b: [],
+  mod_progress_summary: {},
+  attested_by_user: false,
+};
+
+const SAMPLE_BODY = "# Synthesis\n\nThey agree on X.\n";
+
+const SAMPLE_DOC: StagingDoc = {
+  frontmatter: SAMPLE_FM,
+  userResponse: "",
+  body: SAMPLE_BODY,
+};
+
+let tmp: string;
+
+beforeEach(() => {
+  tmp = mkdtempSync(join(tmpdir(), "lc-staging-test-"));
+});
+
+afterEach(() => {
+  rmSync(tmp, { recursive: true, force: true });
+});
+
+describe("parseStaging / dumpStaging", () => {
+  it("round-trips a doc without userResponse", () => {
+    const serialized = dumpStaging(SAMPLE_DOC);
+    const parsed = parseStaging(serialized);
+    expect(parsed.frontmatter.debate_id).toBe(SAMPLE_FM.debate_id);
+    expect(parsed.frontmatter.run_id).toBe(SAMPLE_FM.run_id);
+    expect(parsed.frontmatter.crux_id).toBe(SAMPLE_FM.crux_id);
+    expect(parsed.frontmatter.outcome).toBe(SAMPLE_FM.outcome);
+    expect(parsed.frontmatter.attested_by_user).toBe(false);
+    expect(parsed.body).toBe(SAMPLE_BODY);
+  });
+
+  it("userResponse is empty string after round-trip when not set", () => {
+    const serialized = dumpStaging(SAMPLE_DOC);
+    const parsed = parseStaging(serialized);
+    expect(parsed.userResponse).toBe("");
+  });
+
+  it("preserves non-empty userResponse through round-trip", () => {
+    const doc: StagingDoc = { ...SAMPLE_DOC, userResponse: "I think X is debatable." };
+    const serialized = dumpStaging(doc);
+    const parsed = parseStaging(serialized);
+    expect(parsed.userResponse).toBe("I think X is debatable.");
+    // _user_response should not appear in frontmatter object
+    expect((parsed.frontmatter as any)._user_response).toBeUndefined();
+  });
+
+  it("round-trip preserves arrays and nested objects in frontmatter", () => {
+    const doc: StagingDoc = {
+      ...SAMPLE_DOC,
+      frontmatter: {
+        ...SAMPLE_FM,
+        citations_a: [{ source: "page 3", quote: "exact text" }],
+        mod_progress_summary: { phase: "synthesis", rounds: 2 },
+      },
+    };
+    const parsed = parseStaging(dumpStaging(doc));
+    expect(parsed.frontmatter.citations_a).toEqual([{ source: "page 3", quote: "exact text" }]);
+    expect(parsed.frontmatter.mod_progress_summary).toEqual({ phase: "synthesis", rounds: 2 });
+  });
+
+  it("throws on missing opening ---", () => {
+    expect(() => parseStaging("not frontmatter\n---\nbody")).toThrow(/frontmatter/);
+  });
+
+  it("throws on missing closing ---", () => {
+    expect(() => parseStaging("---\ndebate_id: x\nbody")).toThrow(/closing/);
+  });
+
+  it("body appears after closing --- delimiter", () => {
+    const serialized = dumpStaging({ ...SAMPLE_DOC, body: "hello\nworld\n" });
+    expect(serialized).toContain("---\nhello\nworld\n");
+  });
+});
+
+describe("readStaging / writeStaging", () => {
+  it("write then read produces equivalent doc", () => {
+    const path = stagingPathFor(tmp, "crux_abc");
+    writeStaging(path, SAMPLE_DOC);
+    const loaded = readStaging(path);
+    expect(loaded.frontmatter.crux_id).toBe("crux_abc");
+    expect(loaded.body).toBe(SAMPLE_BODY);
+    expect(loaded.userResponse).toBe("");
+  });
+
+  it("writeStaging creates intermediate directories", () => {
+    const nested = join(tmp, "a", "b", "c");
+    const path = stagingPathFor(nested, "crux_xyz");
+    // Should not throw
+    writeStaging(path, SAMPLE_DOC);
+    const loaded = readStaging(path);
+    expect(loaded.frontmatter.crux_id).toBe("crux_abc");
+  });
+});
+
+describe("listCruxFiles", () => {
+  it("returns empty array for non-existent directory", () => {
+    expect(listCruxFiles(join(tmp, "nonexistent"))).toEqual([]);
+  });
+
+  it("returns .md files only", () => {
+    writeStaging(stagingPathFor(tmp, "crux_001"), SAMPLE_DOC);
+    writeStaging(stagingPathFor(tmp, "crux_002"), SAMPLE_DOC);
+    const files = listCruxFiles(tmp);
+    expect(files).toHaveLength(2);
+    expect(files.every((f) => f.endsWith(".md"))).toBe(true);
+  });
+
+  it("skips files starting with a dot", () => {
+    writeStaging(stagingPathFor(tmp, "crux_001"), SAMPLE_DOC);
+    writeFileSync(join(tmp, ".lock"), "{}");
+    const files = listCruxFiles(tmp);
+    expect(files.every((f) => !f.startsWith("."))).toBe(true);
+  });
+});
+
+describe("computePaBodyHash", () => {
+  it("returns sha256: prefix followed by 64 hex chars", () => {
+    expect(computePaBodyHash("some body text")).toMatch(/^sha256:[0-9a-f]{64}$/);
+  });
+
+  it("is deterministic over identical input", () => {
+    const body = "# Synthesis\n\nContent here.\n";
+    expect(computePaBodyHash(body)).toBe(computePaBodyHash(body));
+  });
+
+  it("produces different hashes for different bodies", () => {
+    expect(computePaBodyHash("body A")).not.toBe(computePaBodyHash("body B"));
+  });
+});