codd-dev 3.27.0__tar.gz → 3.29.0__tar.gz

{codd_dev-3.27.0 → codd_dev-3.29.0}/PKG-INFO

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

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "3.27.0"
+__version__ = "3.29.0"

{codd_dev-3.27.0 → codd_dev-3.29.0}/codd/greenfield/pipeline.py

@@ -4948,6 +4948,38 @@ def _drive_test_rederivation(
             feedback=feedback,
         )
 
+    def _oracle_check() -> Any:
+        """One-shot native-oracle run for transcription acceptance (rerun=None).
+
+        Best-effort: an oracle that cannot run here (unresolvable stack /
+        uncertifiable scope) returns ``None`` → the re-derivation degrades to its
+        prior behavior with the fresh verify as the backstop — never a new
+        failure mode, never a silent pass (verify still gates)."""
+        from codd.implement_oracle import run_implement_oracle_gate
+
+        project_section = (
+            config.get("project") if isinstance(config.get("project"), dict) else {}
+        )
+        scan = config.get("scan") if isinstance(config.get("scan"), dict) else {}
+        try:
+            return run_implement_oracle_gate(
+                project_root,
+                language=(
+                    project_section.get("language")
+                    if isinstance(project_section, dict)
+                    else None
+                ),
+                project_name=str(
+                    (project_section or {}).get("name") or project_root.name
+                ),
+                source_dirs=scan.get("source_dirs") if isinstance(scan, dict) else None,
+                test_dirs=scan.get("test_dirs") if isinstance(scan, dict) else None,
+                config=config,
+                echo=echo,
+            )
+        except Exception:  # noqa: BLE001 — best-effort acceptance probe.
+            return None
+
     budget_used: dict[str, int] = {}
     current = outcome
     any_ran = False
@@ -4963,6 +4995,7 @@ def _drive_test_rederivation(
             budget_used=budget_used,
             history_session_dir=getattr(outcome, "history_session_dir", None),
             trigger="T2" if getattr(current, "test_defect_claim", None) else "T1",
+            oracle_check=_oracle_check,
         )
 
         if rederived.status == STATUS_GREEN:

{codd_dev-3.27.0 → codd_dev-3.29.0}/codd/greenfield/test_rederivation.py

