@heretek-ai/epistemic-swarm 0.7.21 → 0.7.22

package/runner/tests/fixtures/config_validation_cases.json

@@ -134,6 +134,37 @@
       "expect": "search_timeout_s",
       "config": {"search_timeout_s": 0}
     },
+    {
+      "name": "float_integral_divergence_above_maximum",
+      "valid": false,
+      "expect": "maximum",
+      "config": {"divergence_threshold": 2.0}
+    },
+    {
+      "name": "float_integral_search_timeout_below_minimum",
+      "valid": false,
+      "expect": "minimum",
+      "config": {"search_timeout_s": 0.0}
+    },
+    {
+      "name": "float_integral_min_fuzzy_above_maximum",
+      "valid": false,
+      "expect": "min_fuzzy_confidence",
+      "config": {"verify": {"min_fuzzy_confidence": 2.0}}
+    },
+    {
+      "name": "float_fractional_cache_ttl_type_error",
+      "valid": false,
+      "expect": "got float",
+      "config": {"cache_ttl_days": -1.5}
+    },
+    {
+      "name": "type_integral_float_in_integer_field",
+      "valid": false,
+      "expect": "got float",
+      "lexeme_sensitive": true,
+      "config": {"cache_ttl_days": 2.0}
+    },
     {
       "name": "type_search_engine_integer",
       "valid": false,
@@ -211,6 +242,35 @@
       "valid": false,
       "expect": "pattern",
       "config": {"searxng_url": "localhost:8080"}
+    },
+    {
+      "name": "vert_searxng_url_scheme_without_host",
+      "valid": false,
+      "expect": "pattern",
+      "config": {"searxng_url": "http://"}
+    },
+    {
+      "name": "vert_searxng_url_scheme_without_host_slash",
+      "valid": false,
+      "expect": "pattern",
+      "config": {"searxng_url": "https:///path-only"}
+    },
+    {
+      "name": "vert_searxng_url_host_with_port_and_path",
+      "valid": true,
+      "config": {"searxng_url": "https://searx.local:8888/search"}
+    },
+    {
+      "name": "vert_domain_pack_whitespace_only",
+      "valid": false,
+      "expect": "pattern",
+      "config": {"domain_pack": "   "}
+    },
+    {
+      "name": "vert_domain_pack_padded",
+      "valid": false,
+      "expect": "pattern",
+      "config": {"domain_pack": " biopharma "}
     }
   ]
 }

package/runner/tests/test_config_schema.py

