@heretek-ai/epistemic-swarm 0.2.2 → 0.3.0

package/runner/tests/fixtures/auction_objective.json

@@ -0,0 +1,35 @@
+{
+  "objective_set": "auction-f-v1",
+  "note": "Fixed 4-scope objective for the Stream F auction-vs-DAG probe. Stable set: do not edit between runs, or wall-clock and claims/token are not comparable.",
+  "objective": "Evaluate the operational envelope of content-addressed research caches for long-lived engineering briefs",
+  "scopes": [
+    {
+      "scope_id": "scope_01_integrity",
+      "title": "Tamper evidence in content-addressed caches",
+      "objective": "Assess mechanisms for detecting tampering in SHA-256 addressed document caches",
+      "dependencies": [],
+      "bid": 4.0
+    },
+    {
+      "scope_id": "scope_02_staleness",
+      "title": "Claim staleness and source retraction",
+      "objective": "Determine how retraction and revision events should degrade previously verified claims",
+      "dependencies": ["scope_01_integrity"],
+      "bid": 3.0
+    },
+    {
+      "scope_id": "scope_03_portability",
+      "title": "Portable proof-carrying briefs",
+      "objective": "Evaluate self-contained signed brief bundles for third-party re-verification",
+      "dependencies": [],
+      "bid": 2.0
+    },
+    {
+      "scope_id": "scope_04_allocation",
+      "title": "Research resource allocation policies",
+      "objective": "Compare static DAG ordering versus bid-based allocation of dialectic research scopes",
+      "dependencies": [],
+      "bid": 1.0
+    }
+  ]
+}

package/runner/tests/fixtures/borderline_claims.json

