codd-dev 2.38.0__tar.gz → 2.40.0__tar.gz

{codd_dev-2.38.0 → codd_dev-2.40.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.38.0
+Version: 2.40.0
 Summary: CoDD: Coherence-Driven Development — cross-artifact change impact analysis
 Project-URL: Homepage, https://github.com/yohey-w/codd-dev
 Project-URL: Repository, https://github.com/yohey-w/codd-dev

{codd_dev-2.38.0 → codd_dev-2.40.0}/codd/__init__.py

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "2.38.0"
+__version__ = "2.40.0"

{codd_dev-2.38.0 → codd_dev-2.40.0}/codd/contracts_registry/registry.py

@@ -230,6 +230,28 @@ _COVERED: tuple[Contract, ...] = (
         ),
         finding_ids=("PC-docref-resolution",),
     ),
+    # ── authenticity.observable_in_supported_stack.v1 (GPT r2 §3.6) ──────────
+    # The NEW hard gate: a marker-bearing file the adapter RECOGNIZES but parses
+    # ZERO executable test blocks out of was silently degraded to a pass (only an
+    # UNSUPPORTED file should degrade). strict_observability=True (greenfield Gate 2)
+    # makes it an unobservable_test_structure violation — an unparseable test in a
+    # SUPPORTED stack is a false-green, not an unsupported one.
+    Contract(
+        id="authenticity.observable_in_supported_stack.v1",
+        source_node="TestFile",
+        target_node="TestBlock",
+        edge_type="claims",
+        dimensions=("authenticity", "observability", "parsing"),
+        authority="codd.vb_marker_authenticity.build_authenticity_report",
+        fail_mode="honest_red",
+        status="covered",
+        certification_fixtures=(
+            "tests/test_vb_marker_authenticity.py::test_strict_observability_flags_recognized_file_with_no_parseable_test",
+            "tests/test_vb_marker_authenticity.py::test_strict_observability_still_degrades_unsupported_stack",
+            "tests/test_vb_marker_authenticity.py::test_strict_observability_does_not_affect_genuine_covering_test",
+        ),
+        finding_ids=("PC-authenticity-observable", "F-verify-false-green"),
+    ),
     # ── Task -> GeneratedArtifact ownership / orphan prohibition (v2.29) ─────
     Contract(
         id="task.owns_generated_artifacts_no_orphans",
@@ -467,6 +489,30 @@ _COVERED: tuple[Contract, ...] = (
         ),
         finding_ids=("PC-verify-campaign-observable", "F-verify-false-green"),
     ),
