codd-dev 2.87.0__tar.gz → 2.89.0__tar.gz

{codd_dev-2.87.0 → codd_dev-2.89.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.87.0
+Version: 2.89.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.87.0 → codd_dev-2.89.0}/codd/__init__.py

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "2.87.0"
+__version__ = "2.89.0"

{codd_dev-2.87.0 → codd_dev-2.89.0}/codd/cli.py

@@ -5023,6 +5023,13 @@ def verify(
         if not runtime:
             return
 
+    # Stack contract intake (Contract Kernel v2.77a) — bring the project's declared
+    # framework-stack contract into the live verify run's trace, mirroring the
+    # greenfield intake. INTAKE ONLY: no obligation is enforced and NO verdict
+    # changes (that is v2.77b-e). A project with no `stack:` block is unaffected; a
+    # declared-but-broken stack fails HONESTLY (anti-false-green), never a silent skip.
+    _intake_stack_contract_for_verify(Path(path).resolve())
+
     verify_kwargs: dict[str, Any] = {"path": path, "prefer_standalone": True}
     if runtime_skip:
         verify_kwargs["runtime_skip"] = runtime_skip
@@ -7591,6 +7598,43 @@ def _load_optional_project_config(project_root: Path) -> dict[str, Any]:
         return {}
 
 
+def _intake_stack_contract_for_verify(project_root: Path) -> None:
+    """Resolve the project's declared stack contract into the verify run trace.
+
+    Contract Kernel v2.77a (intake only) — the verify-path mirror of the greenfield
+    pipeline's :meth:`GreenfieldPipeline._intake_stack_contract`. Proves the
+    framework-stack contract is LIVE-consumed by the verify path (the hash enters
+    the run trace), WITHOUT enforcing any obligation or changing the verify verdict
+    (obligation enforcement is v2.77b-e).
+
+    * No ``stack:`` block → no-op (the opt-in framework layer is unused; the vast
+      majority of projects — emits a single trace line, no behaviour change).
+    * A declared stack → its ``stack_contract_hash`` is echoed to the run trace.
+    * A declared-but-BROKEN stack → honest failure (``SystemExit`` non-zero), never
+      a silent skip (anti-false-green / no-silent-fallback).
+    """
+    from codd.stack.project import stack_contract_intake, stack_contract_trace
+
+    try:
+        contract = stack_contract_intake(project_root)
+    except Exception as exc:  # noqa: BLE001 — a declared-but-broken stack must fail HONESTLY.
+        click.echo(
+            "stack contract intake failed: the project declares a `stack:` block in "
+            f"codd.yaml but it could not be resolved ({type(exc).__name__}: {exc}). "
+            "A declared-but-unresolvable stack is an honest error, never a silent skip.",
+            err=True,
+        )
+        raise SystemExit(1) from exc
+
+    if contract is None:
+        return
+    trace = stack_contract_trace(contract)
+    click.echo(
+        f"[verify] stack contract intake: {trace['resolved_stack_id']} "
+        f"stack_contract_hash={trace['stack_contract_hash']}"
+    )
+
+
 def _run_verify_once(
     path: str,
     *,

{codd_dev-2.87.0 → codd_dev-2.89.0}/codd/e2e_harness.py

@@ -40,6 +40,7 @@ from collections.abc import Mapping
 from dataclasses import dataclass
 from typing import Any, Literal
 
+from codd.parsing.regex_strategies import language_extensions
 from codd.project_types import ProjectCapabilities
 
 
@@ -234,7 +235,11 @@ def resolve_e2e_harness(
     """
 
     lang = (project_language or "").strip().lower()
-    is_python = lang == "python"
+    # "host language is Python" is driven from the language's declared source
+    # extensions (registry DATA: ``regex_strategies.language_extensions`` is
+    # canonical-keyed — it does NOT resolve aliases — so this is byte-identical
+    # to the former ``lang == "python"``), not a language-name branch in core.
+    is_python = ".py" in language_extensions(lang)
     modality = capabilities.e2e_modality
 
     if modality == "cli":

{codd_dev-2.87.0 → codd_dev-2.89.0}/codd/greenfield/pipeline.py

@@ -440,6 +440,26 @@ class GreenfieldPipeline:
 
         self._notify(options, f"greenfield start: {project_root.name}")
 
+        # Stack contract intake (Contract Kernel v2.77a) — bring the project's
+        # declared framework-stack contract into the LIVE run (in the run record +
+        # trace) so the framework layer is consumed by production, not only tests.
+        # INTAKE ONLY: no obligation is enforced here and NO verdict changes (that
+        # is v2.77b-e). A project with no ``stack:`` block is byte-identical (the
+        # opt-in framework layer is unused). A declared-but-broken stack is an
+        # HONEST failure (anti-false-green), never a silent skip. Done once, early,
+        # before the stage loop, so the hash covers the whole run. Routed through
+        # _fail (like every stage) so the autopilot REPORTS the honest error via a
+        # failed GreenfieldResult instead of raising to the caller. Its own
+        # pseudo-stage name (not a real STAGES entry) so the failure is attributed
+        # honestly to intake, not to ``init``.
+        try:
+            self._intake_stack_contract(project_root, session)
+        except StageError as exc:
+            return self._fail(
+                project_root, session, options, "stack_intake",
+                {"status": STATUS_PENDING, "detail": ""}, str(exc),
+            )
+
         runners: dict[str, Callable[[Path, dict[str, Any], dict[str, Any]], None]] = {
             "init": self._stage_init,
             "elicit": self._stage_elicit,
@@ -522,6 +542,51 @@ class GreenfieldPipeline:
         self._notify(options, f"greenfield {project_root.name}: FAILED at {stage_name} — {error}")
         return result
 
+    # ── stack contract intake (Contract Kernel v2.77a, intake only) ──
+
+    def _intake_stack_contract(self, project_root: Path, session: dict[str, Any]) -> None:
+        """Resolve the project's declared stack contract into the live run record + trace.
+
+        See the call site in :meth:`run`. INTAKE ONLY — proves the framework-stack
+        contract is LIVE-consumed (it enters the run record and the trace); it does
+        NOT enforce any obligation and does NOT change any pass/fail verdict
+        (obligation enforcement is v2.77b-e).
+
+        * No ``stack:`` block → no-op: nothing is added to the record and only a
+          single debug ``self.echo`` is emitted, so a non-stack project (the vast
+          majority) is behaviour-preserving.
+        * A declared stack → its :func:`stack_contract_trace` payload (incl.
+          ``stack_contract_hash``) is written to ``session["stack_contract"]`` and
+          echoed to the run trace.
+        * A declared-but-BROKEN stack → :class:`StageError` (honest error), never a
+          silent skip (anti-false-green / no-silent-fallback).
+        """
+        from codd.stack.project import stack_contract_intake, stack_contract_trace
+
+        try:
+            contract = stack_contract_intake(project_root)
+        except Exception as exc:  # noqa: BLE001 — a declared-but-broken stack must fail HONESTLY.
+            raise StageError(
+                "stack contract intake failed: the project declares a `stack:` block in "
+                f"codd.yaml but it could not be resolved ({type(exc).__name__}: {exc}). "
+                "A declared-but-unresolvable stack is an honest error, never a silent skip "
+                "(check the language / frameworks / addons ids against the curated stack "
+                "profiles, or remove the `stack:` block to opt out of the framework layer)."
+            ) from exc
+
+        if contract is None:
+            # The opt-in framework layer is unused — byte-identical behaviour.
+            self.echo("[greenfield] stack contract intake: no `stack:` block (framework layer opt-out)")
+            return
+
+        trace = stack_contract_trace(contract)
+        session["stack_contract"] = dict(trace)
+        self.echo(
+            "[greenfield] stack contract intake: "
+            f"{trace['resolved_stack_id']} "
+            f"stack_contract_hash={trace['stack_contract_hash']}"
+        )
+
     # ── option resolution ───────────────────────────────────
 
     def _resolve_options(self, project_root: Path) -> dict[str, Any]:

{codd_dev-2.87.0 → codd_dev-2.89.0}/codd/implementer.py

@@ -747,7 +747,10 @@ def _confusable_code_error(relative_path: str, content: str, *, language: str) -
     deterministic, no LLM calls.
     """
     suffix = PurePosixPath(relative_path).suffix.lower()
-    is_python = suffix == ".py" or (suffix == "" and language == "python")
+    # "is this a Python payload" is driven from the language's declared
+    # extensions (DATA), not a ``language == "python"`` branch: a .py suffix, or
+    # an extensionless payload whose language declares .py as a source extension.
+    is_python = suffix == ".py" or (suffix == "" and ".py" in _implementation_language_extensions(language))
     if not is_python:
         return None
     findings = _confusable_findings(content)
@@ -1754,7 +1757,7 @@ def _candidate_generated_paths(spec: ImplementSpec, language: Any, design_conten
         candidates.append(PurePosixPath(output_path) / f"index{default_extension}")
 
     normalized_language = _normalize_implementation_language(language)
-    if normalized_language in {"typescript", "javascript"} and _spec_looks_ui_facing(spec, design_content):
+    if _ui_variant_extension(normalized_language) is not None and _spec_looks_ui_facing(spec, design_content):
         extensions = _implementation_language_extensions(normalized_language)
         if len(extensions) > 1:
             for output_path in spec.output_paths:
@@ -1883,7 +1886,7 @@ def _build_implementation_prompt(
     else:
         framework_guidance = f"- Use idiomatic {language_name} patterns for the target project."
 
-    if language in {"typescript", "javascript"} and len(preferred_extensions) > 1:
+    if _ui_variant_extension(language) is not None and len(preferred_extensions) > 1:
         jsx_extension = preferred_extensions[1]
         extension_guidance = (
             f"- If the work needs JSX-style UI components, emit {jsx_extension} files. "
@@ -2581,10 +2584,41 @@ def _implementation_language_extensions(language: Any) -> tuple[str, ...]:
     return LANGUAGE_EXT_MAP.get(normalized, LANGUAGE_EXT_MAP["typescript"])
 
 
+#: Registry DATA (Contract Kernel Cut Condition A — implementer.py): the SECOND
+#: extension some language families carry is a JSX/UI-COMPONENT variant
+#: (TypeScript's ``.tsx``, JavaScript's ``.jsx``) rather than just "another file
+#: type" (e.g. C++'s ``.cc``/``.h``). Only a family whose alt extension is a UI
+#: variant should route UI-facing work to ``extensions[1]``. This is a
+#: language→capability DATA table (the analogue of a profile/registry entry — a
+#: declared capability, NOT a core ``language in (...)`` branch); core code asks
+#: ``_ui_variant_extension(language) is not None`` (a capability flag), never a
+#: language name. Byte-identical to the former ``in {"typescript","javascript"}``
+#: guards: those two families are exactly the ones whose ``extensions[1]`` is the
+#: UI/JSX variant.
+_UI_VARIANT_EXTENSION_BY_LANGUAGE: dict[str, str] = {
+    "typescript": ".tsx",
+    "javascript": ".jsx",
+}
+
+
+def _ui_variant_extension(language: Any) -> str | None:
+    """The language's JSX/UI-component variant extension, or ``None`` (data lookup).
+
+    A capability flag in DATA form: a language family declares whether it has a
+    dedicated UI-component extension (``.tsx``/``.jsx``). ``None`` means the
+    family has no UI variant (its ``extensions[1]``, if any, is just another file
+    type), so UI-facing routing must NOT use the alternate extension. Replaces
+    the former ``language in {"typescript","javascript"}`` dispatch.
+    """
+    normalized = _normalize_implementation_language(language)
+    return _UI_VARIANT_EXTENSION_BY_LANGUAGE.get(normalized)
+
+
 def _default_generated_extension(language: Any, content: str | None = None) -> str:
     normalized = _normalize_implementation_language(language)
     extensions = _implementation_language_extensions(normalized)
-    if normalized in {"typescript", "javascript"} and len(extensions) > 1 and content and _looks_like_tsx(content):
+    ui_variant = _ui_variant_extension(normalized)
+    if ui_variant is not None and len(extensions) > 1 and content and _looks_like_tsx(content):
         return extensions[1]
     return extensions[0]
 

{codd_dev-2.87.0 → codd_dev-2.89.0}/codd/parsing/regex_strategies.py

@@ -529,6 +529,99 @@ def strategy_for(language: str) -> RegexLanguageStrategy:
     return _STRATEGIES.get((language or "").lower(), GENERIC_STRATEGY)
 
 
+# ─────────────────────────────────────────────────────────────────────────────
+# Repair-slice analyzer registry DATA (Contract Kernel Cut Condition A —
+# repair_slice.py de-literalization). ``codd/repair_slice.py``'s function
+# line-range + raises analyzer used to branch on ``language in
+# ("typescript","javascript")`` (tree-sitter func node-type set) and
+# ``language == "python"`` (regex def-vs-function pattern + group index, and the
+# python-only raises regex). Those per-language facts live HERE as registry DATA
+# (the analogue of a profile/adapter — an analyzer impl legitimately names its
+# own language), so the core analyzer dispatches by a data lookup, NOT a
+# language-name branch. Byte-identical to the former inline ladders; the
+# ``tests/languages/test_contract_kernel_cut_a_parity.py`` oracle pins this.
+#
+# Repair-slice extraction (like all extraction) is ANALYSIS input for patch
+# context, never a green/red GATE verdict — so an unknown language degrading to
+# the GENERIC profile (empty func-node set, the function-keyword regex, no raises)
+# is legitimate best-effort analysis, not a false-green.
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+@dataclass(frozen=True)
+class RepairSliceLanguageProfile:
+    """Per-language repair-slice analyzer DATA (one language; not dispatch).
+
+    * ``function_node_types`` — the tree-sitter named-node types that are a
+      function/method definition for this language (walked for line ranges).
+    * ``line_range_pattern`` — the regex (with ``re.MULTILINE``) that matches a
+      function definition in the regex FALLBACK path.
+    * ``line_range_name_group`` — which regex group holds the function name.
+    * ``raises_def_pattern`` / ``raises_stmt_pattern`` — the regex pair for the
+      regex-fallback raises analyzer; ``None`` (the GENERIC default) means this
+      language contributes NO raises in the fallback (byte-identical to the
+      former ``if language != "python": return {}``).
+    """
+
+    function_node_types: frozenset[str] = frozenset({"function_definition"})
+    line_range_pattern: re.Pattern[str] = field(
+        default_factory=lambda: re.compile(
+            r"^\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(", re.MULTILINE
+        )
+    )
+    line_range_name_group: int = 1
+    raises_def_pattern: re.Pattern[str] | None = None
+    raises_stmt_pattern: re.Pattern[str] | None = None
+
+
+#: The python repair-slice profile: tree-sitter walks only ``function_definition``
+#: (methods are ``function_definition`` inside a class in the python grammar); the
+#: regex fallback uses the ``def`` pattern with the NAME in group 2; and python is
+#: the ONLY language with a regex raises analyzer.
+_REPAIR_PYTHON = RepairSliceLanguageProfile(
+    function_node_types=frozenset({"function_definition"}),
+    line_range_pattern=re.compile(r"^(\s*)(?:async\s+)?def\s+(\w+)\s*\(", re.MULTILINE),
+    line_range_name_group=2,
+    raises_def_pattern=re.compile(r"\s*(?:async\s+)?def\s+(\w+)\s*\("),
+    raises_stmt_pattern=re.compile(r"\s+raise\s+(\w+)"),
+)
+
+#: The ts/js repair-slice profile: tree-sitter additionally walks
+#: ``method_definition`` + ``function_declaration`` (the former ``language in
+#: ("typescript","javascript")`` set); the regex fallback uses the
+#: ``function`` pattern with the NAME in group 1; no regex raises analyzer.
+_REPAIR_TS_JS = RepairSliceLanguageProfile(
+    function_node_types=frozenset(
+        {"function_definition", "method_definition", "function_declaration"}
+    ),
+    line_range_pattern=re.compile(
+        r"^\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(", re.MULTILINE
+    ),
+    line_range_name_group=1,
+)
+
+#: The GENERIC repair-slice profile for any other/unknown language — byte-identical
+#: to the former ``else`` branches: tree-sitter walks only ``function_definition``;
+#: the regex fallback uses the ``function`` pattern with the name in group 1; and
+#: no raises (the former ``if language != "python": return {}``).
+GENERIC_REPAIR_PROFILE = RepairSliceLanguageProfile()
+
+_REPAIR_PROFILES: dict[str, RepairSliceLanguageProfile] = {
+    "python": _REPAIR_PYTHON,
+    "typescript": _REPAIR_TS_JS,
+    "javascript": _REPAIR_TS_JS,
+}
+
+
+def repair_slice_profile_for(language: str) -> RepairSliceLanguageProfile:
+    """Repair-slice analyzer profile for *language* (registry-data lookup).
+
+    Unknown languages resolve to :data:`GENERIC_REPAIR_PROFILE` (the former
+    non-python / non-ts-js ``else`` behavior); analysis input, never a gate.
+    """
+    return _REPAIR_PROFILES.get((language or "").lower(), GENERIC_REPAIR_PROFILE)
+
+
 def language_extensions(language: str) -> set[str]:
     """Source-file extensions for *language* (registry-data lookup)."""
     return set(strategy_for(language).extensions)

{codd_dev-2.87.0 → codd_dev-2.89.0}/codd/repair_slice.py

@@ -60,9 +60,8 @@ def extract_function_line_ranges(
         ext = get_extractor(language)
         if not isinstance(ext, TreeSitterExtractor):
             return _extract_line_ranges_regex(content, language)
-        parser = ext._get_parser()
-        tree = parser.parse(content.encode("utf-8", errors="ignore"))
-        return _walk_functions_for_ranges(tree.root_node, content, language)
+        root = ext._parse(content)
+        return _walk_functions_for_ranges(root, content, language)
     except Exception:
         return _extract_line_ranges_regex(content, language)
 
@@ -72,12 +71,14 @@ def _walk_functions_for_ranges(
 ) -> dict[str, tuple[int, int]]:
     """Walk AST to find all function definitions with their line ranges."""
     from codd.parsing import _iter_named_nodes, _field_text
+    from codd.parsing.regex_strategies import repair_slice_profile_for
     content_bytes = content.encode("utf-8", errors="ignore")
     ranges: dict[str, tuple[int, int]] = {}
 
-    func_types = {"function_definition"}
-    if language in ("typescript", "javascript"):
-        func_types.update({"method_definition", "function_declaration"})
+    # The set of tree-sitter function/method node types for this language is
+    # registry DATA (the analogue of a profile/adapter), not a language-name
+    # branch in core. ts/js add method_definition + function_declaration.
+    func_types = repair_slice_profile_for(language).function_node_types
 
     for node in _iter_named_nodes(root):
         if node.type not in func_types:
@@ -105,18 +106,24 @@ def _parent_class_name(content_bytes: bytes, node: Any) -> str:
 
 
 def _extract_line_ranges_regex(content: str, language: str) -> dict[str, tuple[int, int]]:
-    """Fallback: regex-based line range extraction."""
-    ranges: dict[str, tuple[int, int]] = {}
-    if language == "python":
-        pattern = re.compile(r'^(\s*)(?:async\s+)?def\s+(\w+)\s*\(', re.MULTILINE)
-    else:
-        pattern = re.compile(r'^\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(', re.MULTILINE)
+    """Fallback: regex-based line range extraction.
+
+    The def-vs-function regex and the name-capture group are registry DATA per
+    language (python uses ``def`` with name in group 2; every other language uses
+    ``function`` with name in group 1), so this core fallback dispatches by a
+    data lookup, not a ``language == "python"`` branch.
+    """
+    from codd.parsing.regex_strategies import repair_slice_profile_for
+    profile = repair_slice_profile_for(language)
+    pattern = profile.line_range_pattern
+    name_group = profile.line_range_name_group
 
+    ranges: dict[str, tuple[int, int]] = {}
     lines = content.split("\n")
     matches = list(pattern.finditer(content))
     for i, m in enumerate(matches):
         line_no = content[:m.start()].count("\n") + 1
-        name = m.group(2) if language == "python" else m.group(1)
+        name = m.group(name_group)
         # Estimate end: next function or end of file
         if i + 1 < len(matches):
             end_line = content[:matches[i + 1].start()].count("\n")
@@ -137,9 +144,8 @@ def extract_raises(content: str, file_path: str, language: str) -> dict[str, lis
         ext = get_extractor(language)
         if not isinstance(ext, TreeSitterExtractor):
             return _extract_raises_regex(content, language)
-        parser = ext._get_parser()
-        tree = parser.parse(content.encode("utf-8", errors="ignore"))
-        return _walk_raises(tree.root_node, content, language)
+        root = ext._parse(content)
+        return _walk_raises(root, content, language)
     except Exception:
         return _extract_raises_regex(content, language)
 
@@ -193,17 +199,27 @@ def _enclosing_function(content_bytes: bytes, node: Any) -> str:
 
 
 def _extract_raises_regex(content: str, language: str) -> dict[str, list[str]]:
-    """Fallback regex for raises extraction."""
+    """Fallback regex for raises extraction.
+
+    The def/raise regex pair is registry DATA per language; a language without a
+    declared raises analyzer (every language except python today) yields no
+    raises — a data lookup, not a ``language != "python"`` branch.
+    """
+    from codd.parsing.regex_strategies import repair_slice_profile_for
+    profile = repair_slice_profile_for(language)
+    def_pattern = profile.raises_def_pattern
+    stmt_pattern = profile.raises_stmt_pattern
+
     result: dict[str, list[str]] = {}
-    if language != "python":
+    if def_pattern is None or stmt_pattern is None:
         return result
     current_func = ""
     for line in content.split("\n"):
-        m = re.match(r'\s*(?:async\s+)?def\s+(\w+)\s*\(', line)
+        m = def_pattern.match(line)
         if m:
             current_func = m.group(1)
         if current_func:
-            rm = re.match(r'\s+raise\s+(\w+)', line)
+            rm = stmt_pattern.match(line)
             if rm:
                 exc = rm.group(1)
                 result.setdefault(current_func, [])

{codd_dev-2.87.0 → codd_dev-2.89.0}/codd/stack/project.py

@@ -68,3 +68,45 @@ def verify_project_stack(
     if contract is None:
         return None
     return enforce_obligations(contract, project_root=project_root, **checker_inputs)
+
+
+def stack_contract_trace(contract: ResolvedStackContract) -> dict[str, Any]:
+    """Run-trace fields proving a run consumed the resolved stack contract.
+
+    Mirrors :meth:`codd.languages.contract.ResolvedLanguageContract.to_trace`: the
+    minimal, deterministic facts a run record / trace records so the live-consumption
+    of the framework-stack contract is observable (the v2.77a intake exit gate).
+    ``stack_contract_hash`` is the deterministic :attr:`ResolvedStackContract.content_hash`;
+    ``resolved_stack_id`` / ``resolved_stack_layers`` make "changing the profile changes
+    the plan" visible in the record itself.
+    """
+    return {
+        "resolved_stack_id": contract.stack_id,
+        "stack_contract_hash": contract.content_hash,
+        "resolved_stack_layers": [f"{ref.kind}:{ref.id}" for ref in contract.layers],
+    }
+
+
+def stack_contract_intake(project_root: str | Path) -> ResolvedStackContract | None:
+    """Resolve a project's declared stack contract for LIVE consumption (intake only).
+
+    This is the production seam the greenfield/verify pipeline calls EARLY in a run
+    to bring the (previously dormant) framework-stack contract into the live run —
+    *without* enforcing any obligation yet (enforcement is v2.77b-e). It is exactly
+    :func:`resolve_project_stack`, named for the intake call-site so the
+    "no non-test caller = 0 state" is eliminated by an unambiguous production caller.
+
+    Contract:
+
+    * No ``stack:`` block (the opt-in framework layer is unused) → ``None``. The
+      vast majority of projects; behaviour is byte-identical, never an error.
+    * A declared ``stack:`` block → the :class:`ResolvedStackContract` (its
+      ``content_hash`` is the run-trace hash; see :func:`stack_contract_trace`).
+    * A declared-but-BROKEN block (unknown language/framework/addon, malformed
+      mapping) → the resolver RAISES (``ValueError`` / ``UnknownLanguageError`` /
+      ``UnknownLayerError``). The intake NEVER swallows this: anti-false-green
+      forbids a declared-but-unresolvable stack from silently proceeding as if no
+      stack were declared. The pipeline call-site turns the raise into an honest
+      stage/command failure.
+    """
+    return resolve_project_stack(project_root)

{codd_dev-2.87.0 → codd_dev-2.89.0}/codd/vb_marker_authenticity.py

@@ -1235,6 +1235,18 @@ def _python_body_assigned_names(body_text: str) -> set[str]:
     return names
 
 
+#: Poetry MANIFEST-FORMAT reserved keys that appear under
+#: ``[tool.poetry.dependencies]`` but are NOT third-party packages. Poetry stores
+#: the interpreter version constraint as a pseudo-dependency named ``python``
+#: (``python = "^3.11"``); it is the interpreter pin, not a distribution to
+#: import. This is a poetry FILE-FORMAT fact (the analogue of registry/profile
+#: DATA), NOT a target-language gate dispatch — the surrounding parser is already
+#: unconditionally Python-specific. Excluding it keeps the third-party set exact;
+#: membership here is byte-identical to the former inline ``k.lower() != "python"``
+#: filter (Contract Kernel Cut Condition A — vb_marker_authenticity.py).
+_POETRY_RESERVED_NON_DEPENDENCY_KEYS = frozenset({"python"})
+
+
 def _python_manifest_top_dependencies(project_root: Path | None) -> frozenset[str]:
     """Declared third-party dependency names from ``pyproject.toml`` (PEP 621 +
     poetry), normalized for top-module matching. Empty when absent/unparseable —
@@ -1268,7 +1280,11 @@ def _python_manifest_top_dependencies(project_root: Path | None) -> frozenset[st
     if isinstance(poetry, dict):
         pdeps = poetry.get("dependencies", {})
         if isinstance(pdeps, dict):
-            reqs.extend(k for k in pdeps if isinstance(k, str) and k.lower() != "python")
+            reqs.extend(
+                k
+                for k in pdeps
+                if isinstance(k, str) and k.lower() not in _POETRY_RESERVED_NON_DEPENDENCY_KEYS
+            )
     names: set[str] = set()
     for req in reqs:
         m = re.match(r"\s*([A-Za-z0-9._-]+)", req)

{codd_dev-2.87.0 → codd_dev-2.89.0}/pyproject.toml

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