@@ -0,0 +1,27 @@
+{
+  "fixture_id": "borderline-g-v1",
+  "note": "20 borderline claims for the Domain Packs probe. Mechanisms: 6 banned-domain, 2 missing-tag, 2 retracted-source (see retracted_hashes), 10 clean preprint-tier. Default constitution should ACCEPT all 20; biopharma should REJECT >= 25%.",
+  "retracted_hashes": ["RETRACTED_SRC_A", "RETRACTED_SRC_B"],
+  "claims": [
+    {"claim_id": "BB-01", "tag": "VERIFIED", "statement": "Cohort endpoint met primary efficacy bar", "source_hash": "PREPRINT_01", "source_url": "https://banned-preprint-mirror.example/p1", "verbatim_quote": "primary efficacy bar met", "tier": "PREPRINT"},
+    {"claim_id": "BB-02", "tag": "VERIFIED", "statement": "Adverse event rate within expected band", "source_hash": "PREPRINT_02", "source_url": "https://banned-preprint-mirror.example/p2", "verbatim_quote": "within expected band", "tier": "PREPRINT"},
+    {"claim_id": "BB-03", "tag": "VERIFIED", "statement": "Secondary endpoint shows dose response", "source_hash": "PREPRINT_03", "source_url": "https://banned-preprint-mirror.example/p3", "verbatim_quote": "dose response observed", "tier": "PREPRINT"},
+    {"claim_id": "BB-04", "tag": "VERIFIED", "statement": "Biomarker subgroup analysis favorable", "source_hash": "PREPRINT_04", "source_url": "https://predatory-journal.example/p4", "verbatim_quote": "subgroup analysis favorable", "tier": "PREPRINT"},
+    {"claim_id": "BB-05", "tag": "VERIFIED", "statement": "Pharmacokinetics consistent with model", "source_hash": "PREPRINT_05", "source_url": "https://predatory-journal.example/p5", "verbatim_quote": "consistent with model", "tier": "PREPRINT"},
+    {"claim_id": "BB-06", "tag": "VERIFIED", "statement": "Manufacturing yield acceptable at scale", "source_hash": "PREPRINT_06", "source_url": "https://banned-preprint-mirror.example/p6", "verbatim_quote": "yield acceptable at scale", "tier": "PREPRINT"},
+    {"claim_id": "BB-07", "tag": "", "statement": "Untagged assertion lacking epistemic classification", "source_hash": "CLEAN_01", "source_url": "https://journal.example/c1", "verbatim_quote": "assertion recorded without tag", "tier": "PREPRINT"},
+    {"claim_id": "BB-08", "tag": "", "statement": "Second untagged assertion in the borderline set", "source_hash": "CLEAN_02", "source_url": "https://journal.example/c2", "verbatim_quote": "second assertion without tag", "tier": "PREPRINT"},
+    {"claim_id": "BB-09", "tag": "VERIFIED", "statement": "Claim resting on a retracted source", "source_hash": "RETRACTED_SRC_A", "source_url": "https://journal.example/r1", "verbatim_quote": "finding later retracted", "tier": "PREPRINT"},
+    {"claim_id": "BB-10", "tag": "VERIFIED", "statement": "Second claim resting on a retracted source", "source_hash": "RETRACTED_SRC_B", "source_url": "https://journal.example/r2", "verbatim_quote": "second retracted finding", "tier": "PREPRINT"},
+    {"claim_id": "BB-11", "tag": "VERIFIED", "statement": "Preprint claim near acceptance boundary", "source_hash": "CLEAN_03", "source_url": "https://journal.example/c3", "verbatim_quote": "near acceptance boundary", "tier": "PREPRINT"},
+    {"claim_id": "BB-12", "tag": "VERIFIED", "statement": "Preprint claim with modest evidence", "source_hash": "CLEAN_04", "source_url": "https://journal.example/c4", "verbatim_quote": "modest evidence presented", "tier": "PREPRINT"},
+    {"claim_id": "BB-13", "tag": "VERIFIED", "statement": "Preprint claim with weak statistical power", "source_hash": "CLEAN_05", "source_url": "https://journal.example/c5", "verbatim_quote": "weak statistical power", "tier": "PREPRINT"},
+    {"claim_id": "BB-14", "tag": "VERIFIED", "statement": "Preprint claim awaiting replication", "source_hash": "CLEAN_06", "source_url": "https://journal.example/c6", "verbatim_quote": "awaiting replication", "tier": "PREPRINT"},
+    {"claim_id": "BB-15", "tag": "VERIFIED", "statement": "Preprint claim with narrow applicability", "source_hash": "CLEAN_07", "source_url": "https://journal.example/c7", "verbatim_quote": "narrow applicability", "tier": "PREPRINT"},
+    {"claim_id": "BB-16", "tag": "VERIFIED", "statement": "Preprint claim with exploratory endpoint", "source_hash": "CLEAN_08", "source_url": "https://journal.example/c8", "verbatim_quote": "exploratory endpoint", "tier": "PREPRINT"},
+    {"claim_id": "BB-17", "tag": "VERIFIED", "statement": "Preprint claim with post-hoc analysis", "source_hash": "CLEAN_09", "source_url": "https://journal.example/c9", "verbatim_quote": "post-hoc analysis", "tier": "PREPRINT"},
+    {"claim_id": "BB-18", "tag": "VERIFIED", "statement": "Preprint claim with surrogate endpoint", "source_hash": "CLEAN_10", "source_url": "https://journal.example/c10", "verbatim_quote": "surrogate endpoint", "tier": "PREPRINT"},
+    {"claim_id": "BB-19", "tag": "VERIFIED", "statement": "Preprint claim with single-site data", "source_hash": "CLEAN_11", "source_url": "https://journal.example/c11", "verbatim_quote": "single-site data", "tier": "PREPRINT"},
+    {"claim_id": "BB-20", "tag": "VERIFIED", "statement": "Preprint claim with interim readout", "source_hash": "CLEAN_12", "source_url": "https://journal.example/c12", "verbatim_quote": "interim readout", "tier": "PREPRINT"}
+  ]
+}

package/runner/tests/fixtures/divergence_objectives.json