@@ -346,6 +346,7 @@ def run_test_rederivation(
     history_session_dir: Path | None = None,
     trigger: str = "",
     test_dirs: list[str] | None = None,
+    oracle_check: Callable[[], Any] | None = None,
 ) -> RederivationOutcome:
     """Re-derive the blocked test transcription(s) from the design, then fresh-verify.
 
@@ -438,21 +439,26 @@ def run_test_rederivation(
         f"{len(eligible_paths)} test file(s) from the design across {len(eligible_tasks)} "
         f"task(s); fenced to {len(allowed)} test path(s)."
     )
-    crash: Exception | None = None
-    with _OracleWriteFence(project_root, allowed_paths=allowed, echo=echo) as fence:
-        try:
-            for task in eligible_tasks:
-                implement_runner(task, REDERIVATION_FEEDBACK)
-            fence.enforce()
-        except Exception as exc:  # noqa: BLE001 — a crashed draw must NOT escape.
-            # CRASH CONTAINMENT (the honesty fix). A draw that raised (e.g. the
-            # implementer honestly emitting 0 files → an unhandled CoddCLIError, the
-            # F7 live crash) must never surface as a misleading stage crash. Roll the
-            # write-fence back to its ENTRY snapshot so a crashed draw leaves NO
-            # partial transcription (in- OR out-of-scope), then fall through to the
-            # honest RED terminal.
-            crash = exc
-            fence.rollback()
+    def _run_draw(feedback: str) -> Exception | None:
+        """One fenced re-derivation draw with CRASH CONTAINMENT (the honesty fix).
+
+        A draw that raised (e.g. the implementer honestly emitting 0 files → an
+        unhandled CoddCLIError, the F7 live crash) must never surface as a
+        misleading stage crash: the write-fence rolls back to its ENTRY snapshot
+        so a crashed draw leaves NO partial transcription (in- OR out-of-scope),
+        and the exception is RETURNED for the caller's honest RED terminal.
+        """
+        with _OracleWriteFence(project_root, allowed_paths=allowed, echo=echo) as fence:
+            try:
+                for task in eligible_tasks:
+                    implement_runner(task, feedback)
+                fence.enforce()
+            except Exception as exc:  # noqa: BLE001 — a crashed draw must NOT escape.
+                fence.rollback()
+                return exc
+        return None
+
+    crash = _run_draw(REDERIVATION_FEEDBACK)
 
     # Consume the budget for every re-driven task — a crash counts as a spent draw
     # (attempted == spent), so a crash cannot grant a re-roll. A second claim on the
@@ -483,6 +489,72 @@ def run_test_rederivation(
             reason=f"re-derivation draw crashed: {crash}",
         )
 
+    # NATIVE-ORACLE ACCEPTANCE — a transcription that fails the native oracle is
+    # not a transcription. The re-derived test must COMPILE before coverage /
+    # authenticity / fresh-verify mean anything (csharp3 exprcalc dogfood,
+    # 2026-07-11: T2 re-derived an immutability test that ASSIGNED to read-only
+    # properties — CS0200 — and the compile-red fresh verify was misread as "a
+    # real impl/design defect"). One diagnostics-informed completion retry
+    # belongs to the SAME draw: the budget above is already consumed and is NOT
+    # re-claimed (a retry is a completion, not a second claim). Still failing
+    # after the retry → an honest RED that NAMES the oracle. ``oracle_check`` is
+    # opt-in (None → prior behavior; the fresh verify stays the backstop).
+    if oracle_check is not None:
+        ora = oracle_check()
+        if ora is not None and _oracle_rejects_transcription(ora):
+            diag = "; ".join(
+                str(getattr(f, "message", "")).strip()
+                for f in _non_environment_findings(ora)[:6]
+                if str(getattr(f, "message", "")).strip()
+            )
+            echo(
+                "[greenfield] test re-derivation: the transcription failed the "
+                f"NATIVE ORACLE ({diag[:300] or 'no diagnostics'}); one "
+                "diagnostics-informed completion retry (same draw, no new budget)."
+            )
+            retry_feedback = (
+                REDERIVATION_FEEDBACK
+                + "\n\nNATIVE-ORACLE DIAGNOSTICS — the re-derived test file(s) do "
+                "not pass the toolchain (they must COMPILE). Fix the TEST "
+                "transcription only; the diagnostics are:\n"
+                + (diag or "(opaque toolchain failure)")
+            )
+            crash = _run_draw(retry_feedback)
+            _record_event(
+                history_session_dir,
+                trigger=f"{trigger}-oracle-retry" if trigger else "oracle-retry",
+                paths=eligible_paths,
+                tasks=eligible_task_ids,
+                old_hashes=new_hashes,
+                new_hashes={p: _file_hash(project_root / p) for p in eligible_paths},
+                error=str(crash) if crash is not None else None,
+            )
+            if crash is not None:
+                echo(
+                    "[greenfield] test re-derivation: the oracle-retry draw crashed "
+                    f"({crash}); the write-fence rolled back (no partial transcription)."
+                )
+                return RederivationOutcome(
+                    STATUS_RED, trigger=trigger, rederived_paths=eligible_paths,
+                    rederived_tasks=eligible_task_ids, skipped_paths=skipped,
+                    reason=f"re-derivation oracle-retry draw crashed: {crash}",
+                )
+            ora = oracle_check()
+            if ora is not None and _oracle_rejects_transcription(ora):
+                echo(
+                    "[greenfield] test re-derivation: the transcription STILL fails "
+                    "the native oracle after the retry — honest RED (an invalid "
+                    "transcription, not evidence of an impl/design defect)."
+                )
+                return RederivationOutcome(
+                    STATUS_RED, trigger=trigger, rederived_paths=eligible_paths,
+                    rederived_tasks=eligible_task_ids, skipped_paths=skipped,
+                    reason=(
+                        "re-derived test failed the native oracle after one retry "
+                        "(the transcription does not compile)"
+                    ),
+                )
+
     # The regenerated test file must pass the UNCHANGED implement-side gates (VB
     # marker-authenticity + coverage reconciliation) BEFORE verify runs — dropping a
     # disputed ``covers vb=`` marker fails the build here, not the gate.
@@ -516,6 +588,30 @@ def run_test_rederivation(
 
 # ── helpers ──────────────────────────────────────────────────────────────────
 
+def _non_environment_findings(ora: Any) -> list[Any]:
+    """The oracle findings that are SUT-fixable (not environment_build_error)."""
+    return [
+        f
+        for f in list(getattr(ora, "findings", ()) or ())
+        if str(getattr(f, "category", "") or "") != "environment_build_error"
+    ]
+
+
+def _oracle_rejects_transcription(ora: Any) -> bool:
+    """Whether a native-oracle result REJECTS the re-derived transcription.
+
+    Only a failed result carrying at least one NON-environment finding rejects:
+    an environment-only red (missing toolchain, opaque env failure — the
+    zero-infra clause) is never the transcription's fault, and a failed result
+    with no findings proves nothing about the test file. Both degrade to the
+    prior behavior (fresh verify stays the backstop) — anti-false-RED without a
+    false-green (verify still gates).
+    """
+    if bool(getattr(ora, "passed", True)):
+        return False
+    return bool(_non_environment_findings(ora))
+
+
 def _fence_allowed_paths(
     eligible_paths: list[str], test_dirs: list[str] | None, config: Mapping[str, Any] | None
 ) -> tuple[str, ...]:

{codd_dev-3.27.0 → codd_dev-3.29.0}/codd/languages/adapters/oracle_cpp.py

@@ -81,6 +81,7 @@ dependency edge runs gate → executor → adapters → leaf types, never back.
 
 from __future__ import annotations
 
+import dataclasses
 import re
 from pathlib import Path, PurePosixPath
 
@@ -494,8 +495,33 @@ def _parse_cpp_tool_output(
         m = _CPP_DIAG_LINE.match(line)
         if m is not None:
             severity = (m.group("severity") or "").strip().lower()
-            if severity in ("warning", "note"):
-                continue  # a warning/note is not a failure
+            if severity == "warning":
+                continue  # a warning is not a failure
+            if severity == "note":
+                # A positioned ``note:`` is CONTEXT for the PRECEDING error — the
+                # other side of a two-sided diagnostic (``previously defined
+                # here`` names the header a redefinition collides with; candidate
+                # sites for an overload miss). Attach it to the last finding's
+                # message and attribution so the repair feedback carries BOTH
+                # sides of the disagreement (cpp3 exprcalc dogfood, 2026-07-11:
+                # feedback saw only the .cpp side and oscillated). An orphan note
+                # (no preceding finding) stays noise — a note is never a failure
+                # of its own. Capped at 2 notes per finding (overload-candidate
+                # spam adds no repair signal past the first sites).
+                if findings and findings[-1].code.startswith("CPP_"):
+                    last = findings[-1]
+                    if last.message.count(": note: ") < 2:
+                        note_txt = (
+                            f"{m.group('path')}:{m.group('line')}: note: "
+                            f"{m.group('message').strip()}"
+                        )
+                        findings[-1] = dataclasses.replace(
+                            last, message=f"{last.message} [{note_txt}]"
+                        )
+                        rel_note = _cpp_rel_path(m.group("path"), project_root)
+                        if rel_note and rel_note not in failed_paths:
+                            failed_paths.append(rel_note)
+                continue
             classified = _classify_cpp_compiler_diagnostic(
                 severity, m.group("message").strip()
             )

{codd_dev-3.27.0 → codd_dev-3.29.0}/codd/vb_marker_authenticity.py

@@ -5861,10 +5861,15 @@ def _java_resolve_module(importer_rel: str, spec: str, project_root: Path) -> Pa
 #: helper like ``HarnessAssertions.assertSuccess`` is exactly this shape. A bare
 #: CALL (``assertSuccess(result, "14.0");``) never matches: it has no
 #: return-type-shaped token before it, and it ends in ``;`` rather than ``{``.
+#: The return type accepts a QUALIFIED / nested name (``Expr.Literal``,
+#: ``Map.Entry<K, V>``) — dot-separated identifier segments — not just a single
+#: identifier: a same-file helper returning a nested type was otherwise
+#: invisible, resolving as ``unresolved_helper`` and false-redding real
+#: delegated assertions (java3 exprcalc dogfood, 2026-07-11).
 _JAVA_METHOD_DEF_RE = re.compile(
     r"(?<![A-Za-z0-9_.])(?:(?:public|protected|private|static|final|synchronized|"
     r"abstract|default|native|strictfp)\s+)*"
-    r"[A-Za-z_][A-Za-z0-9_$]*(?:<[^;{}]*?>)?(?:\[\])*\s+"
+    r"[A-Za-z_][A-Za-z0-9_$]*(?:\.[A-Za-z_][A-Za-z0-9_$]*)*(?:<[^;{}]*?>)?(?:\[\])*\s+"
     r"(?P<name>[A-Za-z_][A-Za-z0-9_]*)\s*\((?P<params>[^;{}]*)\)"
     r"(?:\s*throws\s+[A-Za-z0-9_.,\s<>]+?)?\s*\{",
     re.DOTALL,

{codd_dev-3.27.0 → codd_dev-3.29.0}/pyproject.toml

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