@heretek-ai/epistemic-swarm 0.2.2 → 0.3.0

package/runner/tests/test_refinement.py

@@ -0,0 +1,255 @@
+#!/usr/bin/env python3
+"""Tests for the refinement-type checker and pure E(D) scoring.
+
+Property-style checks are seeded hand-rolled loops (200 random claim sets)
+rather than a hypothesis dependency — zero-dep constraint holds.
+"""
+
+import random
+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_REJECTED,
+    TAG_HYPOTHESIS,
+    TAG_INFERRED,
+    TAG_NEGATIVE_KNOWLEDGE,
+    TAG_VERIFIED,
+    ClaimWitness,
+)
+from runner.refinement import (  # noqa: E402
+    LEGACY_CONSTITUTION,
+    Constitution,
+    check_invariants,
+    compute_epistemic_score,
+    compute_epistemic_score_from_claims,
+)
+
+
+def make_claim(**kw) -> ClaimWitness:
+    base = dict(
+        claim_id="C",
+        kind=KIND_CLAIM,
+        tag=TAG_VERIFIED,
+        statement="s",
+        source_hash="h",
+        verbatim_quote="q",
+    )
+    base.update(kw)
+    return ClaimWitness(**base)
+
+
+class TestCheckInvariants(unittest.TestCase):
+    def test_verified_requires_hash_and_quote(self):
+        bad = make_claim(claim_id="C1", source_hash=None, verbatim_quote=None)
+        viols = check_invariants([bad])
+        rules = {v.rule for v in viols}
+        self.assertIn("VERIFIED_REQUIRES_HASH", rules)
+        self.assertIn("VERIFIED_REQUIRES_QUOTE", rules)
+
+    def test_inferred_requires_parents_and_logic(self):
+        bad = make_claim(
+            claim_id="I1",
+            kind=KIND_INFERENCE,
+            tag=TAG_INFERRED,
+            source_hash=None,
+            verbatim_quote=None,
+            parent_claims=[],
+            deductive_logic=None,
+        )
+        viols = check_invariants([bad])
+        rules = {v.rule for v in viols}
+        self.assertIn("INFERRED_REQUIRES_PARENTS", rules)
+        self.assertIn("INFERRED_REQUIRES_LOGIC", rules)
+
+    def test_hypothesis_requires_falsification(self):
+        bad = make_claim(
+            claim_id="H1",
+            kind=KIND_HYPOTHESIS,
+            tag=TAG_HYPOTHESIS,
+            source_hash=None,
+            verbatim_quote=None,
+            falsification=None,
+        )
+        viols = check_invariants([bad])
+        self.assertIn("HYPOTHESIS_REQUIRES_FALSIFICATION", {v.rule for v in viols})
+
+    def test_neg_knowledge_requires_query_and_finding(self):
+        bad = make_claim(
+            claim_id="N1",
+            kind=KIND_NEGATIVE_KNOWLEDGE,
+            tag=TAG_NEGATIVE_KNOWLEDGE,
+            source_hash=None,
+            verbatim_quote=None,
+            query=None,
+            finding=None,
+        )
+        viols = check_invariants([bad])
+        rules = {v.rule for v in viols}
+        self.assertIn("NEG_KNOWLEDGE_REQUIRES_QUERY", rules)
+        self.assertIn("NEG_KNOWLEDGE_REQUIRES_FINDING", rules)
+
+    def test_parent_cross_ref_resolution(self):
+        good_parent = make_claim(claim_id="C1")
+        orphan = make_claim(
+            claim_id="I1",
+            kind=KIND_INFERENCE,
+            tag=TAG_INFERRED,
+            source_hash=None,
+            verbatim_quote=None,
+            parent_claims=["DOES_NOT_EXIST"],
+            deductive_logic="because",
+        )
+        viols = check_invariants([good_parent, orphan])
+        self.assertIn("PARENT_UNRESOLVED", {v.rule for v in viols})
+
+    def test_clean_set_has_no_violations(self):
+        c1 = make_claim(claim_id="C1")
+        c2 = make_claim(
+            claim_id="I1",
+            kind=KIND_INFERENCE,
+            tag=TAG_INFERRED,
+            source_hash=None,
+            verbatim_quote=None,
+            parent_claims=["C1"],
+            deductive_logic="therefore",
+        )
+        self.assertEqual(check_invariants([c1, c2]), [])
+
+    def test_witness_check_with_hasher(self):
+        import tempfile
+        from skills.research_cache.hasher import SourceHasher
+
+        with tempfile.TemporaryDirectory() as tmp:
+            hasher = SourceHasher(Path(tmp))
+            content = "Verbatim sentence here."
+            digest = hasher.store_source(url="https://x", content=content)
+            good = make_claim(
+                claim_id="C1", source_hash=digest, verbatim_quote="Verbatim sentence"
+            )
+            bad = make_claim(
+                claim_id="C2", source_hash=digest, verbatim_quote="never in source"
+            )
+            viols = check_invariants([good, bad], hasher=hasher)
+            rules_by_id = {v.claim_id: v.rule for v in viols}
+            self.assertNotIn("C1", rules_by_id)
+            self.assertEqual(rules_by_id.get("C2"), "WITNESS_CHECK_FAILED")
+
+    def test_banned_domain_rule(self):
+        const = Constitution(banned_domains=["banned.example"])
+        bad = make_claim(claim_id="C1", source_url="https://banned.example/paper")
+        viols = check_invariants([bad], constitution=const)
+        self.assertIn("BANNED_DOMAIN", {v.rule for v in viols})
+
+
+class TestComputeEpistemicScore(unittest.TestCase):
+    def test_legacy_formula_exact(self):
+        # 1 verified, 1 inferred, 1 hypothesis, 1 rejected, 1 neg_knowledge
+        # raw = (1.0*1 + 0.5*1 - 2.5*1) / (1+1+1+1) = (1+0.5-2.5)/4 = -1/4 = -0.25
+        # clamped to 0.0
+        score, br = compute_epistemic_score(
+            {"verified": 1, "rejected": 1, "inferred": 1, "hypotheses": 1, "neg_knowledge": 1}
+        )
+        self.assertEqual(score, 0.0)
+        self.assertEqual(br["verified_passed"], 1)
+        self.assertEqual(br["unverified_rejected"], 1)
+        self.assertEqual(br["negative_knowledge_count"], 1)
+
+    def test_legacy_formula_all_verified(self):
+        # 2 verified, 0 else: raw = 2/2 = 1.0
+        score, _ = compute_epistemic_score(
+            {"verified": 2, "rejected": 0, "inferred": 0, "hypotheses": 0, "neg_knowledge": 0}
+        )
+        self.assertEqual(score, 1.0)
+
+    def test_score_bounded(self):
+        for counts in (
+            {"verified": 0, "rejected": 0, "inferred": 0, "hypotheses": 0, "neg_knowledge": 0},
+            {"verified": 0, "rejected": 100, "inferred": 0, "hypotheses": 0, "neg_knowledge": 0},
+            {"verified": 100, "rejected": 0, "inferred": 0, "hypotheses": 0, "neg_knowledge": 100},
+        ):
+            score, _ = compute_epistemic_score(counts)
+            self.assertGreaterEqual(score, 0.0)
+            self.assertLessEqual(score, 1.0)
+
+    def test_deterministic(self):
+        counts = {"verified": 3, "rejected": 1, "inferred": 2, "hypotheses": 1, "neg_knowledge": 2}
+        s1, b1 = compute_epistemic_score(counts)
+        s2, b2 = compute_epistemic_score(counts)
+        self.assertEqual(s1, s2)
+        self.assertEqual(b1, b2)
+
+    def test_monotone_rejection_penalty(self):
+        base = {"verified": 5, "rejected": 0, "inferred": 0, "hypotheses": 0, "neg_knowledge": 0}
+        more_rejects = dict(base, rejected=3)
+        s0, _ = compute_epistemic_score(base)
+        s1, _ = compute_epistemic_score(more_rejects)
+        self.assertLessEqual(s1, s0)
+
+    def test_zero_assertions_clamps(self):
+        score, br = compute_epistemic_score(
+            {"verified": 0, "rejected": 0, "inferred": 0, "hypotheses": 0, "neg_knowledge": 0}
+        )
+        self.assertEqual(score, 0.0)
+        self.assertEqual(br["total_assertions"], 1)
+
+    def test_property_loops_200_random_claim_sets(self):
+        rng = random.Random(0xF00D)
+        for _ in range(200):
+            counts = {
+                "verified": rng.randint(0, 20),
+                "rejected": rng.randint(0, 10),
+                "inferred": rng.randint(0, 10),
+                "hypotheses": rng.randint(0, 10),
+                "neg_knowledge": rng.randint(0, 5),
+            }
+            score, _br = compute_epistemic_score(counts)
+            self.assertGreaterEqual(score, 0.0, counts)
+            self.assertLessEqual(score, 1.0, counts)
+            # Determinism
+            score2, _ = compute_epistemic_score(counts)
+            self.assertEqual(score, score2)
+            # More rejections never improve the score
+            worse = dict(counts, rejected=counts["rejected"] + 1)
+            worse_score, _ = compute_epistemic_score(worse)
+            self.assertLessEqual(worse_score, score, (counts, worse))
+
+
+class TestConstitution(unittest.TestCase):
+    def test_legacy_default_is_flat(self):
+        self.assertEqual(LEGACY_CONSTITUTION.weight_for(None), 1.0)
+        self.assertEqual(LEGACY_CONSTITUTION.weight_for("PREPRINT"), 1.0)
+
+    def test_tier_weights_override(self):
+        const = Constitution(tier_weights={"PREPRINT": 0.3, "__default__": 1.0})
+        self.assertEqual(const.weight_for("PREPRINT"), 0.3)
+        self.assertEqual(const.weight_for("PEER_REVIEWED"), 1.0)
+
+    def test_tier_weighted_claims_path(self):
+        # Legacy: 2 verified = 1.0
+        legacy_claims = [make_claim(claim_id=f"C{i}") for i in range(2)]
+        s_legacy, _ = compute_epistemic_score_from_claims(legacy_claims)
+        self.assertEqual(s_legacy, 1.0)
+
+        # Biopharma-ish: preprints downgraded to 0.3
+        const = Constitution(tier_weights={"PREPRINT": 0.3, "__default__": 1.0})
+        preprints = [
+            make_claim(claim_id=f"C{i}", tier="PREPRINT") for i in range(2)
+        ]
+        s_tiered, br = compute_epistemic_score_from_claims(preprints, constitution=const)
+        # weight = 0.3*2 = 0.6, assertions = 2, raw = 0.6/2 = 0.3
+        self.assertEqual(s_tiered, 0.3)
+        self.assertAlmostEqual(br["verified_weight"], 0.6, places=3)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/runner/tests/test_swarm.py

