codd-dev 3.30.0__tar.gz → 3.31.0__tar.gz

{codd_dev-3.30.0 → codd_dev-3.31.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 3.30.0
+Version: 3.31.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.30.0 → codd_dev-3.31.0}/codd/__init__.py

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "3.30.0"
+__version__ = "3.31.0"

{codd_dev-3.30.0 → codd_dev-3.31.0}/codd/dag/checks/source_completeness.py

@@ -9,10 +9,17 @@ discovery gap and a false-green risk). This is the first-class,
 The two share the pure :func:`codd.dag.builder.compute_source_completeness`, so
 the advisory and the check can never drift.
 
-Severity is fixed ``amber`` and ``block_deploy`` is fixed ``False`` — surfacing
-only. Promoting the gap to a red / deploy-blocking gate (e.g. via a tolerance
-threshold) is a NEW gate and therefore owner-gated; it is intentionally NOT done
-here (see the ``block_deploy`` note in :class:`SourceCompletenessResult`).
+Severity is ``amber`` (surfacing) up to the RED-ESCALATION thresholds granted by
+the Fable5 ruling of 2026-07-11 (the previously owner-gated promotion): when the
+gap is SYSTEMIC — ``missing >= red_min_missing`` (default 5, the small-project
+ratio-spike guard) AND ``missing/on_disk >= red_min_ratio`` (default 0.5) — the
+check escalates to red / deploy-blocking. The defaults are DATA-DERIVED from the
+②-green dogfood fleet's healthy measurements (max observed healthy state:
+java 10 missing / 31 on disk = 32.3%, where the toolchain still executes the
+inert files — a bookkeeping gap, not an execution gap), so the shipped values
+never hit a measured-healthy project (F5). Knobs:
+``dag.source_completeness.red_min_missing`` / ``red_min_ratio`` — either set to
+0 disables the escalation (prior amber-only behavior).
 
 Generality: the check carries no ``language ==`` / framework literal. The set of
 "source" suffixes is DATA (``implementation_suffixes`` / ``test_suffixes`` from
@@ -38,10 +45,10 @@ class SourceCompletenessResult:
     findings: list[str] = field(default_factory=list)
     message: str = ""
     passed: bool = True
-    # ``block_deploy`` is fixed ``False``: a source-scope gap is advisory (amber),
-    # never a deploy gate. Promoting it to red (e.g. a "> N missing files fails"
-    # threshold) introduces a NEW gate, which is owner-gated and deliberately out
-    # of scope here.
+    # ``block_deploy`` defaults ``False`` (amber, advisory). The red escalation
+    # (Fable5 ruling 2026-07-11 — the previously owner-gated promotion) sets it
+    # ``True`` only when the gap is systemic: missing >= red_min_missing AND
+    # missing/on_disk >= red_min_ratio (both data-derived; see module docstring).
     block_deploy: bool = False
     # ``status``/``skipped``/``checked_count`` mirror ``transitive_closure`` and
     # close the vacuous-pass hole: when no source file exists on disk the check
@@ -110,12 +117,55 @@ class SourceCompletenessCheck:
 
         if report.on_disk > report.node_count and report.missing:
             examples = ", ".join(report.missing[:5])
+            missing_count = len(report.missing)
             message = (
                 f"{report.on_disk} source file(s) on disk but only {report.node_count} "
-                f"source node(s) in the DAG — {len(report.missing)} file(s) are outside the "
+                f"source node(s) in the DAG — {missing_count} file(s) are outside the "
                 f"configured source scope and will be inert (e.g. {examples}). Consider "
                 f"widening source_dirs / impl_file_patterns."
             )
+
+            # RED ESCALATION (Fable5 ruling 2026-07-11): a SYSTEMIC discovery gap
+            # — both the absolute floor and the ratio must hold — fails the check
+            # and blocks deploy. Data-derived defaults (healthy ②-green max:
+            # 10/31 = 32.3%): missing >= 5 AND ratio >= 0.5. Either knob at 0
+            # disables (prior amber-only behavior).
+            esc_raw = effective_settings.get("source_completeness") if isinstance(effective_settings, dict) else None
+            esc = esc_raw if isinstance(esc_raw, dict) else {}
+            try:
+                red_min_missing = int(esc.get("red_min_missing", 5) or 0)
+            except (TypeError, ValueError):
+                red_min_missing = 5
+            try:
+                red_min_ratio = float(esc.get("red_min_ratio", 0.5) or 0.0)
+            except (TypeError, ValueError):
+                red_min_ratio = 0.5
+            ratio = missing_count / report.on_disk
+            if (
+                red_min_missing > 0
+                and red_min_ratio > 0
+                and missing_count >= red_min_missing
+                and ratio >= red_min_ratio
+            ):
+                message += (
+                    f" RED escalation: {missing_count} missing >= {red_min_missing} and "
+                    f"{ratio:.0%} of on-disk source is outside the DAG's scope "
+                    f">= {red_min_ratio:.0%} — a systemic discovery gap "
+                    f"(dag.source_completeness.red_min_missing / red_min_ratio)."
+                )
+                return SourceCompletenessResult(
+                    severity="red",
+                    findings=list(report.missing),
+                    message=message,
+                    passed=False,
+                    block_deploy=True,
+                    status="fail",
+                    skipped=False,
+                    checked_count=report.on_disk,
+                    on_disk=report.on_disk,
+                    node_count=report.node_count,
+                )
+
             return SourceCompletenessResult(
                 findings=list(report.missing),
                 message=message,

{codd_dev-3.30.0 → codd_dev-3.31.0}/codd/generator.py

@@ -296,7 +296,22 @@ def _resolve_layout_placement_contract(
             config=config,
             project_root=project_root,
         )
-        return render_layout_placement_contract(profile)
+        placement = render_layout_placement_contract(profile)
+        # NAMESPACE-coherence contract (profile-declared, {package_name}
+        # substituted) rides the same pre-rendered string: the design docs are
+        # where a namespace convention is first written down, so pinning it at
+        # GENERATE prevents the split the implement-stage oracle would otherwise
+        # only catch after the fact (csharp4 exprcalc dogfood, 2026-07-11).
+        # ""/None for every profile that doesn't declare it.
+        from codd.languages import resolve_namespace_guidance
+
+        namespace = resolve_namespace_guidance(
+            project.get("language") if isinstance(project, dict) else None,
+            package_name=getattr(profile, "package_name", None),
+        )
+        if namespace:
+            return f"{placement}\n\n{namespace}" if placement else namespace
+        return placement
     except Exception:  # noqa: BLE001 — a projection failure must never break generation.
         return ""
 

{codd_dev-3.30.0 → codd_dev-3.31.0}/codd/implementer.py

@@ -2712,6 +2712,21 @@ def _build_implementation_prompt(
                 project_root=project_root,
             )
             layout_block = render_import_coherence_contract(layout_profile)
+            # NAMESPACE-coherence contract (profile-declared, {package_name}
+            # substituted) — pins the first-party namespace convention so
+            # independently-generated files cannot split on it (the native
+            # oracle is the enforcing gate; csharp4 exprcalc dogfood 2026-07-11:
+            # a namespace segment sharing a type's name shadowed the type →
+            # CS0234 ×34). None/"" for every profile that doesn't declare it.
+            from codd.languages import resolve_namespace_guidance
+
+            namespace_block = (
+                resolve_namespace_guidance(
+                    language,
+                    package_name=getattr(layout_profile, "package_name", None),
+                )
+                or ""
+            )
             # LAYOUT-PLACEMENT CONTRACT (2026-07-04): project the harness-owned
             # test-root / source-root / scaffold-owned-config topology onto the
             # SAME prompt, read from the SAME LayoutProfile. Complements the
@@ -2724,10 +2739,13 @@ def _build_implementation_prompt(
         except Exception:  # noqa: BLE001 — a projection failure must never break generation.
             layout_block = ""
             placement_block = ""
+            namespace_block = ""
         if layout_block:
             lines.extend([layout_block, ""])
         if placement_block:
             lines.extend([placement_block, ""])
+        if namespace_block:
+            lines.extend([namespace_block, ""])
 
     if _spec_targets_tests(spec, config):
         test_framework = resolve_test_framework_guidance(language)

{codd_dev-3.30.0 → codd_dev-3.31.0}/codd/languages/__init__.py

@@ -53,6 +53,7 @@ from .contract import (
     ResolvedLanguageContract,
     build_language_contract,
     resolve_assertion_guidance,
+    resolve_namespace_guidance,
     resolve_language_contract,
     resolve_language_profile,
     resolve_test_framework_guidance,
@@ -115,6 +116,7 @@ __all__ = [
     "resolve_language_profile",
     "resolve_test_framework_guidance",
     "resolve_assertion_guidance",
+    "resolve_namespace_guidance",
     # verify run plan + semantic classifier (v2.69a, shadow)
     "ShadowComparison",
     "VerifyClass",

{codd_dev-3.30.0 → codd_dev-3.31.0}/codd/languages/contract.py

@@ -328,6 +328,50 @@ def resolve_assertion_guidance(
     return profile.tests.assertion_guidance
 
 
+def resolve_namespace_guidance(
+    project_language: str | None,
+    *,
+    package_name: str | None = None,
+    registry: LanguageRegistry | None = None,
+) -> str | None:
+    """The optional per-language first-party NAMESPACE-coherence guidance.
+
+    Same convenience-seam contract as :func:`resolve_test_framework_guidance`
+    (an already-resolved language string, best-effort, never raises). Reads the
+    profile's ``imports.namespace_guidance`` prose from the raw view (the
+    ImportsSpec dataclass models resolver/first-party fields only; ``raw`` is
+    the documented later-phase escape hatch) and substitutes ``{package_name}``
+    when supplied. Returns ``None`` when the language is unknown or the profile
+    has not declared the field — callers MUST treat ``None`` as "append
+    nothing" (prior behavior). The enforcing gate for this contract is the
+    NATIVE ORACLE (a namespace-convention split between independently-generated
+    files fails the toolchain — csharp exprcalc dogfood, 2026-07-11: a
+    namespace segment sharing a TYPE's name shadowed the type under
+    ``using <root>;`` and every call failed CS0234); this seam states the
+    contract the gate already enforces, so prompt and gate cannot drift.
+    """
+    if not project_language:
+        return None
+    lang_registry = registry if registry is not None else default_registry
+    try:
+        profile = lang_registry.resolve(project_language)
+    except UnknownLanguageError:
+        return None
+    raw = getattr(profile, "raw", None)
+    text: str | None = None
+    if isinstance(raw, Mapping):
+        imports = raw.get("imports")
+        if isinstance(imports, Mapping):
+            declared = imports.get("namespace_guidance")
+            if isinstance(declared, str) and declared.strip():
+                text = declared.strip()
+    if not text:
+        return None
+    if package_name:
+        text = text.replace("{package_name}", str(package_name))
+    return text
+
+
 def resolve_language_contract(
     config: Mapping[str, Any] | None,
     *,

{codd_dev-3.30.0 → codd_dev-3.31.0}/codd/languages/profiles/csharp.yaml

@@ -139,6 +139,23 @@ imports:
     rule: root_namespace_prefix
     base: "src"
 
+  # First-party NAMESPACE-coherence contract, projected onto generation/implement
+  # prompts via resolve_namespace_guidance ({package_name} substituted). The
+  # enforcing gate is the native oracle: independently-generated files that split
+  # on the namespace convention fail `dotnet build` (csharp4 exprcalc dogfood,
+  # 2026-07-11 — `namespace ExprCalc.Evaluator; public static class Evaluator`
+  # made the type unreachable as `Evaluator.Evaluate(...)` under
+  # `using ExprCalc;`: the identifier resolved to the NAMESPACE → CS0234 ×34).
+  namespace_guidance: |
+    NAMESPACE COHERENCE (release-blocking — the native build enforces this):
+    every first-party file MUST declare exactly `namespace {package_name};`
+    (file-scoped). Do NOT create sub-namespaces (`{package_name}.<Segment>`).
+    In particular, a namespace segment must NEVER share a declared TYPE's name
+    (e.g. `namespace {package_name}.Evaluator` containing `class Evaluator`):
+    under `using {package_name};` the identifier resolves to the NAMESPACE and
+    shadows the type, so every call site fails to compile (CS0234), and files
+    that disagree on the namespace convention cannot reference each other.
+
   stdlib:
     classifier: adapter
 

{codd_dev-3.30.0 → codd_dev-3.31.0}/pyproject.toml

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