Modularize Make targets and retire C901 backlog (#780)

* Modularize Make targets and enforce complexity limits

* Fix SMT checker type narrowing

Author: morluto

.github/ci-impact.json

@@ -415,7 +415,8 @@
     {
       "name": "makefile",
       "patterns": [
-        "Makefile"
+        "Makefile",
+        "make/**"
       ],
       "suites": [
         "static",

.github/scripts/plan-benchmarks

@@ -66,6 +66,7 @@ BENCHMARK_CONTROL_PATHS = frozenset(
         ".github/workflows/benchmarks.yml",
         ".github/workflows/heldout-benchmarks.yml",
         "Makefile",
+        "make/harbor.mk",
         "tools/check_benchmark_adapters.py",
         "tools/benchmark_pr_status.py",
         "tools/check_benchmark_contracts.py",

.github/scripts/validate-ci-plan

@@ -11,6 +11,10 @@ import tomllib
 from pathlib import Path
 
 ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from tools.makefile_catalog import MakefileCatalogError, discover_makefiles
 
 BOOLEAN_KEYS = (
     "run-python",
@@ -117,7 +121,7 @@ def _validate_catalog() -> None:
         targets = set(
             re.findall(
                 r"(?m)^([A-Za-z0-9_.-]+):(?:[^=]|$)",
-                (ROOT / "Makefile").read_text(encoding="utf-8"),
+                discover_makefiles(ROOT).text(),
             )
         )
         for name, entry in catalog.items():
@@ -177,7 +181,14 @@ def _validate_catalog() -> None:
                 "CI catalog must keep a local-only deploy gate "
                 "with command 'make deploy-check'"
             )
-    except (OSError, KeyError, TypeError, ValueError, tomllib.TOMLDecodeError) as exc:
+    except (
+        MakefileCatalogError,
+        OSError,
+        KeyError,
+        TypeError,
+        ValueError,
+        tomllib.TOMLDecodeError,
+    ) as exc:
         fail(f"invalid CI validation catalog: {exc}")
 
 

.github/workflows/benchmarks.yml

@@ -119,6 +119,7 @@ jobs:
             --config benchmarks/environment-profiles.toml \
             --config .github/workflows/benchmarks.yml \
             --config Makefile \
+            --config make/harbor.mk \
             --config tools/check_benchmark_adapters.py \
             --config tools/check_benchmark_contracts.py \
             --config tools/check_benchmark_static.py \

.github/workflows/ci.yml

@@ -118,6 +118,9 @@ jobs:
             --config .github/scripts/validate-ci-plan \
             --config .github/workflows/ci.yml \
             --config Makefile \
+            --config make/development.mk \
+            --config make/harbor.mk \
+            --config make/evaluations.mk \
             --plan-file "$plan_dir/plan.txt" \
             --paths-file "$plan_dir/changed-paths.txt" \
             --output "$plan_dir/plan-receipt.json"

Makefile

@@ -267,6 +267,21 @@ def resolve_evidence(
 _JSON_WHITESPACE_CHARS = " \t\n\r"
 
 
+def _drain_stream_tail(stream, decoder) -> None:
+    """Reject any non-whitespace content after the parsed JSON value."""
+
+    while True:
+        block = stream.read(65_536)
+        if not block:
+            break
+        tail = decoder.decode(block)
+        if tail and not all(character in _JSON_WHITESPACE for character in tail):
+            raise ValueError("non-whitespace after evidence JSON value")
+    tail = decoder.decode(b"", final=True)
+    if tail and not all(character in _JSON_WHITESPACE for character in tail):
+        raise ValueError("non-whitespace after evidence JSON value")
+
+
 def _read_streaming_json_value(stream) -> Any:
     """Parse the first JSON value from a binary stream without a byte cap.
 
@@ -301,16 +316,7 @@ def _read_streaming_json_value(stream) -> Any:
             continue
         if not all(character in _JSON_WHITESPACE for character in buffer[end:]):
             raise ValueError("non-whitespace after evidence JSON value")
-        while True:
-            block = stream.read(65_536)
-            if not block:
-                break
-            tail = decoder.decode(block)
-            if tail and not all(character in _JSON_WHITESPACE for character in tail):
-                raise ValueError("non-whitespace after evidence JSON value")
-        tail = decoder.decode(b"", final=True)
-        if tail and not all(character in _JSON_WHITESPACE for character in tail):
-            raise ValueError("non-whitespace after evidence JSON value")
+        _drain_stream_tail(stream, decoder)
         return value
 
 

benchmarks/datasets/conjecture-probes-v1/reconstruction-deck-certificate/tests/verifier_support.py

@@ -1,7 +1,7 @@
 FROM python:3.12-slim@sha256:57cd7c3a7a273101a6485ba99423ee568157882804b1124b4dd04266317710de
 RUN python -m pip install --no-cache-dir attrs==26.1.0 jsonschema==4.26.0 jsonschema-specifications==2025.9.1 referencing==0.37.0 rpds-py==2026.6.3 typing-extensions==4.16.0
 LABEL jacobian.task="jacobian/vizing-bounded-cartesian-products" \
-      jacobian.checksum="0eba7b4cb29a47aae2d613ea04941d599c32998dda49aa089653441a50db6945"
+      jacobian.checksum="838147c45b1c21c5b7d1e54d2b0d1d5995c448b2bb649669dbefda6def151b59"
 COPY expected.json input.json public_contract.json test.sh verifier.py verifier_support.py /tests/
 COPY input.json /app/input.json
 RUN chmod +x /tests/test.sh && python -c 'import json; assert json.load(open("/tests/input.json"))["task_id"] == "jacobian/vizing-bounded-cartesian-products"'

benchmarks/datasets/conjecture-probes-v1/vizing-bounded-cartesian-products/tests/Dockerfile

@@ -84,6 +84,25 @@ def _product(left: list[list[int]], right: list[list[int]]) -> list[list[int]]:
     return [sorted(neighbors) for neighbors in result]
 
 
+def _frozen_graphs(graphs: list[object]) -> dict[str, list[list[int]]] | None:
+    by_id: dict[str, list[list[int]]] = {}
+    for graph in graphs:
+        if (
+            not isinstance(graph, dict)
+            or set(graph) != {"id", "adjacency"}
+            or graph.get("id") not in GRAPH_IDS
+            or graph["id"] in by_id
+        ):
+            return None
+        adjacency = _adjacency(graph["adjacency"])
+        if adjacency is None:
+            return None
+        by_id[graph["id"]] = adjacency
+    if tuple(by_id) != GRAPH_IDS:
+        return None
+    return by_id
+
+
 def _frozen() -> dict[str, Any] | None:
     try:
         value = json.loads((TESTS / "input.json").read_text())
@@ -106,20 +125,8 @@ def _frozen() -> dict[str, Any] | None:
         or len(pairs) != 13
     ):
         return None
-    by_id: dict[str, list[list[int]]] = {}
-    for graph in graphs:
-        if (
-            not isinstance(graph, dict)
-            or set(graph) != {"id", "adjacency"}
-            or graph.get("id") not in GRAPH_IDS
-            or graph["id"] in by_id
-        ):
-            return None
-        adjacency = _adjacency(graph["adjacency"])
-        if adjacency is None:
-            return None
-        by_id[graph["id"]] = adjacency
-    if tuple(by_id) != GRAPH_IDS:
+    by_id = _frozen_graphs(graphs)
+    if by_id is None:
         return None
     actual = []
     for pair in pairs:
@@ -167,17 +174,11 @@ def _product_witness(
     )
 
 
-def _math(result: object, frozen: dict[str, Any]) -> bool:
-    if (
-        not isinstance(result, dict)
-        or set(result) != {"graphs", "pairs", "derived_conclusion", "scope_identity"}
-        or result.get("scope_identity") != SCOPE
-    ):
-        return False
-    graphs = frozen["graphs"]
-    expected = {name: _domination(graphs[name]) for name in GRAPH_IDS}
-    if any(value is None for value in expected.values()):
-        return False
+def _math_graphs(
+    result: dict[str, Any],
+    graphs: dict[str, list[list[int]]],
+    expected: dict[str, Any],
+) -> bool:
     rows = result.get("graphs")
     if not isinstance(rows, list) or len(rows) != 8:
         return False
@@ -204,11 +205,17 @@ def _math(result: object, frozen: dict[str, Any]) -> bool:
             or not _dominates(row["minimum_dominating_set"], gamma, adjacency)
         ):
             return False
-    if seen != set(GRAPH_IDS):
-        return False
+    return seen == set(GRAPH_IDS)
+
+
+def _math_pairs(
+    result: dict[str, Any],
+    graphs: dict[str, list[list[int]]],
+    expected: dict[str, Any],
+) -> bool | None:
     rows = result.get("pairs")
     if not isinstance(rows, list) or len(rows) != 13:
-        return False
+        return None
     seen_pairs: set[tuple[str, str]] = set()
     all_hold = True
     for row in rows:
@@ -226,10 +233,10 @@ def _math(result: object, frozen: dict[str, Any]) -> bool:
             "bound_holds",
         }
         if not isinstance(row, dict) or set(row) != required:
-            return False
+            return None
         pair = (row.get("left"), row.get("right"))
         if pair not in PAIR_IDS or pair in seen_pairs:
-            return False
+            return None
         seen_pairs.add(pair)
         left, right = pair
         left_adj, right_adj = graphs[left], graphs[right]
@@ -238,7 +245,7 @@ def _math(result: object, frozen: dict[str, Any]) -> bool:
         product_adj = _product(left_adj, right_adj)
         product_value = _domination(product_adj)
         if product_value is None:
-            return False
+            return None
         product_gamma = product_value[0]
         if (
             row["gamma_left"] != left_gamma
@@ -257,12 +264,31 @@ def _math(result: object, frozen: dict[str, Any]) -> bool:
                 len(right_adj),
             )
         ):
-            return False
+            return None
         holds = product_gamma >= left_gamma * right_gamma
         if row["bound_holds"] is not holds:
-            return False
+            return None
         all_hold = all_hold and holds
     if seen_pairs != set(PAIR_IDS):
+        return None
+    return all_hold
+
+
+def _math(result: object, frozen: dict[str, Any]) -> bool:
+    if (
+        not isinstance(result, dict)
+        or set(result) != {"graphs", "pairs", "derived_conclusion", "scope_identity"}
+        or result.get("scope_identity") != SCOPE
+    ):
+        return False
+    graphs = frozen["graphs"]
+    expected = {name: _domination(graphs[name]) for name in GRAPH_IDS}
+    if any(value is None for value in expected.values()):
+        return False
+    if not _math_graphs(result, graphs, expected):
+        return False
+    all_hold = _math_pairs(result, graphs, expected)
+    if all_hold is None:
         return False
     return result.get("derived_conclusion") == (
         "HOLDS_ON_FROZEN_PAIR_SET" if all_hold else "VIOLATION_IN_FROZEN_PAIR_SET"

benchmarks/datasets/conjecture-probes-v1/vizing-bounded-cartesian-products/tests/verifier.py

@@ -1,6 +1,6 @@
 FROM python:3.12-slim@sha256:57cd7c3a7a273101a6485ba99423ee568157882804b1124b4dd04266317710de
 RUN python -m pip install --no-cache-dir attrs==26.1.0 jsonschema==4.26.0 jsonschema-specifications==2025.9.1 referencing==0.37.0 rpds-py==2026.6.3 typing-extensions==4.16.0
-LABEL jacobian.checksum="188d51930c7bafebb659afa2d9d75c9388616f39636c18216114d9823fef83f6"
+LABEL jacobian.checksum="51e3e8145415187b5ef60562608ae5f7b2cfd38fa0ff169cf86b09437988cc59"
 LABEL jacobian.task="jacobian/cubic-image-classification"
 COPY expected.json input.json test.sh verifier.py verifier_support.py public_contract.json /tests/
 COPY input.json /app/input.json