@heretek-ai/epistemic-swarm 0.6.0 → 0.7.2

package/runner/tests/test_backends.py

@@ -0,0 +1,280 @@
+#!/usr/bin/env python3
+"""Tests for host-native agent backends (parity spec section 8).
+
+Claude Code spawns `claude -p`; OpenCode spawns `opencode run`. Default
+follows the host; explicit flags/env/config always win.
+"""
+
+import json
+import os
+import subprocess
+import sys
+import unittest
+from pathlib import Path
+from unittest import mock
+
+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.research_swarm import (  # noqa: E402
+    _backend_family,
+    _build_opencode_cmd,
+    _default_backend_cmd,
+    _extract_opencode_text,
+    SwarmRunner,
+)
+
+
+class TestBackendDefaults(unittest.TestCase):
+    def test_explicit_config_host_wins(self):
+        self.assertEqual(_default_backend_cmd("opencode"), ["opencode", "run"])
+        self.assertEqual(_default_backend_cmd("claude"), ["claude", "-p"])
+
+    def test_env_host_hint(self):
+        with mock.patch.dict(os.environ, {"IUMBTEMS_HOST": "opencode"}):
+            self.assertEqual(_default_backend_cmd(None), ["opencode", "run"])
+        with mock.patch.dict(os.environ, {"IUMBTEMS_HOST": "claude"}):
+            self.assertEqual(_default_backend_cmd(None), ["claude", "-p"])
+
+    def test_legacy_default_when_nothing_selects_opencode(self):
+        with mock.patch.dict(os.environ, {}, clear=True):
+            with mock.patch("shutil.which", return_value=None):
+                self.assertEqual(_default_backend_cmd(None), ["claude", "-p"])
+
+    def test_probe_falls_back_to_opencode_when_claude_absent(self):
+        with mock.patch.dict(os.environ, {}, clear=True):
+
+            def which(name):
+                return "/usr/bin/opencode" if name == "opencode" else None
+
+            with mock.patch("shutil.which", side_effect=which):
+                self.assertEqual(_default_backend_cmd(None), ["opencode", "run"])
+
+
+class TestOpencodeArgv(unittest.TestCase):
+    def test_shape_has_no_claude_flags(self):
+        cmd = _build_opencode_cmd(
+            ["opencode", "run"], "do research", "anthropic/claude-x", "alpha-thesis"
+        )
+        self.assertEqual(cmd[0:2], ["opencode", "run"])
+        self.assertIn("do research", cmd)
+        self.assertIn("--agent", cmd)
+        self.assertIn("alpha-thesis", cmd)
+        self.assertIn("-m", cmd)
+        self.assertIn("anthropic/claude-x", cmd)
+        self.assertIn("--format", cmd)
+        self.assertIn("json", cmd)
+        self.assertNotIn("--tools", cmd)
+        self.assertNotIn("--system-prompt", cmd)
+        self.assertFalse(any(a.startswith("--model") for a in cmd))
+
+    def test_minimal_shape(self):
+        self.assertEqual(
+            _build_opencode_cmd(["opencode", "run"], "p", None, None),
+            ["opencode", "run", "p", "--format", "json"],
+        )
+
+    def test_family_detection(self):
+        self.assertEqual(_backend_family(["opencode", "run"]), "opencode")
+        self.assertEqual(_backend_family(["claude", "-p"]), "claude")
+        self.assertEqual(_backend_family(["/usr/bin/opencode", "run"]), "opencode")
+
+
+class TestRunnerBackendWiring(unittest.TestCase):
+    def _runner(self, **kw):
+        import tempfile
+
+        tmp = tempfile.mkdtemp()
+        return SwarmRunner(
+            base_dir=Path(tmp), mock_mode=True, mode=kw.pop("mode", "research"), **kw
+        )
+
+    def test_claude_shape_preserved_by_default(self):
+        with mock.patch.dict(os.environ, {}, clear=True):
+            with mock.patch("shutil.which", return_value=None):
+                r = self._runner()
+                cmd = r.build_agent_cmd("obj")
+                self.assertEqual(cmd[:3], ["claude", "-p", "obj"])
+                self.assertIn("--tools", cmd)
+
+    def test_opencode_shape_via_host_env(self):
+        with mock.patch.dict(os.environ, {"IUMBTEMS_HOST": "opencode"}):
+            r = self._runner(mode="scout")
+            cmd = r.build_agent_cmd("obj")
+            self.assertEqual(cmd[:2], ["opencode", "run"])
+            self.assertIn("oss-scout", cmd)
+
+    def test_research_beta_maps_to_beta_redteam(self):
+        with mock.patch.dict(os.environ, {"IUMBTEMS_HOST": "opencode"}):
+            r = self._runner(mode="research")
+            self.assertIn("beta-redteam", r.build_agent_cmd("obj", role="beta"))
+            self.assertIn("alpha-thesis", r.build_agent_cmd("obj", role="alpha"))
+
+    def test_explicit_override_beats_host_env(self):
+        with mock.patch.dict(os.environ, {"IUMBTEMS_HOST": "opencode"}):
+            r = self._runner(agent_overrides={"alpha": {"backend": ["claude", "-p"]}})
+            cmd = r.build_agent_cmd("obj", role="alpha")
+            self.assertEqual(cmd[:2], ["claude", "-p"])
+
+
+class TestOpencodeOutputParsing(unittest.TestCase):
+    def test_extracts_text_events(self):
+        raw = "\n".join(
+            [
+                '{"type":"session","id":"s1"}',
+                '{"type":"message","text":"first finding"}',
+                '{"type":"message","text":"second finding"}',
+                '{"type":"tool_call","tool":"read"}',
+            ]
+        )
+        self.assertEqual(_extract_opencode_text(raw), "first finding\nsecond finding")
+
+    def test_falls_back_to_raw(self):
+        self.assertEqual(_extract_opencode_text("plain text out"), "plain text out")
+        self.assertEqual(_extract_opencode_text(""), "")
+
+    def test_ignores_malformed_lines(self):
+        raw = '{not json\n{"type":"result","result":"verdict: clean-room"}'
+        self.assertEqual(_extract_opencode_text(raw), "verdict: clean-room")
+
+
+class TestDossierStdoutFallback(unittest.TestCase):
+    def _runner(self):
+        import tempfile
+        from runner.research_swarm import SwarmRunner
+
+        tmp = tempfile.mkdtemp()
+        r = SwarmRunner(base_dir=Path(tmp), mock_mode=False, mode="research")
+        r.state_machine.init_session("fallback probe")
+        r.state_machine.set_scopes(
+            [
+                {
+                    "scope_id": "scope_01_probe",
+                    "title": "Probe",
+                    "objective": "probe objective",
+                    "dependencies": [],
+                    "affirmative_targets": [],
+                    "adversarial_targets": [],
+                }
+            ]
+        )
+        return r
+
+    def test_recovers_dossier_from_stdout(self):
+        from runner.research_swarm import SwarmRunner
+
+        r = self._runner()
+        payload = json.dumps(
+            {
+                "agent": "Agent Alpha (Thesis)",
+                "scope_id": "scope_01_probe",
+                "affirmative_claims": [],
+            }
+        )
+        transcript = "Some chatter\n```json\n" + payload + "\n```\nDone."
+        with mock.patch.object(
+            SwarmRunner, "run_claude_process", return_value=transcript
+        ):
+            scope = {
+                "scope_id": "scope_01_probe",
+                "title": "Probe",
+                "objective": "probe objective",
+                "dependencies": [],
+                "affirmative_targets": [],
+                "adversarial_targets": [],
+            }
+            r.run_agent_alpha(scope)
+        dossier_path = (
+            r.state_machine.get_scope_dir("scope_01_probe") / "alpha_dossier.json"
+        )
+        self.assertTrue(dossier_path.is_file())
+        saved = json.loads(dossier_path.read_text())
+        self.assertTrue(saved.get("recovered_from_stdout"))
+
+    def test_raises_when_no_file_and_no_json(self):
+        from runner.research_swarm import SwarmRunner
+
+        r = self._runner()
+        with mock.patch.object(
+            SwarmRunner, "run_claude_process", return_value="just some prose, no json"
+        ):
+            scope = {
+                "scope_id": "scope_01_probe",
+                "title": "Probe",
+                "objective": "probe objective",
+                "dependencies": [],
+                "affirmative_targets": [],
+                "adversarial_targets": [],
+            }
+            with self.assertRaises(FileNotFoundError):
+                r.run_agent_beta(scope)
+
+
+class TestProjectDirResolution(unittest.TestCase):
+    def test_explicit_base_dir_wins(self):
+        from runner.mcp_server import _resolve_base_dir
+
+        with mock.patch.dict(os.environ, {"IUMBTEMS_PROJECT_DIR": "/tmp"}):
+            p = _resolve_base_dir({"base_dir": "/tmp/custom"})
+            self.assertEqual(p, Path("/tmp/custom"))
+
+    def test_project_dir_preferred_over_cwd(self):
+        import tempfile
+        from runner.mcp_server import _resolve_base_dir
+
+        project = tempfile.mkdtemp()
+        with mock.patch.dict(os.environ, {"IUMBTEMS_PROJECT_DIR": project}):
+            p = _resolve_base_dir({})
+            self.assertEqual(
+                p, Path(os.path.realpath(os.path.join(project, ".research")))
+            )
+
+    def test_missing_project_dir_falls_back_to_cwd(self):
+        from runner.mcp_server import _resolve_base_dir
+
+        with mock.patch.dict(os.environ, {"IUMBTEMS_PROJECT_DIR": "/no/such/dir"}):
+            p = _resolve_base_dir({})
+            self.assertEqual(p, Path(os.path.realpath(".research")))
+
+
+def run_node(code):
+    return subprocess.run(
+        ["node", "--input-type=module", "-e", code],
+        capture_output=True,
+        text=True,
+        cwd=str(PROJECT_ROOT),
+    )
+
+
+def last_json_object(stdout):
+    lines = [l.strip() for l in stdout.strip().split("\n") if l.strip().startswith("{")]
+    return json.loads(lines[-1])
+
+
+class TestOpencodePluginBackend(unittest.TestCase):
+    def test_backend_input_mirrored_on_swarm_tools(self):
+        res = run_node(
+            """
+            import plugin from "./plugins/opencode/index.js";
+            const toolMap = {};
+            const host = {
+              options: {},
+              command: {list: async () => ({data: []}), transform: async () => ({dispose: () => {}}), reload: async () => {}},
+              tool: {transform: async (fn) => { fn({add: (t) => { toolMap[t.name] = t; }}); return {dispose: () => {}}; }, reload: async () => {}},
+              session: {prompt: async () => ({})}
+            };
+            await plugin.setup(host);
+            const names = ["iumbtems_swarm_research","iumbtems_code_audit","iumbtems_oss_scout","iumbtems_brainstorm","iumbtems_darkharvest"];
+            console.log(JSON.stringify(Object.fromEntries(names.map(n => [n, toolMap[n]?.input?.properties?.backend?.enum || null]))));
+            """
+        )
+        self.assertEqual(res.returncode, 0, res.stderr)
+        data = last_json_object(res.stdout)
+        self.assertEqual(len(data), 5)
+        for name, enum in data.items():
+            self.assertEqual(enum, ["auto", "claude", "opencode"], name)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/runner/tests/test_claude_plugin.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""Tests for Claude Code plugin surfaces: manifests, agents, modular sync, evals.
+
+Per https://code.claude.com/docs/en/plugins/create (manifest + layout),
+/components (skills/agents/hooks/MCP), and /plugin-evals (suite layout).
+Behavioral eval runs are billable and stay in CI (plugin-evals.yml); here we
+assert suite structure only.
+"""
+
+import json
+import unittest
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
+if str(PROJECT_ROOT) not in __import__("sys").path:
+    __import__("sys").path.insert(0, str(PROJECT_ROOT))
+
+MODULAR = {
+    "socratic-grilling": "grilling",
+    "research-cache": "research_cache",
+    "darkharvest": "darkharvest",
+    "factory": "factory",
+}
+
+
+def parse_frontmatter(path):
+    text = Path(path).read_text(encoding="utf-8")
+    if not text.startswith("---"):
+        return {}
+    end = text.find("---", 3)
+    if end < 0:
+        return {}
+    data = {}
+    for line in text[3:end].strip().splitlines():
+        if ":" in line:
+            k, v = line.split(":", 1)
+            data[k.strip()] = v.strip()
+    return data
+
+
+class TestClaudeManifests(unittest.TestCase):
+    def test_root_manifest_lists_all_nine_skills(self):
+        manifest = json.loads(
+            (PROJECT_ROOT / ".claude-plugin" / "plugin.json").read_text()
+        )
+        self.assertEqual(manifest["name"], "epistemic-swarm")
+        for skill in (
+            "grilling",
+            "research_cache",
+            "epistemic_search",
+            "swarm_config",
+            "code_audit",
+            "oss_scout",
+            "brainstorming",
+            "darkharvest",
+            "factory",
+        ):
+            self.assertIn(f"./skills/{skill}", manifest["skills"])
+
+    def test_marketplace_entries_resolve(self):
+        marketplace = json.loads(
+            (PROJECT_ROOT / ".claude-plugin" / "marketplace.json").read_text()
+        )
+        names = [p["name"] for p in marketplace["plugins"]]
+        for name in (
+            "epistemic-swarm",
+            "socratic-grilling",
+            "research-cache",
+            "darkharvest",
+            "factory",
+        ):
+            self.assertIn(name, names)
+        for plugin in marketplace["plugins"]:
+            if plugin["name"] == "epistemic-swarm":
+                continue
+            plugin_json = (
+                PROJECT_ROOT
+                / plugin["source"].lstrip("./")
+                / ".claude-plugin"
+                / "plugin.json"
+            )
+            self.assertTrue(plugin_json.is_file(), f"missing {plugin_json}")
+            data = json.loads(plugin_json.read_text())
+            self.assertEqual(data["name"], plugin["name"])
+
+    def test_modular_skills_in_sync(self):
+        for mod, skill in MODULAR.items():
+            src = PROJECT_ROOT / "skills" / skill
+            dst = PROJECT_ROOT / "plugins" / mod / "skills" / skill
+            self.assertTrue((dst / "SKILL.md").is_file(), f"missing {dst}")
+            src_files = {
+                p.relative_to(src)
+                for p in src.rglob("*")
+                if p.is_file() and "__pycache__" not in p.parts
+            }
+            dst_files = {
+                p.relative_to(dst)
+                for p in dst.rglob("*")
+                if p.is_file() and "__pycache__" not in p.parts
+            }
+            self.assertEqual(src_files, dst_files, f"drift in {mod}")
+            for rel in src_files:
+                self.assertEqual(
+                    (src / rel).read_bytes(),
+                    (dst / rel).read_bytes(),
+                    f"content drift: {mod}/{rel}",
+                )
+
+
+class TestClaudeAgents(unittest.TestCase):
+    AGENTS = {
+        "agents/alpha-thesis.md": "alpha-thesis",
+        "agents/beta-antithesis.md": "beta-antithesis",
+        "agents/epistemic-auditor.md": "epistemic-auditor",
+        "plugins/darkharvest/agents/harvest-proponent.md": "harvest-proponent",
+        "plugins/darkharvest/agents/harvest-redteam.md": "harvest-redteam",
+        "plugins/factory/agents/factory-manager.md": "factory-manager",
+        "plugins/factory/agents/programmer.md": "programmer",
+        "plugins/factory/agents/qa-functional.md": "qa-functional",
+        "plugins/factory/agents/qa-adversarial.md": "qa-adversarial",
+    }
+
+    def test_agent_frontmatter(self):
+        for rel, expected_name in self.AGENTS.items():
+            fm = parse_frontmatter(PROJECT_ROOT / rel)
+            self.assertEqual(fm.get("name"), expected_name, rel)
+            self.assertTrue(fm.get("description"), f"no description: {rel}")
+            self.assertIn("model", fm, f"no model: {rel}")
+            for banned in ("permissionMode", "hooks", "mcpServers", "initialPrompt"):
+                self.assertNotIn(banned, fm, f"banned field in {rel}")
+
+
+class TestClaudeEvals(unittest.TestCase):
+    CASES = {
+        "evals/grill-fires": "grilling",
+        "evals/darkharvest-fires": "darkharvest",
+        "evals/factory-gate": "factory",
+        "plugins/darkharvest/evals/teardown-verdict": "darkharvest",
+        "plugins/factory/evals/gate-halt": "factory",
+    }
+
+    def test_eval_suite_structure(self):
+        for case, skill in self.CASES.items():
+            prompt = PROJECT_ROOT / case / "prompt.md"
+            self.assertTrue(prompt.is_file(), f"missing {prompt}")
+            body = prompt.read_text(encoding="utf-8")
+            self.assertIn("allowed_tools", body)
+            graders = sorted((PROJECT_ROOT / case / "graders").glob("*.md"))
+            self.assertTrue(graders, f"no graders in {case}")
+            kinds = set()
+            for g in graders:
+                fm = parse_frontmatter(g)
+                self.assertIn(
+                    fm.get("type"),
+                    (
+                        "tool_used",
+                        "llm",
+                        "regex",
+                        "tool_order",
+                        "file_exists",
+                        "baseline",
+                    ),
+                    f"bad type in {g}",
+                )
+                kinds.add(fm.get("type"))
+            self.assertIn("tool_used", kinds, f"no Skill-fired grader in {case}")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/runner/tests/test_sweep_regressions.py

@@ -64,11 +64,9 @@ class TestBuildAdaptersImportable(unittest.TestCase):
         # Python 3.14 (PEP 649) defers annotation evaluation, so the NameError
         # only surfaces when something actually resolves the annotations. We
         # force that resolution with get_type_hints() so the test reproduces
-        # the CI failure on every interpreter.
-        try:
-            module = _load_module("scripts/build_adapters.py", "iumbtems_build_adapters")
-        except NameError as e:
-            self.fail(f"scripts/build_adapters.py fails to import on eager-annotation Python: {e}")
+        # the CI failure on every interpreter. An import-time NameError
+        # propagates uncaught (red test) — no wrapper, per S8714.
+        module = _load_module("scripts/build_adapters.py", "iumbtems_build_adapters")
 
         unresolved = []
         for attr_name, attr in list(vars(module).items()):
@@ -86,19 +84,26 @@ class TestBuildAdaptersImportable(unittest.TestCase):
                 # an annotation defect.
                 continue
         self.assertEqual(
-            unresolved, [],
+            unresolved,
+            [],
             "annotations reference undefined names (this is the Python 3.11 "
             f"import-time NameError): {unresolved}",
         )
 
     def test_check_mode_exits_zero(self):
         res = subprocess.run(
-            [sys.executable, str(PROJECT_ROOT / "scripts" / "build_adapters.py"), "--check"],
+            [
+                sys.executable,
+                str(PROJECT_ROOT / "scripts" / "build_adapters.py"),
+                "--check",
+            ],
             capture_output=True,
             text=True,
             cwd=str(PROJECT_ROOT),
         )
-        self.assertEqual(res.returncode, 0, f"--check failed:\n{res.stdout}\n{res.stderr}")
+        self.assertEqual(
+            res.returncode, 0, f"--check failed:\n{res.stdout}\n{res.stderr}"
+        )
 
 
 class TestSearchParserRegression(unittest.TestCase):
@@ -124,7 +129,7 @@ class TestSearchParserRegression(unittest.TestCase):
         and zip(links, snippets) produced nothing.
         """
         html = (
-            '<table><tr>'
+            "<table><tr>"
             '<td><a class="result-link" href="https://a.example/x">Title</a></td>'
             '<td class="result-snippet">See '
             '<a href="/l/?uddg=https%3A%2F%2Fy.example" class="result-link">this</a> page'
@@ -167,17 +172,17 @@ class TestSearchParserRegression(unittest.TestCase):
         A bare `&` from `&amp;` (or from a URL query string) makes the
         <search_results> document malformed.
         """
-        xml_text = self.search.format_xml([
-            {
-                "title": "Q&A",
-                "url": "https://x.example/?a=1&b=2",
-                "snippet": "A & B and C++ <tips>",
-            }
-        ])
-        try:
-            xml.dom.minidom.parseString(xml_text)
-        except Exception as e:  # pragma: no cover - failure path
-            self.fail(f"format_xml produced malformed XML: {e}\n{xml_text}")
+        xml_text = self.search.format_xml(
+            [
+                {
+                    "title": "Q&A",
+                    "url": "https://x.example/?a=1&b=2",
+                    "snippet": "A & B and C++ <tips>",
+                }
+            ]
+        )
+        # Malformed output raises here (red test) — no wrapper, per S8714.
+        xml.dom.minidom.parseString(xml_text)
         self.assertIn("&amp;", xml_text)
         self.assertIn("&lt;tips&gt;", xml_text)
 
@@ -192,11 +197,15 @@ class TestSearchParserRegression(unittest.TestCase):
         results = self._parse(html)
         self.assertEqual(results[0]["title"], "Q&A")
         self.assertEqual(results[0]["snippet"], "A & B")
-        xml_text = self.search.format_xml([{
-            "title": results[0]["title"],
-            "url": "https://a.example/x",
-            "snippet": results[0]["snippet"],
-        }])
+        xml_text = self.search.format_xml(
+            [
+                {
+                    "title": results[0]["title"],
+                    "url": "https://a.example/x",
+                    "snippet": results[0]["snippet"],
+                }
+            ]
+        )
         xml.dom.minidom.parseString(xml_text)  # raises if malformed
         self.assertIn("<title>Q&amp;A</title>", xml_text)
         self.assertIn("<snippet>A &amp; B</snippet>", xml_text)
@@ -222,7 +231,9 @@ class TestDivergenceAggregation(unittest.TestCase):
     def test_single_scope_is_unchanged(self):
         with tempfile.TemporaryDirectory() as tmp:
             base = Path(tmp)
-            self._write_audits(base, {"scope_a": {"divergence_score": 0.5, "verified_passed": True}})
+            self._write_audits(
+                base, {"scope_a": {"divergence_score": 0.5, "verified_passed": True}}
+            )
             score, verified = self.div._extract_audit_divergence(base)
         self.assertAlmostEqual(score, 0.5)
         self.assertTrue(verified)
@@ -231,11 +242,14 @@ class TestDivergenceAggregation(unittest.TestCase):
         """The rule is the mean — independent of scope-name sort order."""
         with tempfile.TemporaryDirectory() as tmp:
             base = Path(tmp)
-            self._write_audits(base, {
-                "aaa_first": {"divergence_score": 0.0, "verified_passed": True},
-                "mmm_mid": {"divergence_score": 0.5, "verified_passed": True},
-                "zzz_last": {"divergence_score": 1.0, "verified_passed": False},
-            })
+            self._write_audits(
+                base,
+                {
+                    "aaa_first": {"divergence_score": 0.0, "verified_passed": True},
+                    "mmm_mid": {"divergence_score": 0.5, "verified_passed": True},
+                    "zzz_last": {"divergence_score": 1.0, "verified_passed": False},
+                },
+            )
             score, verified = self.div._extract_audit_divergence(base)
         self.assertAlmostEqual(score, 0.5)
         # Not the first scope's 0.0, not the last scope's 1.0.
@@ -247,10 +261,13 @@ class TestDivergenceAggregation(unittest.TestCase):
     def test_unscored_audits_are_skipped(self):
         with tempfile.TemporaryDirectory() as tmp:
             base = Path(tmp)
-            self._write_audits(base, {
-                "aaa": {"verified_passed": True},              # no score
-                "bbb": {"divergence_score": 0.25, "verified_passed": True},
-            })
+            self._write_audits(
+                base,
+                {
+                    "aaa": {"verified_passed": True},  # no score
+                    "bbb": {"divergence_score": 0.25, "verified_passed": True},
+                },
+            )
             score, verified = self.div._extract_audit_divergence(base)
         self.assertAlmostEqual(score, 0.25)
         self.assertTrue(verified)
@@ -294,7 +311,9 @@ class TestBackendValidation(unittest.TestCase):
 
     def test_bad_backend_becomes_runtime_error_not_propagated_valueerror(self):
         """A bad backend must surface as a run failure, not abort the swarm."""
-        runner = self.swarm.SwarmRunner(mock_mode=False, base_dir=Path(tempfile.mkdtemp()))
+        runner = self.swarm.SwarmRunner(
+            mock_mode=False, base_dir=Path(tempfile.mkdtemp())
+        )
         original = runner.build_agent_cmd
         runner.build_agent_cmd = lambda *a, **k: ["definitely-not-a-real-binary-xyz"]
         try:
@@ -348,17 +367,20 @@ class TestKeyFileFailsLoudly(unittest.TestCase):
 
     def test_pcrb_resolve_key_rejects_missing_file(self):
         from runner.pcrb import _resolve_key
+
         with self.assertRaises(ValueError):
             _resolve_key(None, Path("/definitely/not/a/real/key/file"))
 
     def test_pcrb_resolve_key_rejects_directory(self):
         from runner.pcrb import _resolve_key
+
         with tempfile.TemporaryDirectory() as tmp:
             with self.assertRaises(ValueError):
                 _resolve_key(None, Path(tmp))
 
     def test_pcrb_resolve_key_reads_valid_file(self):
         from runner.pcrb import _resolve_key
+
         with tempfile.TemporaryDirectory() as tmp:
             kf = Path(tmp) / "key.txt"
             kf.write_text("secret\n", encoding="utf-8")
@@ -366,6 +388,7 @@ class TestKeyFileFailsLoudly(unittest.TestCase):
 
     def test_pcrb_resolve_key_absent_returns_none(self):
         from runner.pcrb import _resolve_key
+
         self.assertIsNone(_resolve_key(None, None))
 
 
@@ -384,7 +407,16 @@ class TestNoStaleV1PluginSurface(unittest.TestCase):
         "registerOpenCodeCommands",
         "experimental.session.compacting",
     )
-    SCAN_DIRS = (".github", "scripts", "bin", "config", "runner", "extensions", "docs", "skills")
+    SCAN_DIRS = (
+        ".github",
+        "scripts",
+        "bin",
+        "config",
+        "runner",
+        "extensions",
+        "docs",
+        "skills",
+    )
     SCAN_SUFFIXES = (".yml", ".yaml", ".js", ".ts", ".py", ".sh", ".json", ".md")
 
     def test_no_v1_surface_references(self):
@@ -410,7 +442,8 @@ class TestNoStaleV1PluginSurface(unittest.TestCase):
                     if pattern in text:
                         offenders.append(f"{path.relative_to(PROJECT_ROOT)}: {pattern}")
         self.assertEqual(
-            offenders, [],
+            offenders,
+            [],
             "references to the removed V1 opencode plugin surface "
             "(these broke CI when `server()` was dropped): " + "; ".join(offenders),
         )