@@ -60,6 +60,19 @@ VALIDATION_CASES = json.loads(
 
 CONTROL_ARGS = set(CONFIG_TOOL_CONTROL_ARGS)
 
+# H1: every keyword the parity comparator deep-compares at each schema node.
+# `items` / `additionalProperties` recurse as schema nodes; `default` compares
+# by value (deep: dict/list defaults compare element-wise via !=).
+COMPARE_KEYWORDS = (
+    "type",
+    "enum",
+    "minimum",
+    "maximum",
+    "minLength",
+    "pattern",
+    "default",
+)
+
 # One representative valid value per canonical key; the test asserts this map
 # covers the schema exactly, so a new key cannot slip in without a test.
 VALID_UPDATES = {
@@ -221,27 +234,45 @@ class TestMcpConfigSurface(unittest.TestCase):
             advertised["properties"]["expectedHash"]["description"],
         )
 
+    def _compare_schema_node(self, sub, advertised_node, path, problems):
+        """Deep-compare one schema node, recursing into subschemas.
+
+        H1: besides the scalar keywords, `properties` recurses per key,
+        `items` recurses as `{path}[]`, and `additionalProperties` recurses
+        as `{path}.*`. A canonical subschema missing on the advertised side
+        is a drift report, never a silent skip.
+        """
+        for keyword in COMPARE_KEYWORDS:
+            if sub.get(keyword) != advertised_node.get(keyword):
+                problems.append(
+                    f"{path}: {keyword} {sub.get(keyword)!r} != "
+                    f"{advertised_node.get(keyword)!r}"
+                )
+        if isinstance(sub.get("properties"), dict):
+            if not isinstance(advertised_node.get("properties"), dict):
+                problems.append(f"{path}: properties schema missing on advertised side")
+            else:
+                self._compare_properties(sub, advertised_node, f"{path}.", problems)
+        for keyword, suffix in (("items", "[]"), ("additionalProperties", ".*")):
+            sub_node = sub.get(keyword)
+            if isinstance(sub_node, dict):
+                adv_node = advertised_node.get(keyword)
+                if not isinstance(adv_node, dict):
+                    problems.append(
+                        f"{path}{suffix}: {keyword} schema missing on advertised side"
+                    )
+                else:
+                    self._compare_schema_node(
+                        sub_node, adv_node, f"{path}{suffix}", problems
+                    )
+
     def _compare_properties(self, canonical, advertised, path, problems):
         for key, sub in (canonical.get("properties") or {}).items():
             adv = (advertised.get("properties") or {}).get(key)
             if adv is None:
                 problems.append(f"missing advertised key: {path}{key}")
                 continue
-            for keyword in (
-                "type",
-                "enum",
-                "minimum",
-                "maximum",
-                "minLength",
-                "pattern",
-            ):
-                if sub.get(keyword) != adv.get(keyword):
-                    problems.append(
-                        f"{path}{key}: {keyword} {sub.get(keyword)!r} != "
-                        f"{adv.get(keyword)!r}"
-                    )
-            if isinstance(sub.get("properties"), dict):
-                self._compare_properties(sub, adv, f"{path}{key}.", problems)
+            self._compare_schema_node(sub, adv, f"{path}{key}", problems)
 
     def test_parity_comparator_is_not_vacuous(self):
         """R2: the comparator must bite when the advertised surface drifts."""
@@ -264,6 +295,79 @@ class TestMcpConfigSurface(unittest.TestCase):
         self._compare_properties(artifact, drifted, "", problems)
         self.assertTrue(any("searxng_url: pattern" in p for p in problems))
 
+    def test_parity_comparator_catches_items_additionalProperties_default_drift(self):
+        """H1: each newly walked keyword bites when the advertised side drifts.
+
+        Every sub-case mutates a FRESH advertised schema exactly once, so a
+        green sub-case proves its own keyword is compared (never vacuous via
+        a shared broken fixture).
+        """
+        from runner.mcp_server import config_tool_input_schema
+
+        artifact = json.loads(
+            (PROJECT_ROOT / "schemas" / "config.schema.json").read_text(
+                encoding="utf-8"
+            )
+        )
+
+        def complained_of(mutator, needle):
+            advertised = config_tool_input_schema()
+            mutator(advertised["properties"])
+            problems = []
+            self._compare_properties(artifact, advertised, "", problems)
+            self.assertTrue(
+                any(needle in p for p in problems),
+                f"{needle!r} not in {problems}",
+            )
+
+        # `items` drift: top-level (license_whitelist) and nested
+        # (agents.alpha.backend); then a dropped `items` subschema.
+        complained_of(
+            lambda props: props["license_whitelist"].__setitem__(
+                "items", {"type": "integer"}
+            ),
+            "license_whitelist[]: type",
+        )
+        complained_of(
+            lambda props: props["agents"]["properties"]["alpha"]["properties"][
+                "backend"
+            ].__setitem__("items", {"type": "integer"}),
+            "agents.alpha.backend[]: type",
+        )
+        complained_of(
+            lambda props: props["license_whitelist"].pop("items"),
+            "license_whitelist[]: items schema missing",
+        )
+
+        # `additionalProperties` drift (mcp_servers) and a dropped subschema.
+        complained_of(
+            lambda props: props["mcp_servers"].__setitem__(
+                "additionalProperties", {"type": "string"}
+            ),
+            "mcp_servers.*: type",
+        )
+        complained_of(
+            lambda props: props["mcp_servers"].pop("additionalProperties"),
+            "mcp_servers.*: additionalProperties schema missing",
+        )
+
+        # `default` drift: top-level (mode) and nested
+        # (verify.min_fuzzy_confidence); then a dropped `default`.
+        complained_of(
+            lambda props: props["mode"].__setitem__("default", "scout"),
+            "mode: default",
+        )
+        complained_of(
+            lambda props: props["verify"]["properties"][
+                "min_fuzzy_confidence"
+            ].__setitem__("default", 0.5),
+            "verify.min_fuzzy_confidence: default",
+        )
+        complained_of(
+            lambda props: props["mode"].pop("default"),
+            "mode: default",
+        )
+
     def test_valid_update_map_covers_every_canonical_key(self):
         self.assertEqual(set(VALID_UPDATES), set(CONFIG["properties"]))
         self.assertEqual(set(INVALID_UPDATES), set(CONFIG["properties"]))

package/runner/tests/test_hardening_contract.py

@@ -0,0 +1,391 @@
+#!/usr/bin/env python3
+"""Phase 05 (hardening-contract, H2-H6) acceptance tests: C1-C5.
+
+Each class maps to one acceptance criterion in
+`.roadmap/05-hardening-contract/GOAL.md`. Default-absent behavior is pinned
+byte-identical throughout (absent keys, None guards, and clean configs behave
+exactly as before).
+"""
+
+import hashlib
+import json
+import os
+import subprocess
+import tempfile
+import unittest
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
+
+
+def _write_config(base: Path, payload: dict) -> Path:
+    base.mkdir(parents=True, exist_ok=True)
+    cfg_file = base / "config.json"
+    cfg_file.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+    return cfg_file
+
+
+def _handle_config(args):
+    from runner.mcp_server import _handle_config as h
+
+    return json.loads(h(args))
+
+
+class TestC1ExpectedHashNormalization(unittest.TestCase):
+    """H2: normalized conflict comparison, 8-hex minimum, show+hash decision."""
+
+    def test_case_and_whitespace_only_difference_is_one_guard(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            _write_config(base, {"mode": "research"})
+            live = hashlib.sha256((base / "config.json").read_bytes()).hexdigest()
+            payload = _handle_config(
+                {
+                    "mode": "audit",
+                    "base_dir": str(base),
+                    "expected_hash": "  " + live.upper() + "  ",
+                    "expectedHash": live,
+                }
+            )
+            self.assertEqual(payload["status"], "updated", payload)
+            self.assertTrue(payload["written_to"])
+
+    def test_genuinely_different_spellings_still_conflict(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            cfg_file = _write_config(base, {"mode": "research"})
+            before = cfg_file.read_bytes()
+            payload = _handle_config(
+                {
+                    "mode": "audit",
+                    "base_dir": str(base),
+                    "expected_hash": "a" * 64,
+                    "expectedHash": "b" * 64,
+                }
+            )
+            self.assertEqual(payload["code"], "CONFLICTING_EXPECTED_HASH")
+            self.assertFalse(payload["written"])
+            self.assertEqual(cfg_file.read_bytes(), before)
+
+    def test_malformed_but_equal_spellings_surface_hash_error(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            cfg_file = _write_config(base, {"mode": "research"})
+            before = cfg_file.read_bytes()
+            payload = _handle_config(
+                {
+                    "mode": "audit",
+                    "base_dir": str(base),
+                    "expected_hash": "zzzzzzzz",
+                    "expectedHash": "ZZZZZZZZ",
+                }
+            )
+            self.assertEqual(payload["code"], "CONFIG_INVALID_EXPECTED_HASH")
+            self.assertFalse(payload["written"])
+            self.assertEqual(cfg_file.read_bytes(), before)
+
+    def test_short_guard_rejected_through_mcp(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            _write_config(base, {"mode": "research"})
+            payload = _handle_config(
+                {"mode": "audit", "base_dir": str(base), "expected_hash": "abcd"}
+            )
+            self.assertEqual(payload["code"], "CONFIG_INVALID_EXPECTED_HASH")
+            self.assertFalse(payload["written"])
+
+    def test_show_wins_over_updates_and_ignores_the_guard(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            cfg_file = _write_config(base, {"mode": "research"})
+            before = cfg_file.read_bytes()
+            payload = _handle_config(
+                {
+                    "show": True,
+                    "mode": "audit",
+                    "base_dir": str(base),
+                    "expected_hash": "deadbeef00",  # bogus: must NOT go stale
+                }
+            )
+            self.assertEqual(payload["status"], "current", payload)
+            self.assertEqual(payload["config"]["mode"], "research")
+            self.assertEqual(payload["ignored_updates"], ["mode"])
+            self.assertEqual(cfg_file.read_bytes(), before)
+
+    def test_show_without_updates_is_unchanged(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            _write_config(base, {"mode": "research"})
+            payload = _handle_config({"show": True, "base_dir": str(base)})
+            self.assertEqual(payload["status"], "current")
+            self.assertNotIn("ignored_updates", payload)
+
+    def test_js_resolve_expected_hash_normalizes(self):
+        """config-io.js mirrors the normalized conflict rule (Phase-05 H2)."""
+        res = subprocess.run(
+            [
+                "node",
+                "--input-type=module",
+                "-e",
+                """
+                import { resolveExpectedHash } from "./plugins/opencode/config-io.js";
+                const out = [];
+                out.push(resolveExpectedHash({ expected_hash: "ABCDEF12", expectedHash: "abcdef12" }));
+                let conflict = null;
+                try {
+                  resolveExpectedHash({ expected_hash: "a".repeat(8), expectedHash: "b".repeat(8) });
+                } catch (e) { conflict = e.code; }
+                let malformed = null;
+                try {
+                  resolveExpectedHash({ expected_hash: "zzzzzzzz", expectedHash: "ZZZZZZZZ" });
+                } catch (e) { malformed = e.code; }
+                console.log(JSON.stringify({ same: out[0], conflict, malformed }));
+                """,
+            ],
+            capture_output=True,
+            text=True,
+            cwd=str(PROJECT_ROOT),
+        )
+        self.assertEqual(res.returncode, 0, res.stderr)
+        data = json.loads(res.stdout.strip().splitlines()[-1])
+        self.assertEqual(data["same"], "abcdef12")
+        self.assertEqual(data["conflict"], "CONFLICTING_EXPECTED_HASH")
+        self.assertEqual(data["malformed"], "CONFIG_INVALID_EXPECTED_HASH")
+
+
+class TestC2HostAndPackValidation(unittest.TestCase):
+    """H3: searxng host presence + domain_pack trim/reject."""
+
+    def test_scheme_without_host_rejected(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            cfg_file = _write_config(base, {"mode": "research"})
+            before = cfg_file.read_bytes()
+            for bad in ("http://", "https://", "https:///path-only", "http:// "):
+                with self.subTest(bad=bad):
+                    payload = _handle_config(
+                        {"searxng_url": bad, "base_dir": str(base)}
+                    )
+                    self.assertEqual(payload["code"], "CONFIG_VALIDATION_FAILED")
+                    self.assertFalse(payload["written"])
+                    self.assertEqual(cfg_file.read_bytes(), before)
+
+    def test_host_with_port_and_path_accepted(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            payload = _handle_config(
+                {
+                    "searxng_url": "https://searx.local:8888/search",
+                    "base_dir": str(base),
+                }
+            )
+            self.assertEqual(payload["status"], "updated", payload)
+
+    def test_null_searxng_url_still_means_untouched(self):
+        """Default-absent pin: explicit null clears, absent leaves unchanged."""
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            payload = _handle_config({"searxng_url": None, "base_dir": str(base)})
+            self.assertEqual(payload["status"], "updated", payload)
+            self.assertIsNone(payload["config"]["searxng_url"])
+
+    def test_blank_and_padded_pack_rejected_at_config_surface(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            cfg_file = _write_config(base, {"mode": "research"})
+            before = cfg_file.read_bytes()
+            for bad in ("", "   ", " biopharma", "biopharma ", " biopharma "):
+                with self.subTest(bad=bad):
+                    payload = _handle_config(
+                        {"domain_pack": bad, "base_dir": str(base)}
+                    )
+                    self.assertEqual(
+                        payload["code"], "CONFIG_VALIDATION_FAILED", payload
+                    )
+                    self.assertFalse(payload["written"])
+                    self.assertEqual(cfg_file.read_bytes(), before)
+
+    def test_set_domain_pack_strips_and_activates(self):
+        from runner.mcp_server import _handle_set_domain_pack
+
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            payload = json.loads(
+                _handle_set_domain_pack(
+                    {"pack": "  biopharma  ", "base_dir": str(base)}
+                )
+            )
+            self.assertEqual(payload["status"], "activated")
+            self.assertEqual(payload["domain_pack"], "biopharma")
+            data = json.loads((base / "config.json").read_text(encoding="utf-8"))
+            self.assertEqual(data["domain_pack"], "biopharma")
+
+    def test_set_domain_pack_rejects_blank(self):
+        from runner.mcp_server import _handle_set_domain_pack
+
+        with tempfile.TemporaryDirectory() as tmp:
+            with self.assertRaises(ValueError):
+                _handle_set_domain_pack({"pack": "   ", "base_dir": str(tmp)})
+
+    def test_load_domain_pack_strips(self):
+        from runner.refinement import load_domain_pack
+
+        self.assertEqual(
+            load_domain_pack("  biopharma  ").accept_threshold,
+            load_domain_pack("biopharma").accept_threshold,
+        )
+
+
+class TestC3NullCodeUnification(unittest.TestCase):
+    """H4: any caller-supplied null where null is banned -> one code."""
+
+    def test_nested_null_reports_null_code_with_path(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            cfg_file = _write_config(base, {"mode": "research"})
+            before = cfg_file.read_bytes()
+            payload = _handle_config(
+                {
+                    "verify": {"min_fuzzy_confidence": None},
+                    "base_dir": str(base),
+                }
+            )
+            self.assertEqual(payload["code"], "NULL_FOR_NON_NULLABLE_KEY")
+            self.assertFalse(payload["written"])
+            self.assertTrue(
+                any("verify.min_fuzzy_confidence" in e for e in payload["errors"]),
+                payload,
+            )
+            self.assertEqual(cfg_file.read_bytes(), before)
+
+    def test_top_level_null_still_reports_null_code(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            payload = _handle_config({"mode": None, "base_dir": str(base)})
+            self.assertEqual(payload["code"], "NULL_FOR_NON_NULLABLE_KEY")
+            self.assertFalse(payload["written"])
+
+    def test_nullable_nested_null_still_clears(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            payload = _handle_config(
+                {"agents": {"alpha": {"backend": None}}, "base_dir": str(base)}
+            )
+            self.assertEqual(payload["status"], "updated", payload)
+
+    def test_map_value_null_reports_null_code_with_path(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            payload = _handle_config(
+                {"mcp_servers": {"searxng": None}, "base_dir": str(base)}
+            )
+            self.assertEqual(payload["code"], "NULL_FOR_NON_NULLABLE_KEY")
+            self.assertTrue(
+                any("mcp_servers.searxng" in e for e in payload["errors"]), payload
+            )
+
+    def test_non_null_violation_keeps_validation_code(self):
+        """The null code must not swallow ordinary schema violations."""
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            payload = _handle_config(
+                {"verify": {"min_fuzzy_confidence": 2.0}, "base_dir": str(base)}
+            )
+            self.assertEqual(payload["code"], "CONFIG_VALIDATION_FAILED")
+
+
+class TestC4SingleCoercionContract(unittest.TestCase):
+    """H5: hasher owns coercion; MCP forwards raw and echoes effective."""
+
+    def test_coerce_helper_is_the_single_rule(self):
+        from skills.research_cache.hasher import coerce_min_fuzzy_confidence
+
+        self.assertEqual(coerce_min_fuzzy_confidence("0.95"), 0.95)
+        self.assertEqual(coerce_min_fuzzy_confidence(0.95), 0.95)
+        self.assertEqual(coerce_min_fuzzy_confidence("high"), 0.88)
+        self.assertEqual(coerce_min_fuzzy_confidence(None), 0.88)
+        self.assertEqual(coerce_min_fuzzy_confidence(1.5), 1.0)
+        self.assertEqual(coerce_min_fuzzy_confidence(-5), 0.0)
+
+    def test_string_config_forwards_to_hasher_and_echoes_effective(self):
+        from runner.mcp_server import _handle_verify_quote
+        from skills.research_cache.hasher import SourceHasher
+
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            hasher = SourceHasher(base)
+            words = [f"w{i}" for i in range(1, 21)]
+            digest = hasher.store_source(
+                url="https://example.test/s", content=" ".join(words)
+            )
+            quote = " ".join(words[:9]) + " nomatch"
+            # Hand-edited string threshold (schema-strict saves can never
+            # produce this; the coercion contract covers it anyway).
+            _write_config(base, {"verify": {"min_fuzzy_confidence": "0.95"}})
+            payload = json.loads(
+                _handle_verify_quote(
+                    {"hash": digest, "quote": quote, "base_dir": str(base)}
+                )
+            )
+            expected = hasher.verify_quote(digest, quote, min_fuzzy_confidence="0.95")
+            self.assertEqual(payload["verified"], expected[0])
+            self.assertEqual(payload["min_fuzzy_confidence"], 0.95)
+
+    def test_malformed_config_falls_back_and_echoes_default(self):
+        from runner.mcp_server import _handle_verify_quote
+        from skills.research_cache.hasher import SourceHasher
+
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            hasher = SourceHasher(base)
+            digest = hasher.store_source(
+                url="https://example.test/m", content="exact words here today"
+            )
+            _write_config(base, {"verify": {"min_fuzzy_confidence": "high"}})
+            payload = json.loads(
+                _handle_verify_quote(
+                    {
+                        "hash": digest,
+                        "quote": "exact words here today",
+                        "base_dir": str(base),
+                    }
+                )
+            )
+            self.assertTrue(payload["verified"])
+            self.assertEqual(payload["min_fuzzy_confidence"], 0.88)
+
+
+class TestC5WrittenToAbsolute(unittest.TestCase):
+    """H6: absolute `written_to` on both updated legs."""
+
+    def test_write_leg_reports_absolute_written_to(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            payload = _handle_config({"mode": "audit", "base_dir": str(base)})
+            self.assertEqual(payload["status"], "updated")
+            self.assertTrue(os.path.isabs(payload["written_to"]), payload)
+            self.assertTrue(Path(payload["written_to"]).is_file())
+            self.assertEqual(
+                payload["hash"],
+                hashlib.sha256(Path(payload["written_to"]).read_bytes()).hexdigest(),
+            )
+
+    def test_defensive_leg_reports_absolute_written_to(self):
+        from runner.mcp_server import _config_updated_payload
+        from skills.swarm_config.configure import DEFAULT_CONFIG
+
+        with tempfile.TemporaryDirectory() as tmp:
+            missing = Path(tmp) / "no-such-dir" / "config.json"
+            payload = _config_updated_payload(
+                missing, {"mode": "audit"}, DEFAULT_CONFIG
+            )
+            self.assertEqual(payload["status"], "updated")
+            self.assertIsNone(payload["hash"])
+            self.assertTrue(os.path.isabs(payload["written_to"]), payload)
+            self.assertEqual(
+                payload["written_to"], str(Path(os.path.realpath(missing)))
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()