codd-dev 2.56.0__tar.gz → 2.58.0__tar.gz

{codd_dev-2.56.0 → codd_dev-2.58.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.56.0
+Version: 2.58.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.56.0 → codd_dev-2.58.0}/codd/__init__.py

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "2.56.0"
+__version__ = "2.58.0"

{codd_dev-2.56.0 → codd_dev-2.58.0}/codd/greenfield/pipeline.py

@@ -633,6 +633,60 @@ class GreenfieldPipeline:
             raise StageError(f"plan --init failed: {exc}") from exc
         record["detail"] = f"{wave_count} wave(s)"
         record["waves"] = wave_count
+        self._enforce_greenfield_vb_plan_contract(project_root, options)
+
+    def _enforce_greenfield_vb_plan_contract(
+        self, project_root: Path, options: dict[str, Any]
+    ) -> None:
+        """Backstop: a greenfield run with the coverage gate ON must PLAN the canonical
+        VB registry doc (``test:test-strategy`` / ``docs/test/test_strategy.md``).
+
+        ``planner._ensure_canonical_vb_doc_planned`` force-injects it on the normal path;
+        this catches a custom ``plan_runner``, a hand-written wave_config, or any future
+        path that bypasses the injection. Deliberately NOT gated on
+        ``project_expects_vb_registry`` — that returns False in exactly the dangerous case
+        (AI omitted the canonical doc, no ``test_coverage.docs``, no file yet), which is the
+        hole this closes. Without the canonical doc the VB audit has zero declarations and
+        coverage trivially passes 0/0 (false-GREEN). Skipped when the coverage gate is
+        explicitly OFF (owner opt-out) or an explicit ``test_coverage.docs`` is pinned."""
+
+        from codd.config import load_project_config
+        from codd.verifiable_behavior_audit import (
+            coverage_gate_enabled,
+            load_verifiable_behaviors,
+            wave_config_plans_canonical_vb_doc,
+        )
+
+        if not bool(options.get("coverage_gate", True)):
+            return
+        try:
+            config = load_project_config(project_root)
+        except (FileNotFoundError, ValueError):
+            config = {}
+        if not coverage_gate_enabled(config):
+            return
+        section = config.get("test_coverage")
+        if isinstance(section, dict) and section.get("docs"):
+            return  # owner pinned an explicit VB doc — respect it
+        if wave_config_plans_canonical_vb_doc(config):
+            return  # the canonical VB doc is planned — SSOT will exist
+        # Not planned — but VBs may ALREADY be declared in a discoverable docs/test
+        # doc. The contract is "a VB SSOT must exist", satisfied by EITHER a planned
+        # canonical doc OR existing declarations. Only RED when NEITHER holds (e.g. a
+        # real greenfield at plan stage with no docs generated and no canonical planned).
+        try:
+            behaviors = load_verifiable_behaviors(project_root, config=config)
+        except Exception:  # noqa: BLE001 — discovery failure ⇒ fall through to the RED below.
+            behaviors = []
+        if behaviors:
+            return  # a VB surface already exists
+        raise StageError(
+            "greenfield coverage gate requires a verifiable-behavior SSOT: plan the canonical "
+            "VB registry document (test:test-strategy / docs/test/test_strategy.md) in wave_config "
+            "or declare VBs in a docs/test doc. Without it the declared-VB set is empty and the "
+            "coverage/authenticity gate can pass WITHOUT certifying any behavior (a false-green). "
+            "Disable the coverage gate explicitly if this build has no behaviors to verify."
+        )
 
     # ── stage: generate ─────────────────────────────────────
 
@@ -2397,6 +2451,26 @@ def _verify_task_contract(
         )
 
 
