@remnic/core 9.69.53 → 9.69.55

package/src/lifecycle/seed-graduation.test.ts

@@ -28,6 +28,10 @@ const SEED_TEXT = "The launch moved to September twelfth after the vendor call."
 // Restates the seed in similar wording (the wearable support-corpus pair).
 const RESTATE_TEXT = "Launch moved to September twelfth after the vendor call.";
 const UNRELATED_TEXT = "Quarterly budget planning covered the new office lease.";
+// Restates the seed's core content with flipped negation polarity.
+const CONTRADICT_TEXT = "The launch was not moved to September twelfth after the vendor call.";
+const NEGATED_UNRELATED_TEXT =
+  "The office lease was not approved during quarterly budget planning.";
 
 function fakeMemory(overrides: {
   id: string;
@@ -329,6 +333,144 @@ test("disabled config holds with the disabled reason (zero-value semantics)", ()
   assert.deepEqual(decision.reasons, ["seed-graduation-disabled"]);
 });
 
+// ---------------------------------------------------------------------------
+// Gate — contradiction during the corroboration window (issue #2974)
+// ---------------------------------------------------------------------------
+
+function seedMemory(overrides: Partial<Parameters<typeof fakeMemory>[0]> & { id: string }): MemoryFile {
+  return fakeMemory({
+    content: SEED_TEXT,
+    created: "2026-08-01T10:00:00.000Z",
+    status: "pending_review",
+    source: "wearable:bee",
+    ...overrides,
+  });
+}
+
+test("an independent negated restatement holds the seed even with enough corroborations", () => {
+  const seed = seedMemory({ id: "seed-1" });
+  const corroborator = fakeMemory({
+    id: "ev-1",
+    content: RESTATE_TEXT,
+    created: "2026-08-02T10:00:00.000Z",
+    source: "wearable:limitless",
+  });
+  const contradictor = fakeMemory({
+    id: "ev-2",
+    content: CONTRADICT_TEXT,
+    created: "2026-08-03T10:00:00.000Z",
+    source: "extraction",
+  });
+  const decision = evaluateSeedGraduation(seed, [corroborator, contradictor], {
+    config: ENABLED,
+  });
+  assert.equal(decision.decision, "hold", "contradiction vetoes graduation");
+  assert.deepEqual(decision.contradicting, [{ memoryId: "ev-2", source: "extraction" }]);
+  assert.ok(decision.reasons.includes("contradiction-observed:1"));
+});
+
+test("a negated seed restated positively is held (polarity symmetry)", () => {
+  const seed = seedMemory({ id: "seed-1", content: CONTRADICT_TEXT });
+  const positive = fakeMemory({
+    id: "ev-1",
+    content: RESTATE_TEXT,
+    created: "2026-08-02T10:00:00.000Z",
+    source: "wearable:limitless",
+  });
+  const decision = evaluateSeedGraduation(seed, [positive], { config: ENABLED });
+  assert.equal(decision.decision, "hold");
+  assert.equal(decision.contradicting.length, 1);
+});
+
+test("a same-session negation is a draft correction, not a contradiction", () => {
+  const seed = seedMemory({
+    id: "seed-1",
+    structuredAttributes: { sessionKey: "session-a" },
+  });
+  const retraction = fakeMemory({
+    id: "ev-2",
+    content: CONTRADICT_TEXT,
+    created: "2026-08-03T10:00:00.000Z",
+    source: "extraction",
+    structuredAttributes: { sessionKey: "session-a" },
+  });
+  const corroborator = fakeMemory({
+    id: "ev-1",
+    content: RESTATE_TEXT,
+    created: "2026-08-02T10:00:00.000Z",
+    source: "wearable:limitless",
+  });
+  const decision = evaluateSeedGraduation(seed, [retraction, corroborator], {
+    config: ENABLED,
+  });
+  assert.equal(decision.decision, "promote");
+  assert.equal(decision.contradicting.length, 0);
+});
+
+test("a polarity flip without core-content restatement neither contradicts nor corroborates", () => {
+  const seed = seedMemory({ id: "seed-1" });
+  const negatedUnrelated = fakeMemory({
+    id: "ev-2",
+    content: NEGATED_UNRELATED_TEXT,
+    created: "2026-08-03T10:00:00.000Z",
+    source: "extraction",
+  });
+  const corroborator = fakeMemory({
+    id: "ev-1",
+    content: RESTATE_TEXT,
+    created: "2026-08-02T10:00:00.000Z",
+    source: "wearable:limitless",
+  });
+  const decision = evaluateSeedGraduation(seed, [negatedUnrelated, corroborator], {
+    config: ENABLED,
+  });
+  assert.equal(decision.decision, "promote");
+  assert.equal(decision.contradicting.length, 0);
+});
+
+test("recall echo does not suppress a contradiction: denying a recalled seed is a correction", () => {
+  const seed = seedMemory({
+    id: "seed-1",
+    structuredAttributes: { sessionKey: "session-a" },
+  });
+  const contradictor = fakeMemory({
+    id: "ev-2",
+    content: CONTRADICT_TEXT,
+    created: "2026-08-03T10:00:00.000Z",
+    source: "extraction",
+    structuredAttributes: { sessionKey: "session-b" },
+  });
+  const decision = evaluateSeedGraduation(seed, [contradictor], {
+    config: ENABLED,
+    recalledBySession: (sessionKey) =>
+      sessionKey === "session-b" ? [["seed-1"]] : [],
+  });
+  assert.equal(decision.decision, "hold");
+  assert.equal(decision.contradicting.length, 1);
+});
+
+test("a superseded contradictor no longer holds the seed (review resolution unblocks)", () => {
+  const seed = seedMemory({ id: "seed-1" });
+  const resolved = fakeMemory({
+    id: "ev-2",
+    content: CONTRADICT_TEXT,
+    created: "2026-08-03T10:00:00.000Z",
+    source: "extraction",
+    status: "superseded",
+  });
+  const corroborator = fakeMemory({
+    id: "ev-1",
+    content: RESTATE_TEXT,
+    created: "2026-08-02T10:00:00.000Z",
+    source: "wearable:limitless",
+  });
+  const decision = evaluateSeedGraduation(seed, [resolved, corroborator], {
+    config: ENABLED,
+  });
+  assert.equal(decision.decision, "promote");
+  assert.equal(decision.contradicting.length, 0);
+});
+
 // ---------------------------------------------------------------------------
 // Pass — against a real StorageManager (acceptance cases)
 // ---------------------------------------------------------------------------
@@ -401,6 +543,40 @@ test("pass: independent corroboration promotes the seed in place with audit attr
   }
 });
 
