@hoanghainh/komagu 1.8.0 → 2.0.1

package/operate/lsa_sarif/sarif_findings.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+"""Read LSA SARIF results back as findings.json-style entries (#289).
+
+`komagu test --from-scan` and `--export-poc` work on findings.json entries. This lets them take
+the SARIF that `komagu scan` writes instead. Both LSA exporters (assess/lsa/scripts/findings_to_sarif.py
+and operate/lsa_sarif/lsa_to_sarif.py) put finding_id, category, endpoint, attack_vector and
+consensus_score in each result's properties; older SARIF without them falls back to the rule id,
+the OWASP rule tags and the "[METHOD /path]" part of the message.
+
+Python standard library only.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any, Dict, List, Optional
+
+# OWASP API Top 10 rule tags written by findings_to_sarif.py, for SARIF whose ruleId has no category
+_TAG_CATEGORY = {
+    "owasp-api1:2023-bola": "bola",
+    "owasp-api5:2023-bfla": "bfla",
+    "owasp-api3:2023-bopla": "mass_assignment",
+}
+# Rule id prefixes written by operate/lsa_sarif/lsa_to_sarif.py (KOMAGU-<PREFIX>-CWE<n>;
+# 1.x SARIF files use KOMAINU-, still read for one major release, #312)
+_LEGACY_PREFIX_CATEGORY = {"BOLA": "bola", "BFLA": "bfla", "MASS": "mass_assignment", "INJ": "sql_injection"}
+_ENDPOINT_IN_MESSAGE = re.compile(r"\[(GET|POST|PUT|PATCH|DELETE)(?:\|[A-Z]+)*\s+(/[^\]\s]*)\]")
+
+
+def is_sarif(data: Any) -> bool:
+    return isinstance(data, dict) and isinstance(data.get("runs"), list)
+
+
+def _rule_tags(run: Dict[str, Any]) -> Dict[str, List[str]]:
+    rules = ((run.get("tool") or {}).get("driver") or {}).get("rules") or []
+    return {
+        str(r.get("id", "")): [str(t).lower() for t in ((r.get("properties") or {}).get("tags") or [])]
+        for r in rules
+        if isinstance(r, dict)
+    }
+
+
+def _category(rule_id: str, props: Dict[str, Any], tags: List[str]) -> Optional[str]:
+    if props.get("category"):
+        return str(props["category"]).lower()
+    if rule_id.startswith("lsa/"):
+        parts = rule_id.split("/")
+        if len(parts) > 1 and parts[1]:
+            return parts[1].lower()
+    m = re.match(r"(?:KOMAINU|KOMAGU)-([A-Z]+)-", rule_id)
+    if m and m.group(1) in _LEGACY_PREFIX_CATEGORY:
+        return _LEGACY_PREFIX_CATEGORY[m.group(1)]
+    for tag in tags:
+        if tag in _TAG_CATEGORY:
+            return _TAG_CATEGORY[tag]
+    return None
+
+
+def findings_from_sarif(data: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """Return one findings.json-style dict per SARIF result that names an endpoint."""
+    findings: List[Dict[str, Any]] = []
+    for run in data.get("runs") or []:
+        if not isinstance(run, dict):
+            continue
+        tags_by_rule = _rule_tags(run)
+        for result in run.get("results") or []:
+            if not isinstance(result, dict):
+                continue
+            rule_id = str(result.get("ruleId", ""))
+            props = result.get("properties") or {}
+            category = _category(rule_id, props, tags_by_rule.get(rule_id, []))
+            if category is None:
+                continue
+            message = str((result.get("message") or {}).get("text", ""))
+            endpoint = props.get("endpoint") if isinstance(props.get("endpoint"), dict) else None
+            if not endpoint:
+                m = _ENDPOINT_IN_MESSAGE.search(message)
+                endpoint = {"method": m.group(1), "path": m.group(2)} if m else None
+            attack_vector = props.get("attack_vector") if isinstance(props.get("attack_vector"), dict) else None
+            if not endpoint and not (attack_vector and attack_vector.get("path")):
+                continue
+            finding_id = props.get("finding_id") or (result.get("partialFingerprints") or {}).get("lsaFindingId") or rule_id
+            finding: Dict[str, Any] = {
+                "finding_id": str(finding_id),
+                "category": category,
+                "title": message.split(" [", 1)[0] or rule_id,
+                "status": props.get("status", "confirmed"),
+            }
+            if endpoint:
+                finding["endpoint"] = dict(endpoint)
+            if attack_vector:
+                finding["attack_vector"] = dict(attack_vector)
+            if isinstance(props.get("consensus_score"), (int, float)):
+                finding["consensus"] = {"score": props["consensus_score"]}
+            findings.append(finding)
+    return findings

package/operate/remediator/runner.py

@@ -191,10 +191,6 @@ class RemediationRunner:
             self.target_dir / "out" / "findings.json",
             self.target_dir / ".komagu-devsecops" / "sca.sarif",
             self.target_dir / ".komagu-devsecops" / "komagu-devsecops.sarif",
-            # Pre-rename output locations (#290)
-            self.target_dir / "komainu-out" / "findings.json",
-            self.target_dir / ".komainu-devsecops" / "sca.sarif",
-            self.target_dir / ".komainu-devsecops" / "komainu-devsecops.sarif",
         ]
         for candidate in candidates:
             if candidate.is_file():
@@ -236,7 +232,7 @@ class RemediationRunner:
                     rule_upper = rule_id.upper()
 
                     if (
-                        rule_upper.startswith(("CVE-", "GHSA-", "OSV-", "KOMAINU-SCA-", "DEP-"))
+                        rule_upper.startswith(("CVE-", "GHSA-", "OSV-", "KOMAGU-SCA-", "DEP-"))
                         or base_name in self.MANIFEST_FILENAMES
                         or base_name.endswith(".csproj")
                         or any(k in driver_name for k in ("trivy", "sca", "dependency", "osv", "pip-audit", "govulncheck"))

package/operate/remediator/strategies.py

@@ -139,7 +139,7 @@ class DependencyVulnerabilityRemediationStrategy(BaseRemediationStrategy):
             return True
         if any(code in cwe for code in ("CWE-1395", "CWE-1104", "CWE-937")):
             return True
-        if finding_id.startswith(("CVE-", "GHSA-", "OSV-", "KOMAINU-SCA-", "DEP-")):
+        if finding_id.startswith(("CVE-", "GHSA-", "OSV-", "KOMAGU-SCA-", "DEP-")):
             return True
         if base_name in self.MANIFEST_FILES or base_name.endswith(".csproj"):
             return True

package/operate/tests/test_ai_anchoring.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python3
+"""Finding locations anchored to Tier 1 routes / candidates, and one retry on empty replies (#319)."""
+
+from __future__ import annotations
+
+import json
+import shutil
+import tempfile
+import unittest
+from pathlib import Path
+
+from operate.ai.anchoring import AnchorReport, anchor_findings, load_anchors
+from operate.ai.runner import HeadlessAIRunner
+
+
+def _write(path: Path, data: object) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data) if not isinstance(data, str) else data, encoding="utf-8")
+
+
+class TestAnchoring(unittest.TestCase):
+    def setUp(self) -> None:
+        self.tmp = Path(tempfile.mkdtemp(prefix="komagu_anchor_"))
+        self.target, self.out = self.tmp / "repo", self.tmp / "out"
+        _write(self.target / "node-express/routes/admin.js", "\n".join(f"// line {i}" for i in range(1, 21)) + "\n")
+        _write(self.target / "python-flask/profile.py", "\n".join(f"# line {i}" for i in range(1, 31)) + "\n")
+        _write(self.out / "routes/routes-001.json", {"routes": [
+            {"route_id": "R-1", "handler": {"file": "node-express/routes/admin.js", "line": 8}},
+            {"route_id": "R-2", "handler": {"file": "node-express/routes/admin.js", "line": 12}},
+            {"route_id": "R-3", "handler": {"file": "node-express/routes/admin.js", "line": 16}}]})
+        _write(self.out / "mass-assignment.candidates.json", {"candidates": [
+            {"candidate_id": "M-14", "file": "python-flask/profile.py", "line": 10}]})
+        self.anchors = load_anchors(self.out, self.target)
+
+    def tearDown(self) -> None:
+        shutil.rmtree(self.tmp, ignore_errors=True)
+
+    def run_one(self, finding: dict) -> tuple:
+        report = AnchorReport()
+        return anchor_findings([finding], self.anchors, self.target, report)[0], report
+
+    def test_handler_spans_end_before_the_next_route(self) -> None:
+        self.assertEqual((self.anchors["R-1"].line, self.anchors["R-1"].end_line), (8, 11))
+        self.assertEqual((self.anchors["R-3"].line, self.anchors["R-3"].end_line), (16, 20))
+
+    def test_wrong_path_with_line_in_span_keeps_the_line(self) -> None:
+        f, report = self.run_one({"finding_id": "BFLA-R-1-1", "route_id": "R-1",
+                                  "location": {"file": "routes.js", "start_line": 9},
+                                  "evidence": [{"file": "routes.js", "line": 9, "why": "no role check"}]})
+        self.assertEqual(f["location"], {"file": "node-express/routes/admin.js", "start_line": 9})
+        self.assertEqual(f["evidence"], [{"file": "node-express/routes/admin.js", "line": 9, "why": "no role check"}])
+        self.assertEqual(report.moved, ["BFLA-R-1-1"])
+
+    def test_line_outside_span_falls_back_to_handler(self) -> None:
+        f, _ = self.run_one({"finding_id": "BFLA-R-1-1", "route_id": "R-1",
+                             "location": {"file": "node-express/routes/admin.js", "start_line": 17}})
+        self.assertEqual(f["location"]["start_line"], 8)
+
+    def test_candidate_finding_takes_candidate_site(self) -> None:
+        f, _ = self.run_one({"finding_id": "MASS-M-14-1", "candidate_id": "M-14",
+                             "location": {"file": "app.py", "start_line": 8, "end_line": 9},
+                             "evidence": [{"file": "app.py", "line": 8, "why": "binds request body"}]})
+        self.assertEqual(f["location"], {"file": "python-flask/profile.py", "start_line": 10})
+        self.assertEqual(f["evidence"][0]["file"], "python-flask/profile.py")
+
+    def test_correct_location_is_not_reported_as_moved(self) -> None:
+        f, report = self.run_one({"finding_id": "BFLA-R-2-1", "route_id": "R-2",
+                                  "location": {"file": "node-express/routes/admin.js", "start_line": 13}})
+        self.assertEqual(f["location"]["start_line"], 13)
+        self.assertEqual((report.moved, report.unanchored), ([], []))
+
+    def test_unknown_reference_is_unanchored_and_low_confidence(self) -> None:
+        f, report = self.run_one({"finding_id": "BFLA-R-9-1", "route_id": "R-9", "confidence": "high",
+                                  "location": {"file": "x.js", "start_line": 1}})
+        self.assertEqual(f["location"], {"file": "x.js", "start_line": 1})
+        self.assertEqual(f["confidence"], "low")
+        self.assertEqual(report.unanchored, ["BFLA-R-9-1"])
+
+    def test_input_is_not_mutated(self) -> None:
+        original = {"finding_id": "BFLA-R-1-1", "route_id": "R-1", "location": {"file": "routes.js", "start_line": 9}}
+        snapshot = json.dumps(original, sort_keys=True)
+        self.run_one(original)
+        self.assertEqual(json.dumps(original, sort_keys=True), snapshot)
+
+
+class TestModelSource(unittest.TestCase):
+    """The privilege auditor sees the bound model's fields, from the same app and language (#319)."""
+
+    def setUp(self) -> None:
+        from operate.ai.runner import _model_source
+        self.model_source = _model_source
+        self.tmp = Path(tempfile.mkdtemp(prefix="komagu_model_"))
+        _write(self.tmp / "java-legacy/src/model/Account.java", "public class Account {\n    private String role;\n}\n")
+        _write(self.tmp / "java-legacy/src/web/ProfileServlet.java",
+               "class ProfileServlet {\n  void post() {\n    Account account = new Account();\n    BeanUtils.populate(account, params);\n  }\n}\n")
+        _write(self.tmp / "php-laravel/app/Models/User.php", "<?php\nclass User extends Model {\n  protected $guarded = [];\n}\n")
+        _write(self.tmp / "node-express/routes/profile.js", "router.post('/p', (req, res) => User.update(req.body));\n")
+
+    def tearDown(self) -> None:
+        shutil.rmtree(self.tmp, ignore_errors=True)
+
+    def test_target_class_is_found_with_its_fields(self) -> None:
+        m = self.model_source(self.tmp, "Account", "java-legacy/src/web/ProfileServlet.java", 4)
+        self.assertEqual(m["file"], "java-legacy/src/model/Account.java")
+        self.assertIn("private String role", m["code"])
+
+    def test_class_is_inferred_from_new_near_the_binding(self) -> None:
+        m = self.model_source(self.tmp, None, "java-legacy/src/web/ProfileServlet.java", 4)
+        self.assertEqual((m["class"], m["file"]), ("Account", "java-legacy/src/model/Account.java"))
+
+    def test_other_app_or_language_is_not_used(self) -> None:
+        m = self.model_source(self.tmp, "User", "node-express/routes/profile.js", 1)
+        self.assertEqual((m["class"], m["file"]), ("User", None))
+        self.assertIn("not found", m["code"])
+
+    def test_unknown_target_without_new_gives_none(self) -> None:
+        self.assertIsNone(self.model_source(self.tmp, None, "node-express/routes/profile.js", 1))
+        self.assertIsNone(self.model_source(self.tmp, "../etc", "node-express/routes/profile.js", 1))
+
+
+class _ScriptedClient:
+    """Returns the scripted replies in order; an Exception item is raised."""
+
+    model = "scripted"
+    endpoint = "test://"
+
+    def __init__(self, replies: list) -> None:
+        self.replies = list(replies)
+        self.calls: list = []
+
+    def chat(self, messages, temperature=0.1):  # noqa: ANN001
+        self.calls.append(messages)
+        item = self.replies.pop(0)
+        if isinstance(item, Exception):
+            raise item
+        return item
+
+    @staticmethod
+    def extract_json(content: str):  # noqa: ANN205
+        from operate.ai.client import LLMClient
+        return LLMClient.extract_json(content)
+
+
+class TestRetry(unittest.TestCase):
+    def setUp(self) -> None:
+        self.tmp = Path(tempfile.mkdtemp(prefix="komagu_retry_"))
+
+    def tearDown(self) -> None:
+        shutil.rmtree(self.tmp, ignore_errors=True)
+
+    def runner(self, replies: list) -> HeadlessAIRunner:
+        return HeadlessAIRunner(self.tmp, self.tmp / "out", _ScriptedClient(replies))
+
+    def test_empty_reply_is_retried_once(self) -> None:
+        r = self.runner(["", '{"findings": []}'])
+        self.assertEqual(r._chat("4a-bola-auditor", "routes-001", [{"role": "user", "content": "audit"}]), '{"findings": []}')
+        self.assertEqual(r.retries, {"4a-bola-auditor": ["routes-001"]})
+        retry = r.client.calls[1]
+        self.assertEqual([m["role"] for m in retry], ["user", "user"])  # no empty assistant turn
+        self.assertIn("JSON object only", retry[-1]["content"])
+
+    def test_unparseable_reply_is_retried_with_its_text(self) -> None:
+        r = self.runner(["looks fine to me", '{"findings": []}'])
+        r._chat("4c-privilege-auditor", "privilege-001", [{"role": "user", "content": "audit"}])
+        self.assertEqual([m["role"] for m in r.client.calls[1]], ["user", "assistant", "user"])
+
+    def test_second_bad_reply_keeps_the_first_text(self) -> None:
+        r = self.runner(["looks fine to me", "still not json"])
+        self.assertEqual(r._chat("5-finding-verifier", "verified-1", [{"role": "user", "content": "v"}]), "looks fine to me")
+
+    def test_good_reply_is_not_retried(self) -> None:
+        r = self.runner(['{"findings": []}'])
+        r._chat("4a-bola-auditor", "routes-001", [{"role": "user", "content": "audit"}])
+        self.assertEqual((len(r.client.calls), r.retries), (1, {}))
+
+    def test_failed_call_is_not_retried(self) -> None:
+        r = self.runner([RuntimeError("timed out")])
+        self.assertIsNone(r._chat("4b-injection-auditor", "injection-001", [{"role": "user", "content": "i"}]))
+        self.assertEqual((len(r.client.calls), r.retries), (1, {}))
+        self.assertEqual(r.call_errors, {"4b-injection-auditor": {"injection-001": "timed out"}})
+
+
+if __name__ == "__main__":
+    unittest.main()