+def _declared_output_is_file_path(raw: str) -> bool:
+    """Whether a declared ``expected_outputs`` entry is an EXACT FILE PATH.
+
+    Only real file paths participate in declared-output-completeness; a SYMBOL
+    declaration (``Version.__str__``, ``Range.matches(version)``, ``module:range``)
+    is left to the kind check. The old test — ``PurePosixPath(out).suffix`` non-empty
+    — mis-classified symbols as files because a dotted symbol has a "suffix"
+    (``.__str__`` / ``.matches(version)``), producing spurious WARNs (and a latent
+    false-RED under ``enforce``). A real path has a ``/`` OR a plausible file
+    extension (short + alphanumeric, e.g. ``.py`` / ``.yaml``)."""
+
+    s = raw.strip().replace("\\", "/").strip("/")
+    if not s:
+        return False
+    if "/" in s:
+        return True
+    ext = PurePosixPath(s).suffix[1:]  # drop the leading dot
+    return bool(ext) and len(ext) <= 6 and ext.isalnum()
+
+
 def _check_declared_output_completeness(
     task: ImplementTaskRef,
     results: list[Any],
@@ -2424,7 +2498,7 @@ def _check_declared_output_completeness(
     declared_files = [
         str(out).strip().replace("\\", "/").strip("/")
         for out in task.expected_outputs
-        if str(out).strip() and PurePosixPath(str(out).strip()).suffix
+        if _declared_output_is_file_path(str(out))
     ]
     if not declared_files:
         return

{codd_dev-2.56.0 → codd_dev-2.58.0}/codd/planner.py

@@ -424,6 +424,12 @@ def plan_init(
     wave_config = _invoke_and_parse_wave_config(
         resolved_ai_command, prompt, max_retries=_plan_init_max_retries(config)
     )
+    if requirement_documents:
+        # Greenfield: GUARANTEE the canonical VB registry doc is planned so the VB
+        # coverage/authenticity SSOT is never silently absent (false-GREEN: 0/0 pass).
+        wave_config = _ensure_canonical_vb_doc_planned(
+            config, wave_config, requirement_documents
+        )
 
     from codd.config import find_codd_dir
     config["wave_config"] = wave_config
@@ -491,6 +497,79 @@ def _set_canonical_vb_doc_config(
     config["test_coverage"] = section
 
 
+def _ensure_canonical_vb_doc_planned(
+    config: dict[str, Any],
+    wave_config: dict[str, Any],
+    requirement_documents: list[RequirementDocument],
+) -> dict[str, Any]:
+    """GUARANTEE the canonical VB registry doc is planned (greenfield VB SSOT).
+
+    The AI's wave_config can omit ``test:test-strategy`` / ``docs/test/test_strategy.md``
+    non-deterministically; without it the VB audit has ZERO declarations and the coverage
+    gate trivially passes 0/0 — a false-GREEN (the requirements' behaviors are never
+    certified). When the canonical doc is absent — and the owner has NOT pinned an explicit
+    ``test_coverage.docs`` — append it as a FINAL wave (so existing wave order/dependencies
+    are untouched) depending on the requirement docs + every already-planned artifact, so it
+    is generated last with full context. ``_set_canonical_vb_doc_config`` then detects+pins
+    it as usual (this stays the force-INJECT step; that one stays detection-only). Generic:
+    keys off the canonical naming, not any project's specifics.
+    """
+
+    from codd.verifiable_behavior_audit import (
+        coverage_gate_enabled,
+        wave_config_plans_canonical_vb_doc,
+    )
+
+    if not coverage_gate_enabled(config):
+        return wave_config  # coverage gate off (owner opt-out) — no VB SSOT needed
+    if wave_config_plans_canonical_vb_doc({"wave_config": wave_config}):
+        return wave_config  # the AI already planned it — nothing to do
+    section = config.get("test_coverage")
+    if isinstance(section, dict) and section.get("docs"):
+        return wave_config  # respect an explicit owner-pinned VB doc
+
+    out = deepcopy(wave_config)
+    new_wave = str(_max_wave_number(out) + 1)
+    existing_node_ids: list[str] = []
+    modules: set[str] = set()
+    for entries in out.values():
+        if not isinstance(entries, list):
+            continue
+        for entry in entries:
+            if not isinstance(entry, dict):
+                continue
+            node_id = entry.get("node_id") or entry.get("id")
+            if isinstance(node_id, str) and node_id.strip():
+                existing_node_ids.append(node_id.strip())
+            for module in entry.get("modules") or []:
+                if isinstance(module, str) and module.strip():
+                    modules.add(module.strip())
+
+    depends_on: list[dict[str, str]] = [
+        {"id": doc.node_id, "relation": "derives_from", "semantic": "governance"}
+        for doc in requirement_documents
+        if getattr(doc, "node_id", None)
+    ]
+    depends_on.extend(
+        {"id": node_id, "relation": "depends_on", "semantic": "verification"}
+        for node_id in existing_node_ids
+    )
+
+    out.setdefault(new_wave, [])
+    if isinstance(out[new_wave], list):
+        out[new_wave].append(
+            {
+                "node_id": "test:test-strategy",
+                "output": "docs/test/test_strategy.md",
+                "title": "Test Strategy and Verifiable Behavior Registry",
+                "depends_on": depends_on,
+                "conventions": [],
+                "modules": sorted(modules),
+            }
+        )
+    return {key: out[key] for key in sorted(out, key=_wave_key_sort_value)}
+
+
 def _ensure_lexicon(project_root: Path) -> None:
     """Create an inferred draft project_lexicon.yaml when plan --init starts without one."""
     from codd.lexicon import LEXICON_FILENAME

{codd_dev-2.56.0 → codd_dev-2.58.0}/pyproject.toml

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