+test("pass: contradiction during the window holds the seed in place", async () => {
+  const { storage, dir } = makeStorage();
+  try {
+    await storage.writeMemory("fact", SEED_TEXT, {
+      source: "wearable:bee",
+      status: "pending_review",
+    });
+    await storage.writeMemory("fact", RESTATE_TEXT, {
+      source: "wearable:limitless",
+    });
+    await storage.writeMemory("fact", CONTRADICT_TEXT, {
+      source: "extraction",
+    });
+    const memories = await storage.readAllMemories();
+    const summary = await runSeedGraduationPass({
+      memories,
+      storage,
+      config: ENABLED,
+    });
+    assert.equal(summary.evaluated, 1);
+    assert.equal(summary.promoted, 0, "contradicted seed must not graduate");
+    assert.equal(summary.held, 1);
+    assert.equal(summary.contradictionHeld, 1);
+    const seed = (await storage.readAllMemories()).find(
+      (memory) => memory.frontmatter.source === "wearable:bee",
+    );
+    assert.ok(seed);
+    assert.equal(seed.frontmatter.status, "pending_review", "held for review resolution");
+    assert.equal(seed.frontmatter.structuredAttributes?.graduatedBy, undefined);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
 test("pass: a non-corroborated seed stays in its prior state", async () => {
   const { storage, dir } = makeStorage();
   try {
@@ -450,6 +626,7 @@ test("pass: disabled config touches nothing", async () => {
       evaluated: 0,
       promoted: 0,
       held: 0,
+      contradictionHeld: 0,
       echoSuppressed: 0,
       disabled: true,
     });
@@ -581,3 +758,35 @@ test("lifecycle pass: recall-handle history suppresses echo corroboration", asyn
     rmSync(dir, { recursive: true, force: true });
   }
 });
+
+test("lifecycle pass: contradiction during the window holds the seed through the policy seam", async () => {
+  const { storage, dir } = makeStorage();
+  try {
+    await storage.writeMemory("fact", SEED_TEXT, {
+      source: "wearable:bee",
+      status: "pending_review",
+    });
+    await storage.writeMemory("fact", RESTATE_TEXT, {
+      source: "wearable:limitless",
+    });
+    await storage.writeMemory("fact", CONTRADICT_TEXT, {
+      source: "extraction",
+    });
+    const config = parseConfig({
+      memoryDir: dir,
+      seedGraduation: { enabled: true, minCorroborations: 1 },
+    });
+    const memories = await storage.readAllMemories();
+    await new LifecyclePolicyCoordinator(coordinatorDeps(storage, config)).runLifecyclePolicyPass(
+      memories,
+      storage,
+    );
+    const seed = (await storage.readAllMemories()).find(
+      (memory) => memory.frontmatter.source === "wearable:bee",
+    );
+    assert.equal(seed?.frontmatter.status, "pending_review", "contradiction holds the seed");
+    assert.equal(seed?.frontmatter.structuredAttributes?.graduatedBy, undefined);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/src/lifecycle/seed-graduation.ts

@@ -1,5 +1,5 @@
 /**
- * Corroboration-graduated seed memories (issue #2974) — foundation layer.
+ * Corroboration-graduated seed memories (issue #2974).
  *
  * A `pending_review` memory is a SEED: it must not enter active recall on its
  * own say-so. This module decides, deterministically, when later evidence has
@@ -12,20 +12,21 @@
  *    anchors are absent, and never a lineage descendant of the seed,
  *  - echo is suppressed: when the caller can show the evidence's session
  *    RECALLED the seed (the store's own content quoted back), that evidence
- *    never counts — otherwise recall would manufacture its own confirmation.
+ *    never counts — otherwise recall would manufacture its own confirmation,
+ *  - a CONTRADICTION observed during the corroboration window — a later
+ *    independent memory restating the seed's core content with flipped
+ *    negation polarity (the dedup detector's vocabulary) — holds the seed:
+ *    it never auto-graduates while the contradiction stands. Demoting or
+ *    superseding stays a reviewer verb, exactly like preference drift.
  *
  * Promotion itself reuses the existing in-place `pending_review -> active`
  * machinery (`StorageManager.promoteWearableMemory`, the same status flip the
  * wearable cross-device corroboration path uses) — no parallel write path.
  * Every graduation stamps the corroborating evidence ids on the promoted row
  * (audit surface; the lifecycle ledger already records the status transition).
- *
- * Foundation scope: the gate, the pass, and the config parser. Wiring the key
- * into `parseConfig` (config.ts sits at its size ratchet), the conservative
- * preset pin, scheduling inside the lifecycle sweep, contradiction holds, and
- * the docs/manifest surface are follow-up layers on this issue.
  */
 
+import { NEGATION_WORDS } from "../dedup/index.js";
 import { normalizeRecallTokens } from "../recall-tokenization.js";
 import { stripAttributesSuffix } from "../storage.js";
 import { STRUCTURED_ATTRIBUTE_LIMITS } from "../write-envelope.js";
@@ -161,8 +162,17 @@ function isIndependentProvenance(seed: MemoryFile, evidence: MemoryFile): boolea
 
 /** Reads the token coverage of `seed`'s tokens inside `evidence`'s body. */
 function coverageOf(seedTokens: ReadonlySet<string>, evidence: MemoryFile): number {
+  return tokenCoverageOf(
+    seedTokens,
+    new Set(normalizeRecallTokens(stripAttributesSuffix(evidence.content))),
+  );
+}
+
+function tokenCoverageOf(
+  seedTokens: ReadonlySet<string>,
+  evidenceTokens: ReadonlySet<string>,
+): number {
   if (seedTokens.size === 0) return 0;
-  const evidenceTokens = new Set(normalizeRecallTokens(stripAttributesSuffix(evidence.content)));
   let matches = 0;
   for (const token of seedTokens) {
     if (evidenceTokens.has(token)) matches += 1;
@@ -170,6 +180,28 @@ function coverageOf(seedTokens: ReadonlySet<string>, evidence: MemoryFile): numb
   return matches / seedTokens.size;
 }
 
+// Contradiction detection shares the dedup detector's negation vocabulary
+// (NEGATION_WORDS) — one vocabulary source, never a per-consumer copy.
+
+/** Word shapes that keep contractions ("don't") as single negation words. */
+const NEGATION_WORD_SPLIT = /[^\p{L}\p{M}\p{N}']+/u;
+
+function hasNegationWord(text: string): boolean {
+  for (const word of text.toLowerCase().split(NEGATION_WORD_SPLIT)) {
+    if (NEGATION_WORDS.has(word)) return true;
+  }
+  return false;
+}
+
+/** Drops negation words so polarity-flipped texts compare on core content. */
+function stripNegationWords(text: string): string {
+  return text
+    .toLowerCase()
+    .split(NEGATION_WORD_SPLIT)
+    .filter((word) => !NEGATION_WORDS.has(word))
+    .join(" ");
+}
+
 /**
  * Per-session recall history seam, satisfied by
  * `RecallHandleHistoryStore.recent(sessionKey)`: the memory-id sets a session
@@ -187,6 +219,12 @@ export interface SeedGraduationEvaluation {
   decision: "promote" | "hold";
   corroborationCount: number;
   corroborating: SeedGraduationEvidenceRef[];
+  /**
+   * Later independent evidence that restated the seed's core content with
+   * flipped negation polarity. Non-empty vetoes promotion: the seed is held
+   * for review resolution instead (issue #2974).
+   */
+  contradicting: SeedGraduationEvidenceRef[];
   /** Evidence that restated the seed but was excluded as echo/derivation. */
   echoSuppressedCount: number;
   reasons: string[];
@@ -208,23 +246,29 @@ export function evaluateSeedGraduation(
       decision: "hold",
       corroborationCount: 0,
       corroborating: [],
+      contradicting: [],
       echoSuppressedCount: 0,
       reasons: ["seed-graduation-disabled"],
     };
   }
-  const seedTokens = new Set(normalizeRecallTokens(stripAttributesSuffix(seed.content)));
+  const seedText = stripAttributesSuffix(seed.content);
+  const seedTokens = new Set(normalizeRecallTokens(seedText));
   if (seedTokens.size < MIN_SEED_TOKENS) {
     return {
       decision: "hold",
       corroborationCount: 0,
       corroborating: [],
+      contradicting: [],
       echoSuppressedCount: 0,
       reasons: ["seed-too-short-for-deterministic-corroboration"],
     };
   }
+  const seedNegated = hasNegationWord(seedText);
+  const seedCoreTokens = new Set(normalizeRecallTokens(stripNegationWords(seedText)));
 
   const seedCreated = createdMs(seed);
   const corroborating: SeedGraduationEvidenceRef[] = [];
+  const contradicting: SeedGraduationEvidenceRef[] = [];
   const reasons: string[] = [];
   let echoSuppressedCount = 0;
 
@@ -236,6 +280,24 @@ export function evaluateSeedGraduation(
     if (!Number.isFinite(seedCreated) || !Number.isFinite(candidateCreated)) continue;
     if (candidateCreated <= seedCreated) continue;
     if (!isEvidenceStatus(candidate.frontmatter.status)) continue;
+    const candidateText = stripAttributesSuffix(candidate.content);
+    if (hasNegationWord(candidateText) !== seedNegated) {
+      // Polarity-flipped restatement of the seed's core content is a
+      // contradiction, never a corroboration. The same independence rules
+      // apply, but recall echo does NOT suppress a contradiction: an
+      // independent consumer denying a recalled seed is a correction, not
+      // manufactured confirmation.
+      if (seedCoreTokens.size >= MIN_SEED_TOKENS && isIndependentProvenance(seed, candidate)) {
+        const coreTokens = new Set(normalizeRecallTokens(stripNegationWords(candidateText)));
+        if (tokenCoverageOf(seedCoreTokens, coreTokens) >= SEED_CORROBORATION_COVERAGE) {
+          contradicting.push({
+            memoryId: candidate.frontmatter.id,
+            source: candidate.frontmatter.source,
+          });
+        }
+      }
+      continue;
+    }
     if (coverageOf(seedTokens, candidate) < SEED_CORROBORATION_COVERAGE) continue;
 
     if (!isIndependentProvenance(seed, candidate)) {
@@ -258,11 +320,27 @@ export function evaluateSeedGraduation(
   }
 
   if (echoSuppressedCount > 0) reasons.push(`echo-suppressed:${echoSuppressedCount}`);
+  if (contradicting.length > 0) {
+    // A contradiction observed during the corroboration window vetoes
+    // graduation no matter how many corroborations also landed: promoting a
+    // disputed fact is never automatic. Demotion/supersession stays with the
+    // reviewer via the existing contradiction-resolution verbs.
+    reasons.push(`contradiction-observed:${contradicting.length}`);
+    return {
+      decision: "hold",
+      corroborationCount: corroborating.length,
+      corroborating,
+      contradicting,
+      echoSuppressedCount,
+      reasons,
+    };
+  }
   if (corroborating.length >= config.minCorroborations) {
     return {
       decision: "promote",
       corroborationCount: corroborating.length,
       corroborating,
+      contradicting,
       echoSuppressedCount,
       reasons,
     };
@@ -272,6 +350,7 @@ export function evaluateSeedGraduation(
     decision: "hold",
     corroborationCount: corroborating.length,
     corroborating,
+    contradicting,
     echoSuppressedCount,
     reasons,
   };
@@ -306,6 +385,8 @@ export interface SeedGraduationPassSummary {
   evaluated: number;
   promoted: number;
   held: number;
+  /** Held specifically because a contradiction was observed in the window. */
+  contradictionHeld: number;
   echoSuppressed: number;
   disabled: boolean;
 }
@@ -333,13 +414,14 @@ export async function runSeedGraduationPass(
 ): Promise<SeedGraduationPassSummary> {
   const config = input.config ?? SEED_GRADUATION_DEFAULTS;
   if (!config.enabled) {
-    return { evaluated: 0, promoted: 0, held: 0, echoSuppressed: 0, disabled: true };
+    return { evaluated: 0, promoted: 0, held: 0, contradictionHeld: 0, echoSuppressed: 0, disabled: true };
   }
   const corpus = excludeSupportPassportPrivateMemories(input.memories);
   const evidencePool = corpus.filter((memory) => isEvidenceStatus(memory.frontmatter.status));
 
   let promoted = 0;
   let held = 0;
+  let contradictionHeld = 0;
   let echoSuppressed = 0;
   let evaluated = 0;
 
@@ -358,6 +440,7 @@ export async function runSeedGraduationPass(
 
     if (evaluation.decision === "hold") {
       held += 1;
+      if (evaluation.contradicting.length > 0) contradictionHeld += 1;
       continue;
     }
     // A concurrent review resolution wins: promoteWearableMemory returns
@@ -370,5 +453,5 @@ export async function runSeedGraduationPass(
     else held += 1;
   }
 
-  return { evaluated, promoted, held, echoSuppressed, disabled: false };
+  return { evaluated, promoted, held, contradictionHeld, echoSuppressed, disabled: false };
 }

package/src/shared-context/governance-wiring.test.ts

@@ -0,0 +1,153 @@
+/**
+ * Regression: #1957 governance controls 2-4 wired into the REAL manager
+ * synthesis and curation paths (issue #3012).
+ *
+ * - Control 2: an expired item never appears in cross-signals sources or the
+ *   roundtable; a superseded item that still circulates is marked, not dropped.
+ * - Control 3: two agents ruling differently on the same feedback ref surface
+ *   as a disputed section citing both — neither entry is silently dropped.
+ * - Control 4: the persisted report carries curator provenance and every
+ *   synthesized overlap claim cites source item ids (lint tripwire holds).
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { SharedContextManager } from "./manager.js";
+import { parseConfig } from "../config.js";
+
+async function makeManager() {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-gov-wiring-"));
+  const config = parseConfig({
+    sharedContextEnabled: true,
+    sharedContextDir: dir,
+  });
+  const manager = new SharedContextManager(config);
+  await manager.ensureStructure();
+  return { manager, dir };
+}
+
+function today(): string {
+  return new Date().toISOString().slice(0, 10);
+}
+
+/** Stored-item shape the write path cannot produce (past expiry), but the
+ *  read path must still classify: legacy or externally written items. */
+async function writeStoredItem(
+  dir: string,
+  opts: { agent: string; title: string; expiresAt?: string; supersedes?: string },
+): Promise<string> {
+  const dayDir = path.join(dir, "agent-outputs", opts.agent, today());
+  await mkdir(dayDir, { recursive: true });
+  const fp = path.join(dayDir, `000000-${opts.title.replace(/\s+/g, "-").toLowerCase()}.md`);
+  const frontmatter = [
+    "kind: agent_output",
+    `agent: ${JSON.stringify(opts.agent)}`,
+    `createdAt: ${new Date().toISOString()}`,
+    `title: ${JSON.stringify(opts.title)}`,
+    ...(opts.expiresAt ? [`expiresAt: ${JSON.stringify(opts.expiresAt)}`] : []),
+    ...(opts.supersedes ? [`supersedes: ${JSON.stringify(opts.supersedes)}`] : []),
+  ];
+  await writeFile(fp, `---\n${frontmatter.join("\n")}\n---\n\nbody text about deploy runbook\n`, "utf-8");
+  return fp;
+}
+
+test("expired items never appear in cross-signals or curation; superseded circulation is marked", async (t) => {
+  const { manager, dir } = await makeManager();
+  t.after(() => rm(dir, { recursive: true, force: true }));
+
+  const livePath = await writeStoredItem(dir, { agent: "agent-live", title: "live item" });
+  const expiredPath = await writeStoredItem(dir, {
+    agent: "agent-old",
+    title: "expired item",
+    expiresAt: "2020-01-01T00:00:00.000Z",
+  });
+
+  const signals = await manager.synthesizeCrossSignals({ date: today() });
+  const paths = signals.report.sources.map((source) => source.path);
+  assert.ok(paths.includes(livePath), "live item must appear in sources");
+  assert.ok(!paths.includes(expiredPath), "expired item must never appear in sources");
+  assert.equal(signals.report.staleness.expiredDropped, 1);
+  assert.deepEqual(signals.report.staleness.supersededStillCirculating, []);
+
+  const curation = await manager.curateDaily({ date: today() });
+  const roundtable = await readFile(curation.roundtablePath, "utf-8");
+  assert.ok(!roundtable.includes(expiredPath), "expired item must never appear in the roundtable");
+  assert.match(roundtable, /## Staleness/);
+  assert.match(roundtable, /Expired items dropped: 1/);
+});
+
+test("a superseded item that still circulates is marked, not dropped", async (t) => {
+  const { manager, dir } = await makeManager();
+  t.after(() => rm(dir, { recursive: true, force: true }));
+
+  const olderPath = await writeStoredItem(dir, { agent: "agent-a", title: "older item" });
+  await writeStoredItem(dir, { agent: "agent-b", title: "newer item", supersedes: olderPath });
+
+  const signals = await manager.synthesizeCrossSignals({ date: today() });
+  assert.deepEqual(signals.report.staleness.supersededStillCirculating, [olderPath]);
+  const paths = signals.report.sources.map((source) => source.path);
+  assert.ok(paths.includes(olderPath), "superseded item still circulates (marked, not dropped)");
+
+  const curation = await manager.curateDaily({ date: today() });
+  const roundtable = await readFile(curation.roundtablePath, "utf-8");
+  assert.match(roundtable, /Superseded items still circulating: 1/);
+});
+
+test("contradictory agent rulings on the same ref surface as disputed, both preserved", async (t) => {
+  const { manager, dir } = await makeManager();
+  t.after(() => rm(dir, { recursive: true, force: true }));
+
+  await manager.appendFeedback({
+    agent: "agent-a",
+    decision: "approved",
+    reason: "matches the runbook",
+    date: `${today()}T10:00:00.000Z`,
+    refs: ["out-0001"],
+  });
+  await manager.appendFeedback({
+    agent: "agent-b",
+    decision: "rejected",
+    reason: "misses the rollback step",
+    date: `${today()}T11:00:00.000Z`,
+    refs: ["out-0001"],
+  });
+
+  const signals = await manager.synthesizeCrossSignals({ date: today() });
+  assert.deepEqual(signals.report.disputed, [
+    { ref: "out-0001", agents: ["agent-a", "agent-b"], decisions: ["approved", "rejected"] },
+  ]);
+  assert.equal(signals.report.feedbackEntries.length, 2, "neither disputed entry is dropped");
+
+  const curation = await manager.curateDaily({ date: today() });
+  const roundtable = await readFile(curation.roundtablePath, "utf-8");
+  assert.match(roundtable, /## Disputed/);
+  assert.match(roundtable, /`out-0001` disputed by agent-a, agent-b/);
+  assert.match(roundtable, /agent-a\] approved/);
+  assert.match(roundtable, /agent-b\] rejected/);
+});
+
+test("curation report carries provenance and cited synthesized claims", async (t) => {
+  const { manager, dir } = await makeManager();
+  t.after(() => rm(dir, { recursive: true, force: true }));
+
+  // Two agents on one topic produce a synthesized overlap claim.
+  await manager.writeAgentOutput({ agentId: "agent-a", title: "deploy runbook notes", content: "deploy runbook steps" });
+  await manager.writeAgentOutput({ agentId: "agent-b", title: "deploy runbook review", content: "deploy runbook feedback" });
+
+  const signals = await manager.synthesizeCrossSignals({ date: today() });
+  assert.equal(signals.report.provenance.actor, "shared-context:curation");
+  assert.ok(!Number.isNaN(Date.parse(signals.report.provenance.at)), "provenance.at is a valid instant");
+  assert.ok(signals.report.overlaps.length > 0, "shared topic produces an overlap claim");
+  for (const overlap of signals.report.overlaps) {
+    assert.ok(overlap.sourcePaths.length > 0, `overlap ${overlap.token} cites source item ids`);
+  }
+
+  // The curation self-check gates the roundtable: it throws on an
+  // uncited synthesized claim and passes when every claim cites.
+  const curation = await manager.curateDaily({ date: today() });
+  const roundtable = await readFile(curation.roundtablePath, "utf-8");
+  assert.match(roundtable, /\[sources: [^\]]+\]/, "synthesized overlap claims cite their sources");
+});