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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.39.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.39.0 → codd_dev-2.40.0}/codd/__init__.py

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

{codd_dev-2.39.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",
@@ -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.39.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.39.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.39.0 → codd_dev-2.40.0}/pyproject.toml

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