package/operate/tests/test_cli_baseline.py

@@ -58,7 +58,7 @@ class TestScanBaseline(unittest.TestCase):
     def test_default_scan_adds_fingerprint_and_passes(self) -> None:
         res = self.scan()
         self.assertEqual(res.returncode, 0, res.stderr + res.stdout)
-        self.assertTrue(self.sarif_result()["partialFingerprints"]["komainu/v1"].startswith("kfp1:"))
+        self.assertTrue(self.sarif_result()["partialFingerprints"]["komagu/v1"].startswith("kfp1:"))
 
     def test_fail_on_new_without_baseline_fails(self) -> None:
         res = self.scan("--fail-on", "new")
@@ -117,14 +117,6 @@ class TestScanSuppressions(unittest.TestCase):
         sarif = json.loads((self.out / "findings.sarif").read_text(encoding="utf-8"))
         self.assertEqual(sarif["runs"][0]["results"][0]["suppressions"][0]["status"], "accepted")
 
-    def test_legacy_komainu_suppressions_dir_still_used(self) -> None:
-        self.write_suppressions(self.target / ".komainu" / "suppressions.json", "2999-12-31")
-        res = self.scan("--fail-on", "new")
-        self.assertEqual(res.returncode, 0, res.stderr + res.stdout)
-        self.assertIn(".komainu/suppressions.json is deprecated", res.stderr)
-        sarif = json.loads((self.out / "findings.sarif").read_text(encoding="utf-8"))
-        self.assertEqual(sarif["runs"][0]["results"][0]["suppressions"][0]["status"], "accepted")
-
     def test_expired_explicit_suppression_fails_gate_and_warns(self) -> None:
         path = self.out.parent / "suppressions.json"
         self.write_suppressions(path, "2020-01-01")