@@ -0,0 +1,31 @@
+{
+  "objective_set": "divergence-g2-v1",
+  "note": "5 fixed objectives for the Stream E cross-family divergence probe. Stable set: do not edit between runs, or the delta is not comparable.",
+  "objectives": [
+    {
+      "id": "G2-01",
+      "objective": "Evaluate feasibility of sub-100ms Poseidon witness generation on commodity GPUs",
+      "domain": "zk-prover-hardware"
+    },
+    {
+      "id": "G2-02",
+      "objective": "Assess whether content-addressed citation caches can be made tamper-evident without a PKI",
+      "domain": "epistemic-infrastructure"
+    },
+    {
+      "id": "G2-03",
+      "objective": "Determine the conditions under which multi-agent dialectic research outperforms single-model deep research",
+      "domain": "multi-agent-methodology"
+    },
+    {
+      "id": "G2-04",
+      "objective": "Evaluate zero-dependency stdio MCP servers versus SDK-based MCP servers for CLI-distributed tooling",
+      "domain": "developer-tooling"
+    },
+    {
+      "id": "G2-05",
+      "objective": "Assess whether claim-level staleness tracking changes the reliability of long-lived research briefs",
+      "domain": "research-durability"
+    }
+  ]
+}

package/runner/tests/test_auction_order.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python3
+"""Tests for the Stream F Frontier Markets auctioneer (deterministic, mock).
+
+The live probe (wall-clock parity + >=20% claims/token) is scripts/auction_experiment.py
+— it needs real models and is NOT a CI step. These tests pin the allocation
+semantics: bid ordering, explicit-bid override, DAG default untouched.
+"""
+
+import json
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+from runner.auctioneer import (  # noqa: E402
+    bid_scope,
+    dependency_depth,
+    estimate_tokens,
+    order_scope_ids,
+    pick_next,
+    record_scope_telemetry,
+    score_scopes,
+    unresolved_frontier_questions,
+)
+
+
+def scope(sid, deps=None, bid=None):
+    s = {"scope_id": sid, "dependencies": deps or []}
+    if bid is not None:
+        s["bid"] = bid
+    return s
+
+
+class TestBidHeuristic(unittest.TestCase):
+    def test_dependency_depth(self):
+        scopes = [
+            scope("a"),
+            scope("b", ["a"]),
+            scope("c", ["b"]),
+            scope("d"),
+        ]
+        self.assertEqual(dependency_depth(scopes[0], scopes), 0)
+        self.assertEqual(dependency_depth(scopes[1], scopes), 1)
+        self.assertEqual(dependency_depth(scopes[2], scopes), 2)
+        self.assertEqual(dependency_depth(scopes[3], scopes), 0)
+
+    def test_unresolved_frontier_questions(self):
+        frontier = {
+            "nodes": {
+                "n1": {"question": "q1", "settled_answer": "yes"},
+                "n2": {"question": "q2", "settled_answer": None},
+                "n3": {"question": "q3"},
+            }
+        }
+        self.assertEqual(unresolved_frontier_questions(frontier), 2)
+        self.assertEqual(unresolved_frontier_questions({}), 0)
+
+    def test_explicit_bid_wins(self):
+        s = scope("a", bid=42.5)
+        self.assertEqual(bid_scope(s), 42.5)
+
+    def test_frontier_weighting_prefers_shallow(self):
+        frontier = {"nodes": {"n1": {"question": "q", "settled_answer": None}}}
+        shallow = scope("a")
+        deep = scope("c", ["b"])
+        b_shallow = bid_scope(shallow, all_scopes=[shallow, scope("b"), deep], frontier=frontier)
+        b_deep = bid_scope(deep, all_scopes=[shallow, scope("b"), deep], frontier=frontier)
+        self.assertGreater(b_shallow, b_deep)
+
+    def test_deterministic(self):
+        scopes = [scope("b", ["a"]), scope("a"), scope("c", ["a"], bid=0.1)]
+        frontier = {"nodes": {"n1": {"settled_answer": None}}}
+        first = [b for b, _s in score_scopes(scopes, frontier=frontier)]
+        second = [b for b, _s in score_scopes(scopes, frontier=frontier)]
+        self.assertEqual(first, second)
+
+
+class TestAuctionOrdering(unittest.TestCase):
+    def test_orders_by_descending_bid(self):
+        scopes = [
+            scope("low", bid=0.1),
+            scope("high", bid=9.0),
+            scope("mid", bid=5.0),
+        ]
+        self.assertEqual(order_scope_ids(scopes), ["high", "mid", "low"])
+
+    def test_tie_breaks_on_scope_id(self):
+        scopes = [scope("zzz", bid=1.0), scope("aaa", bid=1.0)]
+        self.assertEqual(order_scope_ids(scopes), ["aaa", "zzz"])
+
+    def test_pick_next_respects_budget(self):
+        scopes = [scope("high", bid=9.0), scope("mid", bid=5.0), scope("low", bid=0.5)]
+        self.assertEqual(pick_next(scopes)["scope_id"], "high")
+        self.assertEqual(pick_next(scopes, budget=6.0)["scope_id"], "mid")
+        self.assertIsNone(pick_next(scopes, budget=0.1))
+
+    def test_ready_batch_reordering(self):
+        """The exact shape run_swarm uses: a ready batch reordered by bid."""
+        ready = [scope("scope_02", ["scope_01"], bid=0.5), scope("scope_03", bid=3.0), scope("scope_01", bid=1.0)]
+        ordered = order_scope_ids(ready)
+        self.assertEqual(ordered, ["scope_03", "scope_01", "scope_02"])
+
+
+class TestTelemetry(unittest.TestCase):
+    def test_record_scope_telemetry(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            smdir = base / "scratchpads" / "scope_01"
+            smdir.mkdir(parents=True)
+            (smdir / "manifest.json").write_text(json.dumps({"scope_id": "scope_01", "status": "COMPLETE"}))
+
+            record_scope_telemetry(base, "scope_01", tokens_used=1234, verified_claims=7, bid=2.5)
+            manifest = json.loads((smdir / "manifest.json").read_text())
+            self.assertEqual(manifest["telemetry"]["tokens_used"], 1234)
+            self.assertEqual(manifest["telemetry"]["verified_claims"], 7)
+            self.assertEqual(manifest["telemetry"]["bid"], 2.5)
+
+    def test_estimate_tokens_flagged_approximation(self):
+        self.assertEqual(estimate_tokens("x" * 400), 100)
+        self.assertGreaterEqual(estimate_tokens(""), 1)
+
+
+class TestSwarmAuctionIntegration(unittest.TestCase):
+    def test_dag_default_unchanged(self):
+        from runner.research_swarm import SwarmRunner
+
+        with tempfile.TemporaryDirectory() as tmp:
+            runner = SwarmRunner(base_dir=Path(tmp), mock_mode=True)
+            self.assertEqual(runner.allocation, "dag")
+
+    def test_auction_config_selected(self):
+        from runner.research_swarm import SwarmRunner
+
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            (base / "config.json").write_text(json.dumps({"allocation": "auction"}))
+            runner = SwarmRunner(base_dir=base, mock_mode=True)
+            self.assertEqual(runner.allocation, "auction")
+
+    def test_cli_override_beats_config(self):
+        from runner.research_swarm import SwarmRunner
+
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            (base / "config.json").write_text(json.dumps({"allocation": "dag"}))
+            runner = SwarmRunner(base_dir=base, mock_mode=True, allocation="auction")
+            self.assertEqual(runner.allocation, "auction")
+
+    def test_mock_swarm_runs_under_auction(self):
+        """End-to-end mock run with auction allocation completes and records telemetry."""
+        from runner.research_swarm import SwarmRunner
+
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            runner = SwarmRunner(base_dir=base, mock_mode=True, allocation="auction")
+            runner.run_swarm("Evaluate auction allocation ordering")
+
+            manifest = runner.state_machine.load_global_manifest()
+            self.assertEqual(manifest["status"], "COMPLETED")
+            # Mock orchestrator emits one scope; its manifest must carry telemetry.
+            sid = manifest["scopes"][0]["scope_id"]
+            sm = json.loads((base / "scratchpads" / sid / "manifest.json").read_text())
+            self.assertIn("telemetry", sm)
+            self.assertIn("tokens_used", sm["telemetry"])
+            self.assertIn("verified_claims", sm["telemetry"])
+
+
+if __name__ == "__main__":
+    unittest.main()

package/runner/tests/test_claim_store.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+"""Tests for the derived claim index (runner/claim_store.py).
+
+Invariant under test: the flat files are source of truth; claims.sqlite is
+rebuildable and idempotent. Double-reindex must yield an identical content
+fingerprint; cross-run dedup must collapse shared source hashes.
+"""
+
+import json
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+from runner.claim_store import ClaimStore, reindex  # noqa: E402
+
+
+def write_dossier(base: Path, scope: str, name: str, payload: dict) -> Path:
+    d = base / "scratchpads" / scope
+    d.mkdir(parents=True, exist_ok=True)
+    p = d / name
+    p.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+    return p
+
+
+class TestClaimStore(unittest.TestCase):
+    def test_reindex_twice_identical_fingerprint(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            write_dossier(
+                base,
+                "scope_01",
+                "alpha_dossier.json",
+                {
+                    "affirmative_claims": [
+                        {"claim_id": "A1", "statement": "s", "source_hash": "h1", "verbatim_quote": "q"}
+                    ],
+                    "negative_knowledge": [{"query": "q", "finding": "f"}],
+                },
+            )
+            write_dossier(
+                base,
+                "scope_01",
+                "beta_dossier.json",
+                {
+                    "falsification_claims": [
+                        {"claim_id": "B1", "statement": "t", "source_hash": "h1", "verbatim_quote": "q2", "severity": "LOW"}
+                    ],
+                },
+            )
+
+            r1 = reindex(base)
+            r2 = reindex(base)
+            self.assertEqual(r1["fingerprint"], r2["fingerprint"], "reindex must be idempotent")
+            # claims_from_dossier folds all four shapes, so negative_knowledge
+            # rows also become ClaimWitness records: 1 affirmative + 1 neg_knowledge
+            # + 1 falsification = 3.
+            self.assertEqual(r1["claims_indexed"], 3)
+            self.assertEqual(r2["claims_indexed"], 3)
+
+    def test_reindex_captures_sources(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            (base / "sources").mkdir(parents=True)
+            (base / "sources" / "h1.json").write_text(
+                json.dumps({"hash": "h1", "url": "https://x", "title": "T", "tier": "WEB_DOCUMENT"})
+            )
+            (base / "sources" / "h1.md").write_text("content")
+
+            result = reindex(base)
+            self.assertEqual(result["sources_indexed"], 1)
+
+            store = ClaimStore(base)
+            rows = store.conn.execute("SELECT * FROM sources").fetchall()
+            self.assertEqual(len(rows), 1)
+            self.assertEqual(rows[0]["url"], "https://x")
+            store.close()
+
+    def test_cross_run_dedup(self):
+        """Two runs citing one source hash => one sources row, N claim rows."""
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            # Register the shared source once (as a cache metadata file).
+            (base / "sources").mkdir(parents=True)
+            (base / "sources" / "SHARED_HASH.json").write_text(
+                json.dumps({"hash": "SHARED_HASH", "url": "https://shared", "title": "Shared"})
+            )
+            (base / "sources" / "SHARED_HASH.md").write_text("body")
+
+            for scope in ("scope_01", "scope_02"):
+                write_dossier(
+                    base,
+                    scope,
+                    "alpha_dossier.json",
+                    {
+                        "affirmative_claims": [
+                            {
+                                "claim_id": f"{scope}-A1",
+                                "statement": f"claim from {scope}",
+                                "source_hash": "SHARED_HASH",
+                                "verbatim_quote": "q",
+                            }
+                        ]
+                    },
+                )
+            reindex(base)
+
+            store = ClaimStore(base)
+            claims = store.claims_citing("SHARED_HASH")
+            self.assertEqual(len(claims), 2, "both claims present")
+            # One source row (deduped by primary key)
+            n_sources = store.conn.execute(
+                "SELECT COUNT(*) AS n FROM sources WHERE source_hash = ?", ("SHARED_HASH",)
+            ).fetchone()["n"]
+            self.assertEqual(n_sources, 1)
+            store.close()
+
+    def test_search_statements(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            write_dossier(
+                base,
+                "scope_01",
+                "alpha_dossier.json",
+                {
+                    "affirmative_claims": [
+                        {"claim_id": "A1", "statement": "Poseidon hash prover latency", "source_hash": "h", "verbatim_quote": "q"}
+                    ]
+                },
+            )
+            reindex(base)
+            store = ClaimStore(base)
+            hits = store.search_statements("Poseidon")
+            self.assertEqual(len(hits), 1)
+            self.assertEqual(hits[0]["claim_id"], "A1")
+            store.close()
+
+    def test_status_event_append(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            store = ClaimStore(base)
+            store.record_status_event("scope_01", "A1", "LIVE", "STALE", "retracted", "2026-09-26T00:00:00Z")
+            store.record_status_event("scope_01", "A1", "STALE", "SUSPECT", "revised", "2026-09-26T01:00:00Z")
+            rows = store.conn.execute("SELECT * FROM status_events ORDER BY event_id").fetchall()
+            self.assertEqual(len(rows), 2)
+            self.assertEqual(rows[0]["to_status"], "STALE")
+            self.assertEqual(rows[1]["to_status"], "SUSPECT")
+            store.close()
+
+    def test_fts5_flag_is_boolean(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            store = ClaimStore(Path(tmp))
+            self.assertIsInstance(store.fts5, bool)
+            store.close()
+
+
+if __name__ == "__main__":
+    unittest.main()

package/runner/tests/test_claim_witness.py

@@ -0,0 +1,186 @@
+#!/usr/bin/env python3
+"""Tests for the normalized ClaimWitness model (runner/claim_witness.py)."""
+
+import sys
+import unittest
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+from runner.claim_witness import (  # noqa: E402
+    KIND_CLAIM,
+    KIND_HYPOTHESIS,
+    KIND_INFERENCE,
+    KIND_NEGATIVE_KNOWLEDGE,
+    STATUS_LIVE,
+    TAG_HYPOTHESIS,
+    TAG_INFERRED,
+    TAG_NEGATIVE_KNOWLEDGE,
+    TAG_VERIFIED,
+    claims_from_dossier,
+    normalize_claim,
+    witness_check,
+)
+
+
+class TestNormalizeClaim(unittest.TestCase):
+    def test_normalize_claim_kind_claim(self):
+        raw = {
+            "claim_id": "C-01",
+            "tag": "VERIFIED",
+            "statement": "s",
+            "source_hash": "abc",
+            "source_url": "u",
+            "verbatim_quote": "q",
+            "severity": "LOW",
+        }
+        c = normalize_claim(raw, kind=KIND_CLAIM)
+        self.assertEqual(c.claim_id, "C-01")
+        self.assertEqual(c.kind, KIND_CLAIM)
+        self.assertEqual(c.tag, TAG_VERIFIED)
+        self.assertEqual(c.source_hash, "abc")
+        self.assertEqual(c.severity, "LOW")
+        self.assertEqual(c.status, STATUS_LIVE)
+
+    def test_normalize_claim_kind_inference(self):
+        raw = {
+            "inference_id": "I-01",
+            "tag": "INFERRED",
+            "statement": "s",
+            "parent_claims": ["C-01"],
+            "deductive_logic": "because",
+        }
+        c = normalize_claim(raw, kind=KIND_INFERENCE)
+        self.assertEqual(c.claim_id, "I-01")
+        self.assertEqual(c.kind, KIND_INFERENCE)
+        self.assertEqual(c.tag, TAG_INFERRED)
+        self.assertEqual(c.parent_claims, ["C-01"])
+        self.assertEqual(c.deductive_logic, "because")
+
+    def test_normalize_claim_kind_hypothesis(self):
+        raw = {
+            "hypothesis_id": "H-01",
+            "tag": "HYPOTHESIS",
+            "statement": "s",
+            "falsification": "measurable test",
+        }
+        c = normalize_claim(raw, kind=KIND_HYPOTHESIS)
+        self.assertEqual(c.claim_id, "H-01")
+        self.assertEqual(c.kind, KIND_HYPOTHESIS)
+        self.assertEqual(c.tag, TAG_HYPOTHESIS)
+        self.assertEqual(c.falsification, "measurable test")
+
+    def test_normalize_claim_kind_negative_knowledge(self):
+        raw = {"query": "q", "finding": "nothing found"}
+        c = normalize_claim(raw, kind=KIND_NEGATIVE_KNOWLEDGE)
+        self.assertEqual(c.kind, KIND_NEGATIVE_KNOWLEDGE)
+        self.assertEqual(c.tag, TAG_NEGATIVE_KNOWLEDGE)
+        self.assertEqual(c.query, "q")
+        self.assertEqual(c.finding, "nothing found")
+
+    def test_parent_claims_accepts_string(self):
+        c = normalize_claim({"inference_id": "I", "parent_claims": "C-01"}, KIND_INFERENCE)
+        self.assertEqual(c.parent_claims, ["C-01"])
+
+    def test_missing_tag_defaults_by_kind(self):
+        c = normalize_claim({"claim_id": "C"}, KIND_CLAIM)
+        self.assertEqual(c.tag, TAG_VERIFIED)
+        c = normalize_claim({"inference_id": "I"}, KIND_INFERENCE)
+        self.assertEqual(c.tag, TAG_INFERRED)
+
+
+class TestClaimsFromDossier(unittest.TestCase):
+    def test_extracts_all_four_shapes(self):
+        dossier = {
+            "affirmative_claims": [{"claim_id": "A1", "statement": "s"}],
+            "falsification_claims": [{"claim_id": "B1", "statement": "s", "severity": "HIGH"}],
+            "inferred_implications": [{"inference_id": "I1", "parent_claims": ["A1"]}],
+            "hypotheses": [{"hypothesis_id": "H1", "falsification": "t"}],
+            "negative_knowledge": [{"query": "q", "finding": "f"}],
+        }
+        claims = claims_from_dossier(dossier)
+        self.assertEqual(len(claims), 5)
+        kinds = sorted(c.kind for c in claims)
+        self.assertEqual(
+            kinds,
+            sorted(
+                [
+                    KIND_CLAIM,
+                    KIND_CLAIM,
+                    KIND_INFERENCE,
+                    KIND_HYPOTHESIS,
+                    KIND_NEGATIVE_KNOWLEDGE,
+                ]
+            ),
+        )
+
+    def test_handles_missing_keys(self):
+        self.assertEqual(claims_from_dossier({}), [])
+
+    def test_handles_non_list_rows(self):
+        self.assertEqual(claims_from_dossier({"affirmative_claims": "not-a-list"}), [])
+
+
+class TestWitnessCheck(unittest.TestCase):
+    def test_missing_hash_or_quote_rejected(self):
+        from runner.claim_witness import ClaimWitness
+
+        class FakeHasher:
+            def verify_quote(self, h, q):
+                return True, 1.0, "ok"
+
+        c = ClaimWitness(claim_id="C", kind=KIND_CLAIM, tag=TAG_VERIFIED, statement="s")
+        passed, conf, msg = witness_check(c, FakeHasher())
+        self.assertFalse(passed)
+        self.assertEqual(conf, 0.0)
+        self.assertIn("Missing", msg)
+
+    def test_delegates_to_hasher(self):
+        from runner.claim_witness import ClaimWitness
+
+        calls = []
+
+        class FakeHasher:
+            def verify_quote(self, h, q):
+                calls.append((h, q))
+                return True, 0.99, "ok"
+
+        c = ClaimWitness(
+            claim_id="C",
+            kind=KIND_CLAIM,
+            tag=TAG_VERIFIED,
+            statement="s",
+            source_hash="h",
+            verbatim_quote="q",
+        )
+        passed, conf, msg = witness_check(c, FakeHasher())
+        self.assertTrue(passed)
+        self.assertEqual(conf, 0.99)
+        self.assertEqual(calls, [("h", "q")])
+
+    def test_real_hasher_round_trip(self):
+        import tempfile
+        from skills.research_cache.hasher import SourceHasher
+
+        with tempfile.TemporaryDirectory() as tmp:
+            hasher = SourceHasher(Path(tmp))
+            content = "Poseidon round constraints in 184ms with 45 GB/s."
+            digest = hasher.store_source(url="https://x", content=content, title="T")
+            c = normalize_claim(
+                {
+                    "claim_id": "C",
+                    "tag": "VERIFIED",
+                    "statement": "s",
+                    "source_hash": digest,
+                    "verbatim_quote": "Poseidon round constraints in 184ms",
+                }
+            )
+            passed, conf, _msg = witness_check(c, hasher)
+            self.assertTrue(passed)
+            self.assertGreaterEqual(conf, 0.95)
+
+
+if __name__ == "__main__":
+    unittest.main()