+    # ── verify.campaign.clean_execution.v1 — the campaign result gates green ──
+    # The NEW hard gate (GPT r2 §3.2): build_coherence_report reconciles only the
+    # UNBLOCKED VBs against their covering files, so a FAILING test that covers no
+    # declared VB (a plain integration/e2e/unit test) — or a non-zero runner exit —
+    # was invisible to it and passed the coherence gate alone = a false-green.
+    # enforce_campaign_clean_execution makes the campaign's own result a green
+    # authority: any executed_failed_files, or exit_code != 0, is an honest-fail.
+    Contract(
+        id="verify.campaign.clean_execution.v1",
+        source_node="VerifyCampaign",
+        target_node="RunnerExecution",
+        edge_type="executes",
+        dimensions=("execution", "observability"),
+        authority="codd.coverage_execution_coherence.enforce_campaign_clean_execution",
+        fail_mode="honest_fail",
+        status="covered",
+        certification_fixtures=(
+            "tests/test_coverage_execution_coherence.py::test_clean_execution_failed_file_raises",
+            "tests/test_coverage_execution_coherence.py::test_clean_execution_nonzero_exit_raises",
+            "tests/test_coverage_execution_coherence.py::test_clean_execution_all_pass_exit_zero_is_ok",
+            "tests/test_coverage_execution_coherence.py::test_clean_execution_closes_false_green_for_failing_non_vb_test",
+        ),
+        finding_ids=("PC-campaign-clean-execution", "F-verify-false-green"),
+    ),
     # ── CoverageClaim -> VerifyExecution observability (v2.32) ───────────────
     Contract(
         id="coverage_claim.requires_executed_passed_evidence",
@@ -674,30 +720,6 @@ _OUTER: tuple[Contract, ...] = (
 # ════════════════════════════════════════════════════════════════════════════
 
 _UNCOVERED_PRECISE: tuple[Contract, ...] = (
-    # GPT r2 §3.2 — campaign exit_code / failed non-VB tests.
-    Contract(
-        id="verify.campaign.clean_execution.v1",
-        source_node="VerifyCampaign",
-        target_node="RunnerExecution",
-        edge_type="executes",
-        dimensions=("execution", "observability"),
-        authority=None,
-        fail_mode="honest_fail",
-        status="uncovered",
-        predicted_issue=(
-            "run_verify_campaign keeps CampaignRun.exit_code but does NOT treat it "
-            "as pass authority, and build_coherence_report only checks the UNBLOCKED "
-            "VBs' covering files — so a non-VB e2e/integration test that FAILED "
-            "(run.execution.executed_failed_files non-empty, or exit_code != 0) can "
-            "still pass the coherence gate alone."
-        ),
-        proposed_gate=(
-            "enforce_campaign_clean_execution(run.execution, run.exit_code) around "
-            "build_coherence_report: exit_code != 0 OR executed_failed_files → "
-            "CoherenceError. negative fixture: a vitest JSON report with a failed "
-            "tests/e2e/non_vb.e2e.test.ts while every VB covering file passed → hard red."
-        ),
-    ),
     # GPT r2 §3.5 — LayoutProfile scaffold-config certification.
     Contract(
         id="scaffold.config_certified_before_verify.v1",
@@ -724,31 +746,6 @@ _UNCOVERED_PRECISE: tuple[Contract, ...] = (
             "not deferred to the campaign."
         ),
     ),
-    # GPT r2 §3.6 — recognized test file → parseable TestBlock authenticity strict.
-    Contract(
-        id="authenticity.observable_in_supported_stack.v1",
-        source_node="TestFile",
-        target_node="TestBlock",
-        edge_type="claims",
-        dimensions=("authenticity", "observability", "parsing"),
-        authority=None,
-        fail_mode="honest_red",
-        status="uncovered",
-        predicted_issue=(
-            "build_authenticity_report puts a marker-bearing recognized test file "
-            "into degraded_paths (skips Stage 2/3) when the adapter handles the file "
-            "but parses NO blocks; report.passed only checks violations — so a "
-            "supported-stack (TS/Python) test whose wrapper the parser cannot read "
-            "is 'authenticity unknown' yet can degrade-pass."
-        ),
-        proposed_gate=(
-            "strict_authenticity_observability=True greenfield default: when adapter "
-            "handles the file AND markers present AND no blocks parsed → "
-            "violation(kind='unobservable_test_structure'); unknown languages stay "
-            "warn/degrade. negative fixture: tests/foo.test.ts with covers vb=VB-1 "
-            "in a wrapper the parser does not recognize → red (today degrades to pass)."
-        ),
-    ),
     # GPT r2 §3.7 — Python source/test import coherence implement-time oracle.
     Contract(
         id="python.import_coherence_oracle.v1",

{codd_dev-2.38.0 → codd_dev-2.40.0}/codd/coverage_execution_coherence.py

@@ -892,9 +892,10 @@ def run_verify_campaign(
     adapter. ANTI-FALSE-GREEN: a campaign that produced NO report, an UNREADABLE
     report, or an empty-execution report (collected 0 tests) is a :class:`CampaignError`
     (a harness/observability failure), NEVER a silent pass. The command's own exit
-    code is captured but is NOT the pass authority — the coherence gate is (a
-    campaign may exit nonzero because a covering test failed, which the gate
-    reports per-VB).
+    code is captured AND consulted by ``enforce_campaign_clean_execution``
+    (contract verify.campaign.clean_execution.v1): a non-zero exit, or ANY failed
+    executed test file, hard-fails there — independent of the per-VB coherence
+    gate, which alone would miss a failing test that covers no declared VB.
 
     Caller contract: only invoke when ``profile.verify_campaign`` is not None and
     ``profile.runner_report_adapter()`` resolves. A None campaign/adapter is the
@@ -1025,6 +1026,52 @@ def certify_verify_campaign_observable(profile: Any) -> None:
         )
 
 
+def enforce_campaign_clean_execution(
+    execution: RunnerExecution,
+    exit_code: int,
+    *,
+    echo: Callable[[str], None] = print,
+) -> None:
+    """HARD GATE (contract verify.campaign.clean_execution.v1; GPT round-2 §3.2).
+
+    The verify campaign's OWN result is a green authority IN ITS OWN RIGHT —
+    independent of VB reconciliation. ``build_coherence_report`` only checks that
+    each UNBLOCKED VB has an authentic covering file that executed and passed; a
+    FAILING test that covers NO declared VB (a plain integration / e2e / unit
+    test), or a runner that exited NON-ZERO for a non-VB reason, is invisible to it
+    and would pass the coherence gate alone — a false-green. This gate closes that
+    hole.
+
+    Raises :class:`CoherenceError` when ``execution.executed_failed_files`` is
+    non-empty (ANY executed test file had a failing/erroring case) OR
+    ``exit_code != 0`` (the runner itself reported failure). Deterministic and
+    side-effect-free — it runs no command (the caller already executed the
+    campaign). honest-fail: a failing test, or a non-zero runner exit, means the
+    build is RED, never silently green.
+    """
+
+    failed = sorted(execution.executed_failed_files)
+    nonzero_exit = exit_code != 0
+    if not failed and not nonzero_exit:
+        return
+    reasons: list[str] = []
+    if failed:
+        shown = ", ".join(failed[:10]) + (" …" if len(failed) > 10 else "")
+        reasons.append(f"{len(failed)} executed test file(s) FAILED: {shown}")
+    if nonzero_exit:
+        reasons.append(f"the verify campaign exited non-zero ({exit_code})")
+    detail = "; ".join(reasons)
+    echo(f"[greenfield] verify: campaign clean-execution gate FAILED — {detail}")
+    raise CoherenceError(
+        "verify campaign did not execute cleanly: "
+        + detail
+        + ". A failing test — even one that covers no declared verifiable behavior "
+        "— or a non-zero runner exit means the build is RED. The campaign result is "
+        "itself a green authority, independent of per-VB reconciliation; fix the "
+        "failing test(s) (or the runner error) before the run can be green."
+    )
+
+
 def enforce_coverage_execution_coherence(
     project_root: Path | str,
     profile: Any,
@@ -1060,6 +1107,12 @@ def enforce_coverage_execution_coherence(
         )
 
     run = run_verify_campaign(project_root, profile, config=config, echo=echo)
+    # HARD anti-false-green gate (verify.campaign.clean_execution.v1): the
+    # campaign's OWN result gates green BEFORE VB reconciliation — a failing test
+    # that covers no declared VB, or a non-zero runner exit, is RED here even
+    # though build_coherence_report (which only reconciles UNBLOCKED VBs) would
+    # miss it.
+    enforce_campaign_clean_execution(run.execution, run.exit_code, echo=echo)
     report = build_coherence_report(
         project_root, config=config, profile=profile, execution=run.execution
     )
@@ -1115,6 +1168,7 @@ __all__ = [
     "build_test_inventory",
     "certify_verify_campaign_observable",
     "coherence_gate_applies",
+    "enforce_campaign_clean_execution",
     "enforce_coverage_execution_coherence",
     "format_coherence_feedback",
     "render_coherence_markdown",

{codd_dev-2.38.0 → codd_dev-2.40.0}/codd/greenfield/pipeline.py

@@ -2561,7 +2561,12 @@ def _enforce_stage_coverage_gate(
     # --- Gate 2: marker authenticity (anti-false-green). HARD gate. ---
     from codd.vb_marker_authenticity import build_authenticity_report
 
-    auth = build_authenticity_report(project_root, config=config, profile=authenticity_profile)
+    # strict_observability (authenticity.observable_in_supported_stack.v1): in the
+    # autopilot a SUPPORTED test file the adapter recognizes but parses no executable
+    # test block out of is a false-green, not a degrade — honest-fail it.
+    auth = build_authenticity_report(
+        project_root, config=config, profile=authenticity_profile, strict_observability=True
+    )
     if auth.degraded_paths:
         echo(
             "Test coverage gate: marker-authenticity attachment/assertion checks skipped for "
@@ -2574,8 +2579,9 @@ def _enforce_stage_coverage_gate(
         raise StageError(
             "verifiable-behavior marker-authenticity gate failed for the implement stage: "
             f"{len(auth.violations)} `codd: covers vb=` marker(s) are not credible coverage claims "
-            "(attached to a skipped/empty test, an orphan id, or a test with no assertion). A "
-            "covers marker must sit on an executable test that asserts the behavior."
+            "(attached to a skipped/empty test, an orphan id, a test with no assertion, or an "
+            "unobservable test structure — a recognized file with no parseable test). A covers "
+            "marker must sit on an executable test that asserts the behavior."
         )
     echo(
         f"Test coverage gate: marker authenticity OK ({len(auth.degraded_paths)} file(s) stage-1-only)."

{codd_dev-2.38.0 → codd_dev-2.40.0}/codd/vb_marker_authenticity.py

@@ -387,12 +387,22 @@ def build_authenticity_report(
     profile: Any = None,
     test_dirs: Iterable[Path | str] | None = None,
     hooks: Iterable[AuthenticityHook] | None = None,
+    strict_observability: bool = False,
 ) -> AuthenticityReport:
     """Evaluate every ``covers vb=`` marker for structural authenticity.
 
     ``profile`` is the active :class:`~codd.project_types.LayoutProfile` (or any
     object exposing ``test_block_profile()``); when it is ``None`` or yields no
     adapter, stages 2-3 degrade to a warning and only stage 1 (orphan) applies.
+
+    ``strict_observability`` (contract authenticity.observable_in_supported_stack.v1):
+    when True, a marker-bearing file the adapter RECOGNIZES (``handles_file``) but
+    from which it parses ZERO executable test blocks is an
+    ``unobservable_test_structure`` VIOLATION rather than a silent degrade — a
+    SUPPORTED stack that yields no observable test is a false-green, not an
+    unparseable one. An UNSUPPORTED file (no adapter / not handled) still degrades
+    in either mode (never a false-RED). The greenfield autopilot passes True; the
+    default is False for back-compat with non-autopilot callers.
     """
 
     project_root = Path(project_root).resolve()
@@ -451,13 +461,41 @@ def build_authenticity_report(
 
         # ── Stages 2-3 need the per-profile structural parse ──
         blocks: list[TestBlock] = []
-        if adapter is not None and adapter.handles_file(rel):
+        adapter_handles = adapter is not None and adapter.handles_file(rel)
+        if adapter_handles:
             try:
                 blocks = adapter.parse_test_blocks(text)
             except Exception:  # noqa: BLE001 — a parser that throws degrades, never fails.
                 blocks = []
-        if adapter is None or not adapter.handles_file(rel) or not blocks:
-            # Graceful degradation: cannot structurally parse this stack/file.
+        if not blocks:
+            if adapter_handles and strict_observability:
+                # OBSERVABILITY (contract authenticity.observable_in_supported_stack.v1):
+                # the adapter RECOGNIZES this file type but extracted ZERO executable
+                # test blocks though live coverage markers are present. That is NOT an
+                # unsupported stack (which legitimately degrades) — it is an
+                # unobservable coverage claim in a SUPPORTED stack, so it honest-fails
+                # instead of silently degrading to a pass (the false-green this
+                # contract closes).
+                for marker in live_markers:
+                    violations.append(
+                        AuthenticityViolation(
+                            kind="unobservable_test_structure",
+                            vb_id=marker.vb_id,
+                            path=rel,
+                            line=marker.line,
+                            message=(
+                                f"{rel}:{marker.line} `codd: covers vb={marker.vb_id}` sits in a "
+                                "recognized test file from which the structural parser extracted NO "
+                                "executable test block — the coverage claim is unobservable (a marker "
+                                "with no parseable test proves nothing). Write a real test case the "
+                                "runner executes, or use `codd: blocked vb=… reason=…` if it genuinely "
+                                "cannot run yet."
+                            ),
+                        )
+                    )
+                continue
+            # Graceful degradation: an UNSUPPORTED stack/file (no adapter, or the
+            # adapter does not handle this file), or strict observability off.
             # Stage 1 already ran; skip stages 2-3 with a warning (never false-RED).
             degraded.append(rel)
             continue

{codd_dev-2.38.0 → codd_dev-2.40.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "codd-dev"
-version = "2.38.0"
+version = "2.40.0"
 description = "CoDD: Coherence-Driven Development — cross-artifact change impact analysis"
 readme = "README.md"
 license = "MIT"