package/operate/tests/test_cli_env.py

@@ -1,44 +1,23 @@
 #!/usr/bin/env python3
-"""KOMAGU_* environment variables with the deprecated KOMAINU_* fallback (#290)."""
+"""KOMAGU_* environment variables; the pre-rename KOMAINU_* names are no longer read (#312)."""
 
 from __future__ import annotations
 
-import contextlib
-import io
 import unittest
 
 from operate.cli import env as cli_env
 
 
 class TestGetenv(unittest.TestCase):
-    def setUp(self) -> None:
-        cli_env._warned.clear()
-
-    def lookup(self, environ, default=None):
-        stderr = io.StringIO()
-        with contextlib.redirect_stderr(stderr):
-            value = cli_env.getenv("AI_MODEL", default, env=environ)
-        return value, stderr.getvalue()
-
-    def test_new_name_wins_without_warning(self) -> None:
-        value, err = self.lookup({"KOMAGU_AI_MODEL": "new", "KOMAINU_AI_MODEL": "old"})
-        self.assertEqual(value, "new")
-        self.assertEqual(err, "")
-
-    def test_legacy_name_is_read_with_warning(self) -> None:
-        value, err = self.lookup({"KOMAINU_AI_MODEL": "old"})
-        self.assertEqual(value, "old")
-        self.assertIn("KOMAINU_AI_MODEL is deprecated, set KOMAGU_AI_MODEL", err)
-
-    def test_legacy_warning_is_printed_once(self) -> None:
-        self.lookup({"KOMAINU_AI_MODEL": "old"})
-        _, err = self.lookup({"KOMAINU_AI_MODEL": "old"})
-        self.assertEqual(err, "")
+    def test_reads_komagu_name(self) -> None:
+        self.assertEqual(cli_env.getenv("AI_MODEL", env={"KOMAGU_AI_MODEL": "new"}), "new")
+
+    def test_legacy_name_is_ignored(self) -> None:
+        self.assertEqual(cli_env.getenv("AI_MODEL", "llama3.1", env={"KOMAINU_AI_MODEL": "old"}), "llama3.1")
 
     def test_default_when_unset(self) -> None:
-        value, err = self.lookup({}, default="llama3.1")
-        self.assertEqual(value, "llama3.1")
-        self.assertEqual(err, "")
+        self.assertEqual(cli_env.getenv("AI_MODEL", "llama3.1", env={}), "llama3.1")
+        self.assertIsNone(cli_env.getenv("AI_MODEL", env={}))
 
 
 if __name__ == "__main__":

package/operate/tests/test_cross_user_pipeline.py

@@ -208,7 +208,7 @@ class TestCrossUserPipeline(unittest.TestCase):
 
         # Check BOLA result mapping
         bola_res = run["results"][0]
-        self.assertEqual(bola_res["ruleId"], "KOMAINU-BOLA-CWE639")
+        self.assertEqual(bola_res["ruleId"], "KOMAGU-BOLA-CWE639")
         self.assertEqual(bola_res["level"], "error")
         loc = bola_res["locations"][0]["physicalLocation"]
         self.assertEqual(loc["artifactLocation"]["uri"], "legacy/orders.php")
@@ -217,7 +217,7 @@ class TestCrossUserPipeline(unittest.TestCase):
 
         # Check SQLi result mapping
         sqli_res = run["results"][1]
-        self.assertEqual(sqli_res["ruleId"], "KOMAINU-INJ-CWE89")
+        self.assertEqual(sqli_res["ruleId"], "KOMAGU-INJ-CWE89")
         self.assertEqual(sqli_res["level"], "error")
 
     def test_sarif_cli_execution(self) -> None:

package/operate/tests/test_exploit_and_virtual_patch.py

@@ -111,9 +111,9 @@ class TestExploitAndVirtualPatcher(unittest.TestCase):
             self.assertIn("SecRule REQUEST_URI", conf_content)
             self.assertIn("id:1100001", conf_content)
             self.assertIn("id:1100002", conf_content)
-            self.assertIn("tag:'komainu-virtual-patch'", conf_content)
-            self.assertIn("tag:'komainu-bola'", conf_content)
-            self.assertIn("tag:'komainu-sqli'", conf_content)
+            self.assertIn("tag:'komagu-virtual-patch'", conf_content)
+            self.assertIn("tag:'komagu-bola'", conf_content)
+            self.assertIn("tag:'komagu-sqli'", conf_content)
 
     def test_cli_protect_with_virtual_patch(self) -> None:
         """komagu protect --virtual-patch must synthesize rules via CLI."""

package/operate/tests/test_headless_ai.py

@@ -74,6 +74,67 @@ class TestLLMClient(unittest.TestCase):
         self.assertIn("Failed to connect to LLM endpoint", str(ctx.exception))
 
 
+class TestSanitizeFinding(unittest.TestCase):
+    """Format repairs for model output that would otherwise fail finding.schema.json (#286)."""
+
+    def test_impact_list_becomes_string(self) -> None:
+        f = HeadlessAIRunner._sanitize_finding({"category": "mass_assignment", "subtype": "whole_object_binding",
+                                                "impact": ["role escalation", "balance change"]})
+        self.assertEqual(f["impact"], "role escalation; balance change")
+
+    def test_verdict_in_subtype_moves_to_status(self) -> None:
+        f = HeadlessAIRunner._sanitize_finding({"category": "mass_assignment", "subtype": "needs_review", "status": "unverified"})
+        self.assertEqual(f["subtype"], "whole_object_binding")
+        self.assertEqual(f["status"], "needs_review")
+
+    def test_unknown_bfla_subtype_falls_back(self) -> None:
+        f = HeadlessAIRunner._sanitize_finding({"category": "bfla", "subtype": "admin_only", "status": "unverified"})
+        self.assertEqual((f["subtype"], f["status"]), ("missing_role_check", "unverified"))
+
+    def test_null_evidence_line_and_missing_status_are_repaired(self) -> None:
+        f = HeadlessAIRunner._sanitize_finding({"category": "mass_assignment", "subtype": "whole_object_binding",
+                                                "location": {"file": "a.py", "start_line": 7},
+                                                "evidence": [{"file": "a.py", "line": None, "why": "binds body"}]})
+        self.assertEqual(f["evidence"][0]["line"], 7)
+        self.assertEqual(f["status"], "unverified")
+
+    def test_valid_subtype_is_kept(self) -> None:
+        f = HeadlessAIRunner._sanitize_finding({"category": "bfla", "subtype": "role_from_request"})
+        self.assertEqual(f["subtype"], "role_from_request")
+
+
+class TestVerificationContext(unittest.TestCase):
+    """The headless verifier gets the code it judges, including server-side includes (#286)."""
+
+    def setUp(self) -> None:
+        self.tmp = Path(tempfile.mkdtemp(prefix="komagu_verify_ctx_"))
+        (self.tmp / "inc").mkdir()
+        (self.tmp / "admin").mkdir()
+        (self.tmp / "inc" / "auth.php").write_text("<?php\n// Login check only\nsession_start();\n", encoding="utf-8")
+        (self.tmp / "admin" / "delete_user.php").write_text(
+            "<?php\nrequire_once '../inc/auth.php';\n$db->prepare('DELETE FROM users WHERE id = ?');\n", encoding="utf-8")
+
+    def tearDown(self) -> None:
+        shutil.rmtree(self.tmp, ignore_errors=True)
+
+    def test_included_files_are_resolved(self) -> None:
+        from operate.ai.runner import _included_files
+        self.assertEqual(_included_files(self.tmp, "admin/delete_user.php"), ["inc/auth.php"])
+        self.assertEqual(_included_files(self.tmp, "missing.php"), [])
+
+    def test_context_has_site_and_included_code(self) -> None:
+        from operate.ai.runner import _verification_context
+        ctx = _verification_context(self.tmp, {"location": {"file": "admin/delete_user.php", "start_line": 3}})
+        self.assertIn("DELETE FROM users", ctx["location"])
+        self.assertEqual(ctx["included_files"][0]["file"], "inc/auth.php")
+        self.assertIn("Login check only", ctx["included_files"][0]["code"])
+
+    def test_include_outside_target_is_ignored(self) -> None:
+        from operate.ai.runner import _included_files
+        (self.tmp / "x.php").write_text("<?php include '../../etc/passwd';\n", encoding="utf-8")
+        self.assertEqual(_included_files(self.tmp, "x.php"), [])
+
+
 class TestHeadlessAIRunner(unittest.TestCase):
     """End-to-end tests for HeadlessAIRunner and multi-agent pipeline."""
 