@@ -20,6 +20,7 @@ from runner.state_machine import ResearchStateMachine, SessionStatus, ScopeStatu
 from runner.auditor_engine import EpistemicAuditorEngine
 from runner.research_swarm import SwarmRunner
 
+
 class TestEpistemicSwarm(unittest.TestCase):
     def setUp(self):
         self.test_dir = Path(tempfile.mkdtemp(prefix="epistemic_test_"))
@@ -38,7 +39,7 @@ In our experiments, the 70B parameter model was trained on 15.0 trillion tokens.
         shash = self.hasher.store_source(
             url="https://arxiv.org/abs/2203.15556",
             content=content,
-            title="Chinchilla Scaling Laws"
+            title="Chinchilla Scaling Laws",
         )
         self.assertTrue(len(shash) == 64)
 
@@ -57,7 +58,8 @@ In our experiments, the 70B parameter model was trained on 15.0 trillion tokens.
 
         # 3. Fabricated quote rejection
         verified_fake, conf_fake, _ = self.hasher.verify_quote(
-            shash, "the 70B parameter model was trained on 500 quadrillion tokens by aliens."
+            shash,
+            "the 70B parameter model was trained on 500 quadrillion tokens by aliens.",
         )
         self.assertFalse(verified_fake)
         self.assertLess(conf_fake, 0.8)