@@ -109,7 +170,7 @@ module.exports = app;
         # Mock LLM response dispatcher
         def mock_agent_responses(messages, model):
             user_msg = messages[-1]["content"]
-            if "Auth Model" in user_msg or "Pre-scan Stack Profile" in user_msg:
+            if ("Auth Model" in user_msg or "Pre-scan Stack Profile" in user_msg) and "Findings to Verify" not in user_msg:
                 return "# Mock Application Auth Model\n\n- Auth: Express session\n- Ownership: missing on /api/orders/:id\n"
             if "dynamic query string concatenation or interpolation" in user_msg:
                 return """```json
@@ -196,6 +257,7 @@ module.exports = app;
 ```"""
             return '{"status": "ok"}'
 
+        self.mock_agent_responses = mock_agent_responses
         self.server, self.thread, self.base_url = start_mock_llm_server(
             port=0, response_generator=mock_agent_responses
         )
@@ -204,6 +266,91 @@ module.exports = app;
         self.server.server_close()
         shutil.rmtree(self.temp_dir, ignore_errors=True)
 
+    def _prescan(self) -> None:
+        import subprocess
+
+        prescan_script = PROJECT_ROOT / "assess" / "lsa" / "scripts" / "run_prescan.py"
+        res = subprocess.run(
+            [sys.executable, str(prescan_script), str(self.target_dir), str(self.out_dir)],
+            capture_output=True,
+            text=True,
+        )
+        self.assertEqual(res.returncode, 0, f"Pre-scan failed: {res.stderr}")
+
+    def test_run_stats_record_tokens_and_phases(self) -> None:
+        self._prescan()
+        client = LLMClient(endpoint=self.base_url, model="mock-model", api_key="test")
+        HeadlessAIRunner(self.target_dir, self.out_dir, client).run()
+
+        stats = json.loads((self.out_dir / "ai-run-stats.json").read_text(encoding="utf-8"))
+        self.assertEqual(stats["model"], "mock-model")
+        self.assertGreater(stats["totals"]["calls"], 0)
+        # the mock server reports 100 prompt / 50 completion tokens per call
+        self.assertEqual(stats["totals"]["prompt_tokens"], 100 * stats["totals"]["calls"])
+        self.assertEqual(stats["totals"]["completion_tokens"], 50 * stats["totals"]["calls"])
+        self.assertEqual(sum(ph["calls"] for ph in stats["phases"].values()), stats["totals"]["calls"])
+        self.assertIn("5-finding-verifier", stats["phases"])
+        # the mock answers the BOLA prompt with the auth-model markdown; the retry gets plain JSON (#319)
+        self.assertEqual(stats["retries"], {"4a-bola-auditor": ["routes-001"]})
+        self.assertEqual(stats["parse_failures"], {})
+        self.assertEqual(stats["anchoring"]["unanchored"], [])
+
+    def test_unparseable_verifier_reply_leaves_findings_unverified(self) -> None:
+        """A broken verifier reply must not confirm findings (#286)."""
+        self.server.server_close()
+
+        verifier_prompts = []
+
+        def broken_verifier(messages, model):
+            if any("Findings to Verify & Challenge" in m["content"] for m in messages):
+                verifier_prompts.append(messages[-1]["content"])
+                return "I think these all look vulnerable."
+            return self.mock_agent_responses(messages, model)
+
+        self.server, self.thread, self.base_url = start_mock_llm_server(port=0, response_generator=broken_verifier)
+        self._prescan()
+        client = LLMClient(endpoint=self.base_url, model="mock-model", api_key="test")
+        logs = []
+        HeadlessAIRunner(self.target_dir, self.out_dir, client, step_callback=lambda st, msg: logs.append((st, msg))).run()
+
+        findings = json.loads((self.out_dir / "findings.json").read_text(encoding="utf-8"))["findings"]
+        self.assertGreaterEqual(len(findings), 1)
+        self.assertNotIn("confirmed", [f.get("status") for f in findings])
+        coverage = json.loads((self.out_dir / "coverage.json").read_text(encoding="utf-8"))
+        self.assertEqual(sorted(coverage["findings_without_verification"]), sorted(f["finding_id"] for f in findings))
+        stats = json.loads((self.out_dir / "ai-run-stats.json").read_text(encoding="utf-8"))
+        self.assertEqual(stats["parse_failures"]["5-finding-verifier"], ["verified-1"])
+        self.assertEqual(stats["retries"]["5-finding-verifier"], ["verified-1"])
+        # the verifier sees the code and the auth model, and is told not to assume unseen controls
+        self.assertEqual(len(verifier_prompts), 2, "one retry after the unparseable reply")
+        self.assertIn("Answer again with the JSON object only", verifier_prompts[1])
+        self.assertIn("code_context", verifier_prompts[0])
+        self.assertIn("Mock Application Auth Model", verifier_prompts[0])
+        self.assertIn("Never assume a control", verifier_prompts[0])
+        raw = self.out_dir / "ai-raw" / "5-finding-verifier-verified-1.txt"
+        self.assertEqual(raw.read_text(encoding="utf-8"), "I think these all look vulnerable.")
+        self.assertTrue(any(st == "warn" and "verified-1" in msg for st, msg in logs))
+
+    def test_failed_batch_call_is_recorded_and_run_continues(self) -> None:
+        """A timeout on one batch must not abort the run or lose earlier phases (#286)."""
+
+        class TimeoutOnInjection(LLMClient):
+            def chat(self, messages, temperature=0.1, max_tokens=None):  # noqa: ANN001
+                if "dynamic query string concatenation or interpolation" in messages[-1]["content"]:
+                    raise RuntimeError("timed out")
+                return super().chat(messages, temperature=temperature, max_tokens=max_tokens)
+
+        self._prescan()
+        client = TimeoutOnInjection(endpoint=self.base_url, model="mock-model", api_key="test")
+        result = HeadlessAIRunner(self.target_dir, self.out_dir, client).run()
+        self.assertEqual(result["status"], "success")
+
+        stats = json.loads((self.out_dir / "ai-run-stats.json").read_text(encoding="utf-8"))
+        self.assertEqual(stats["call_errors"], {"4b-injection-auditor": {"injection-001": "timed out"}})
+        self.assertNotIn("4b-injection-auditor", stats["parse_failures"])
+        self.assertIn("5-finding-verifier", stats["phases"])
+        self.assertTrue((self.out_dir / "findings.json").is_file())
+
     def test_headless_ai_runner_full_cycle(self) -> None:
         # 1. Run deterministic pre-scan to populate OUT
         prescan_script = PROJECT_ROOT / "assess" / "lsa" / "scripts" / "run_prescan.py"