@@ -68,13 +70,13 @@ In our experiments, the 70B parameter model was trained on 15.0 trillion tokens.
             {
                 "scope_id": "scope_01_prover",
                 "title": "Prover Benchmarks",
-                "dependencies": []
+                "dependencies": [],
             },
             {
                 "scope_id": "scope_02_recursion",
                 "title": "Recursive Verification",
-                "dependencies": ["scope_01_prover"]
-            }
+                "dependencies": ["scope_01_prover"],
+            },
         ]
         self.state_machine.set_scopes(scopes)
 
@@ -96,7 +98,7 @@ In our experiments, the 70B parameter model was trained on 15.0 trillion tokens.
         shash = self.hasher.store_source(
             url="https://benchmark.org/zk",
             content="FPGA prover executes Poseidon in 184ms.",
-            title="ZK Benchmarks"
+            title="ZK Benchmarks",
         )
 
         # 2. Initialize scope
@@ -113,17 +115,17 @@ In our experiments, the 70B parameter model was trained on 15.0 trillion tokens.
                     "tag": "VERIFIED",
                     "statement": "Poseidon prover executes in 184ms",
                     "source_hash": shash,
-                    "verbatim_quote": "FPGA prover executes Poseidon in 184ms."
+                    "verbatim_quote": "FPGA prover executes Poseidon in 184ms.",
                 },
                 {
                     "claim_id": "A2",
                     "tag": "VERIFIED",
                     "statement": "Hallucinated claim that does not exist in source",
                     "source_hash": shash,
-                    "verbatim_quote": "This string does not exist anywhere in the text."
-                }
+                    "verbatim_quote": "This string does not exist anywhere in the text.",
+                },
             ],
-            "negative_knowledge": [{"query": "q1", "finding": "None"}]
+            "negative_knowledge": [{"query": "q1", "finding": "None"}],
         }
 
         # 4. Create Beta Dossier
@@ -134,10 +136,10 @@ In our experiments, the 70B parameter model was trained on 15.0 trillion tokens.
             "methodological_critiques": [
                 {
                     "target_assertion": "Poseidon prover executes in 184ms",
-                    "critique": "Benchmark excludes PCIe host bus latency"
+                    "critique": "Benchmark excludes PCIe host bus latency",
                 }
             ],
-            "negative_knowledge": []
+            "negative_knowledge": [],
         }
 
         self.state_machine.record_agent_completion("scope_test", "alpha", alpha_dossier)
@@ -189,7 +191,9 @@ In our experiments, the 70B parameter model was trained on 15.0 trillion tokens.
 
         for ext_path in pkg["pi"].get("extensions", []):
             resolved = (PROJECT_ROOT / ext_path).resolve()
-            self.assertTrue(resolved.exists(), f"Pi extension path not found: {ext_path}")
+            self.assertTrue(
+                resolved.exists(), f"Pi extension path not found: {ext_path}"
+            )
 
         # 2. OpenCode plugin validation
         self.assertIn("opencode", pkg.get("keywords", []))
@@ -203,6 +207,7 @@ In our experiments, the 70B parameter model was trained on 15.0 trillion tokens.
 
     def test_config_manager_load_and_save(self):
         from skills.swarm_config.configure import load_config, save_config