package/operate/tests/test_npm_package.py

@@ -14,7 +14,6 @@ from pathlib import Path
 REPO_ROOT = Path(__file__).resolve().parents[2]
 PACKAGE_JSON = REPO_ROOT / "package.json"
 BIN_KOMAGU_JS = REPO_ROOT / "bin" / "komagu.js"
-BIN_LEGACY_JS = REPO_ROOT / "bin" / "komainu-legacy.js"
 WORKFLOW_FILE = REPO_ROOT / ".github" / "workflows" / "npm-publish.yml"
 RELEASE_PLEASE_WORKFLOW = REPO_ROOT / ".github" / "workflows" / "release-please.yml"
 RELEASE_PLEASE_CONFIG = REPO_ROOT / "release-please-config.json"
@@ -35,9 +34,8 @@ class TestNPMPackage(unittest.TestCase):
         self.assertEqual(data.get("publishConfig", {}).get("access"), "public")
         self.assertIn("version", data)
         self.assertEqual(data.get("bin", {}).get("komagu"), "bin/komagu.js")
-        # Deprecated pre-rename aliases (#290)
-        self.assertEqual(data.get("bin", {}).get("komainu"), "bin/komainu-legacy.js")
-        self.assertEqual(data.get("bin", {}).get("komainu-guard"), "bin/komainu-legacy.js")
+        # Pre-rename aliases were removed in 2.0 (#312)
+        self.assertEqual(set(data.get("bin", {})), {"komagu"})
         self.assertEqual(data.get("license"), "Apache-2.0")
 
         # Whitelisted files must include platform modules
@@ -72,18 +70,6 @@ class TestNPMPackage(unittest.TestCase):
         self.assertIn("test", res_h.stdout)
         self.assertIn("demo", res_h.stdout)
 
-    def test_legacy_bin_alias_warns_and_delegates(self) -> None:
-        """Deprecated komainu / komainu-guard bins must print a rename notice and still run (#290)."""
-        node_bin = shutil.which("node")
-        if not node_bin:
-            self.skipTest("Node.js runtime not installed on host")
-
-        self.assertTrue(BIN_LEGACY_JS.stat().st_mode & 0o111 != 0, "bin/komainu-legacy.js is not executable")
-        res = subprocess.run([node_bin, str(BIN_LEGACY_JS), "--version"], capture_output=True, text=True)
-        self.assertEqual(res.returncode, 0, res.stderr)
-        self.assertIn("komagu v", res.stdout)
-        self.assertIn("renamed to `komagu`", res.stderr)
-
     def test_node_launcher_error_on_missing_python(self) -> None:
         """Launcher must show friendly error with Docker fallback if Python is missing."""
         node_bin = shutil.which("node")