+
         cfg = load_config(str(self.test_dir))
         self.assertEqual(cfg["search_engine"], "duckduckgo")
         self.assertEqual(cfg["mode"], "research")
@@ -237,8 +242,161 @@ In our experiments, the 70B parameter model was trained on 15.0 trillion tokens.
             content = f.read()
             self.assertIn("Open-Source Software Discovery", content)
 
+    def test_mock_brainstorm_mode(self):
+        runner = SwarmRunner(base_dir=self.test_dir, mock_mode=True, mode="brainstorm")
+        runner.run_swarm("Where do we go from here?")
 
-if __name__ == "__main__":
-    unittest.main()
+        brainstorm_report = self.test_dir / "brainstorm_report.md"
+        self.assertTrue(brainstorm_report.exists())
+        with open(brainstorm_report, "r") as f:
+            content = f.read()
+            self.assertIn("Lateral Brainstorm", content)
+
+    def test_brainstorm_prompt_and_skill_exist(self):
+        prompt = PROJECT_ROOT / "prompts" / "agent_brainstormer.md"
+        skill = PROJECT_ROOT / "skills" / "brainstorming" / "SKILL.md"
+        scaffold = (
+            PROJECT_ROOT / "skills" / "brainstorming" / "scripts" / "brainstorm.py"
+        )
+        self.assertTrue(prompt.exists())
+        self.assertTrue(skill.exists())
+        self.assertTrue(scaffold.exists())
+        text = skill.read_text(encoding="utf-8")
+        self.assertIn("name: brainstorming", text)
+        self.assertIn("HYPOTHESIS", text)
+
+    def test_universal_adapter_bundles_exist(self):
+        # AntiGravity
+        self.assertTrue((PROJECT_ROOT / "plugins/antigravity/plugin.json").exists())
+        self.assertTrue((PROJECT_ROOT / "plugins/antigravity/mcp_config.json").exists())
+        self.assertTrue((PROJECT_ROOT / "plugins/antigravity/hooks.json").exists())
+        self.assertTrue(
+            (
+                PROJECT_ROOT / "plugins/antigravity/skills/brainstorming/SKILL.md"
+            ).exists()
+        )
+        self.assertTrue(
+            (PROJECT_ROOT / "plugins/antigravity/agents/brainstormer.md").exists()
+        )
+        # Gemini
+        self.assertTrue(
+            (PROJECT_ROOT / "plugins/gemini/gemini-extension.json").exists()
+        )
+        self.assertTrue((PROJECT_ROOT / "plugins/gemini/GEMINI.md").exists())
+        self.assertTrue(
+            (PROJECT_ROOT / "plugins/gemini/commands/brainstorming.toml").exists()
+        )
+        self.assertTrue(
+            (PROJECT_ROOT / "plugins/gemini/skills/brainstorming/SKILL.md").exists()
+        )
+        # Codex
+        self.assertTrue((PROJECT_ROOT / "plugins/codex/openai.yaml").exists())
+        self.assertTrue((PROJECT_ROOT / "plugins/codex/config.toml.snippet").exists())
+        self.assertTrue(
+            (PROJECT_ROOT / "plugins/codex/skills/brainstorming/SKILL.md").exists()
+        )
+        self.assertTrue(
+            (PROJECT_ROOT / ".agents/skills/brainstorming/SKILL.md").exists()
+        )
+        # OMP (oh-my-pi)
+        self.assertTrue((PROJECT_ROOT / ".omp/commands/brainstorming.md").exists())
+        self.assertTrue((PROJECT_ROOT / ".omp/prompts/brainstorming.md").exists())
+        self.assertTrue((PROJECT_ROOT / ".omp/SYSTEM.md").exists())
+        self.assertTrue(
+            (PROJECT_ROOT / ".omp/hooks/pre/epistemic-redirect.ts").exists()
+        )
+        # package.json omp block mirrors pi block
+        with open(PROJECT_ROOT / "package.json", "r", encoding="utf-8") as f:
+            pkg = json.load(f)
+        self.assertIn("omp", pkg)
+        self.assertIn("./extensions/pi/index.js", pkg["omp"].get("extensions", []))
+        self.assertIn("./skills/brainstorming", pkg["omp"].get("skills", []))
+        self.assertIn("./skills/brainstorming", pkg["pi"].get("skills", []))
+
+    def test_opencode_and_pi_extension_interfaces(self):
+        import subprocess
+
+        # 1. Test OpenCode Plugin registration (A2b: thin forwarders + both
+        #    name exports — canonical IUMBTEMS_TOOL_NAMES and the deprecated
+        #    IUMBEMS_TOOL_NAMES alias).
+        node_code_oc = """
+        import plugin, { IUMBTEMS_TOOL_NAMES, IUMBEMS_TOOL_NAMES } from "./plugins/opencode/index.js";
+        const tools = plugin.server();
+        const names = tools.map(t => t.name);
+        console.log(JSON.stringify({
+          names,
+          canonical: IUMBTEMS_TOOL_NAMES,
+          alias: IUMBEMS_TOOL_NAMES
+        }));
+        """
+        res_oc = subprocess.run(
+            ["node", "--input-type=module", "-e", node_code_oc],
+            capture_output=True,
+            text=True,
+            cwd=str(PROJECT_ROOT),
+        )
+        self.assertEqual(
+            res_oc.returncode, 0, f"OpenCode plugin test failed: {res_oc.stderr}"
+        )
+        lines = [
+            line.strip()
+            for line in res_oc.stdout.strip().split("\n")
+            if line.strip().startswith("{")
+        ]
+        data_oc = json.loads(lines[-1])
+        tools = data_oc["names"]
+        # Canonical + deprecated alias must both exist and agree.
+        self.assertEqual(data_oc["canonical"], data_oc["alias"])
+        self.assertEqual(sorted(data_oc["canonical"]), sorted(tools))
+        expected_tools = [
+            "iumbtems_config",
+            "iumbtems_swarm_research",
+            "iumbtems_code_audit",
+            "iumbtems_oss_scout",
+            "iumbtems_brainstorm",
+            "iumbtems_verify_quote",
+            "iumbtems_socratic_frontier",
+            "iumbtems_reindex_claims",
+            "iumbtems_report_retraction",
+            "iumbtems_check_staleness",
+            "iumbtems_set_domain_pack",
+            "iumbtems_export_brief",
+            "iumbtems_verify_brief",
+        ]
+        for t in expected_tools:
+            self.assertIn(t, tools)
+
+        # 2. Test Pi Extension registration
+        node_code_pi = """
+        import initPi from "./extensions/pi/index.js";
+        const commands = [];
+        const tools = [];
+        initPi({
+          registerCommand: (name) => commands.push(name),
+          registerTool: (def) => tools.push(def.name)
+        });
+        console.log(JSON.stringify({ commands, tools }));
+        """
+        res_pi = subprocess.run(
+            ["node", "--input-type=module", "-e", node_code_pi],
+            capture_output=True,
+            text=True,
+            cwd=str(PROJECT_ROOT),
+        )
+        self.assertEqual(
+            res_pi.returncode, 0, f"Pi extension test failed: {res_pi.stderr}"
+        )
+        lines = [
+            line.strip()
+            for line in res_pi.stdout.strip().split("\n")
+            if line.strip().startswith("{")
+        ]
+        data = json.loads(lines[-1])
+        for c in ["swarm", "grill", "swarm-config", "audit", "scout", "brainstorming"]:
+            self.assertIn(c, data["commands"])
+        for t in ["iumbtems_verify_quote", "iumbtems_config", "iumbtems_brainstorm"]:
+            self.assertIn(t, data["tools"])
 
 
+if __name__ == "__main__":
+    unittest.main()