codd-dev 2.92.0__tar.gz → 2.93.0__tar.gz

{codd_dev-2.92.0 → codd_dev-2.93.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.92.0
+Version: 2.93.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.92.0 → codd_dev-2.93.0}/codd/__init__.py

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "2.92.0"
+__version__ = "2.93.0"

{codd_dev-2.92.0 → codd_dev-2.93.0}/codd/cli.py

@@ -7697,6 +7697,28 @@ def _intake_stack_contract_for_verify(project_root: Path, *, stack_command_execu
         f"({', '.join(plan.command_ids)})"
     )
 
+    # Stack obligation CHECKER gate (Contract Kernel v2.77e) — the verify-path mirror of
+    # the greenfield pipeline's :meth:`GreenfieldPipeline._enforce_stack_obligations`.
+    # AFTER materialization (v2.77c) + authenticity (v2.77d), CHECK the composed
+    # framework/addon OBLIGATIONS as a red/green gate: the Next.js ignoreBuildErrors guard
+    # reds a build that would pass with type errors; the Playwright e2e_actually_executed
+    # obligation reds a 0-test run. Anti-false-green: a missing/disabled/faulting checker
+    # or an unenforceable ERROR obligation is RED (honest non-zero exit), never a silent
+    # pass. Uses the ALREADY-RESOLVED ``contract`` from intake (no re-resolution from disk
+    # — avoids a TOCTOU skip) and the SAME current-run evidence the authenticity layer
+    # blessed. A non-stack project never reaches here (byte-identical).
+    from codd.stack.project import StackObligationGateError, enforce_stack_obligation_gate
+
+    try:
+        enforce_stack_obligation_gate(contract, project_root)
+    except StackObligationGateError as exc:
+        click.echo(f"[verify] stack obligation gate: {exc}", err=True)
+        raise SystemExit(1) from exc
+    click.echo(
+        f"[verify] stack obligation gate: {len(contract.obligations)} obligation(s) checked "
+        "— all enforced obligations satisfied"
+    )
+
 
 def _run_verify_once(
     path: str,

{codd_dev-2.92.0 → codd_dev-2.93.0}/codd/greenfield/pipeline.py

@@ -533,6 +533,26 @@ class GreenfieldPipeline:
                 {"status": STATUS_PENDING, "detail": ""}, str(exc),
             )
 
+        # Stack obligation CHECKER gate (Contract Kernel v2.77e) — turn the framework/
+        # addon OBLIGATIONS into a red/green gate, AFTER materialization+authenticity. The
+        # composed commands now run (v2.77c) and are authentic (v2.77d); this CHECKS the
+        # declared obligations (the Next.js ignoreBuildErrors guard reds a build that would
+        # pass with type errors; the Playwright e2e_actually_executed obligation reds a
+        # 0-test run). Anti-false-green: a missing/disabled/faulting checker or an
+        # unenforceable ERROR obligation is RED, never a silent pass. Uses the ALREADY-
+        # RESOLVED contract (no re-resolution from disk — avoids a TOCTOU skip) and the
+        # SAME current-run evidence the authenticity layer blessed. Only for stack-declared
+        # projects (contract is not None) — a non-stack run is byte-identical (no gate).
+        # Routed through _fail like intake/lock/materialization.
+        try:
+            if contract is not None:
+                self._enforce_stack_obligations(project_root, session, contract)
+        except StageError as exc:
+            return self._fail(
+                project_root, session, options, "stack_obligations",
+                {"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,
@@ -756,6 +776,45 @@ class GreenfieldPipeline:
             f"{len(plan.slots)} slot(s) invoked ({', '.join(plan.command_ids)})"
         )
 
+    # ── stack obligation checker gate (Contract Kernel v2.77e) ──
+
+    def _enforce_stack_obligations(self, project_root: Path, session: dict[str, Any], contract) -> None:
+        """Run the composed stack obligation checkers as a red/green gate (v2.77e).
+
+        See the call site in :meth:`run`. Only invoked for stack-declared projects
+        (``contract is not None``); non-stack projects never reach here, so they are
+        byte-identical (no obligation gate at all).
+
+        Uses the ALREADY-RESOLVED ``contract`` (passed in from intake/lock/
+        materialization) — NOT a re-resolution from disk — so a stack file that changes
+        or is deleted after materialization cannot make this gate silently skip (a
+        TOCTOU false-green). :func:`enforce_stack_obligation_gate` invokes every
+        obligation's registered checker with ``project_root`` plus the current-run
+        evidence (the SAME e2e report the authenticity layer blessed), and raises
+        :class:`StackObligationGateError` unless every ERROR obligation was genuinely
+        enforced AND satisfied: a blocking violation, an unenforced ERROR obligation
+        (no registered checker — unverifiable), or a checker fault (raised / None /
+        malformed return) is RED. Translated to :class:`StageError` so the autopilot
+        reports it honestly via ``_fail``. The per-obligation verdict counts are
+        recorded in the run trace (observable, like the lock verdict + command plan).
+        """
+        from codd.stack.project import StackObligationGateError, enforce_stack_obligation_gate
+
+        try:
+            result = enforce_stack_obligation_gate(contract, project_root)
+        except StackObligationGateError as exc:
+            self.echo(f"[greenfield] stack obligation gate: {exc}")
+            raise StageError(str(exc)) from exc
+
+        record = session.get("stack_contract")
+        if isinstance(record, dict) and result is not None:
+            record["stack_obligations_checked"] = len(contract.obligations)
+            record["stack_obligations_unenforced"] = [o.id for o in result.unenforced]
+        self.echo(
+            "[greenfield] stack obligation gate: "
+            f"{len(contract.obligations)} obligation(s) checked — all enforced obligations satisfied"
+        )
+
     # ── option resolution ───────────────────────────────────
 
     def _resolve_options(self, project_root: Path) -> dict[str, Any]:

{codd_dev-2.92.0 → codd_dev-2.93.0}/codd/stack/compose.py

@@ -50,7 +50,14 @@ VERIFICATION_SLOTS = frozenset(
     }
 )
 
-_SEVERITY_RANK = {"warn": 0, "error": 1}
+def _normalize_checker_ref(ref: str | None) -> str:
+    """Canonical form of an obligation ``checker`` ref for redefinition comparison.
+
+    ``None`` / empty / whitespace all normalize to ``""`` (no checker) so a later layer
+    that nulls or blanks the checker compares as a CHANGE vs. a non-empty ref (a real
+    weakening). Surrounding whitespace is stripped; the ref is otherwise compared
+    verbatim (we never claim two distinct refs are "equivalent")."""
+    return (ref or "").strip()
 
 
 @dataclass(frozen=True)
@@ -199,7 +206,28 @@ def compose(
                 )
             )
 
-    # -- obligations (union; an addon must not WEAKEN a framework obligation) ---
+    # -- obligations (union; a later layer may not silently REDEFINE an obligation) -
+    # An obligation id is a SEMANTIC KEY. A later layer may repeat the same id ONLY if
+    # the enforcement-relevant fields (severity + checker ref) are IDENTICAL — an exact
+    # idempotent duplicate (e.g. two layers asserting the same e2e obligation). ANY
+    # enforcement-relevant change is a semantic conflict (Contract Kernel v2.77e,
+    # GPT-5.5 Pro consult 2026-06-21):
+    #
+    #   * severity mismatch (downgrade OR upgrade) — first-wins would SILENTLY pick one,
+    #     hiding the ambiguity. A downgrade weakens; an upgrade silently DROPS a stricter
+    #     later layer (a false-green relative to the intended stricter obligation). With
+    #     no explicit monotone-merge semantics, ANY severity mismatch is RED (strict
+    #     option — less clever, harder to game).
+    #   * checker-ref change (including a redefinition that nulls/empties or points the
+    #     checker at a different/weaker/unknown adapter) — "same severity, gutted checker"
+    #     is real weakening that first-wins hides by luck, not by contract. A later layer
+    #     that means a DIFFERENT check must use a DIFFERENT id; one that means the SAME
+    #     check must use the SAME checker ref. (We do NOT try to prove two different refs
+    #     are "equivalent" — intractable at the contract-kernel level.)
+    #
+    # first-wins is kept for the resolved set (the FIRST declaration stays authoritative),
+    # but a non-idempotent redefinition is RECORDED as a Conflict so the strict gate reds
+    # — silence is forbidden (no silent fallback).
     obligations: list[Obligation] = []
     obligation_owners: dict[str, str] = {}
     obl_by_id: dict[str, Obligation] = {}
@@ -211,14 +239,33 @@ def compose(
                 obligation_owners[obl.id] = f"{kind}:{prof.id}"
                 continue
             existing = obl_by_id[obl.id]
-            if _SEVERITY_RANK[obl.severity] < _SEVERITY_RANK[existing.severity]:
+            if obl.severity != existing.severity:
+                conflicts.append(
+                    Conflict(
+                        kind="semantic",
+                        detail=(
+                            f"obligation {obl.id!r} severity redefined to {obl.severity!r} "
+                            f"by {kind}:{prof.id} (owner {obligation_owners[obl.id]} "
+                            f"declared {existing.severity!r}) — a severity mismatch is a "
+                            "semantic conflict (a downgrade weakens; an upgrade silently "
+                            "drops a stricter layer); use the same id only for the same "
+                            "obligation at the same severity"
+                        ),
+                        layers=(obligation_owners[obl.id], f"{kind}:{prof.id}"),
+                    )
+                )
+            elif _normalize_checker_ref(obl.checker) != _normalize_checker_ref(existing.checker):
                 conflicts.append(
                     Conflict(
                         kind="semantic",
                         detail=(
-                            f"obligation {obl.id!r} weakened to {obl.severity!r} by "
-                            f"{kind}:{prof.id} (owner {obligation_owners[obl.id]} "
-                            f"declared {existing.severity!r})"
+                            f"obligation {obl.id!r} checker redefined to "
+                            f"{obl.checker!r} by {kind}:{prof.id} (owner "
+                            f"{obligation_owners[obl.id]} declared {existing.checker!r}) — "
+                            "a same-id checker-ref change is a semantic conflict (it would "
+                            "silently keep one checker and discard the other); two different "
+                            "checks need two different obligation ids, the same check needs "
+                            "the same checker ref"
                         ),
                         layers=(obligation_owners[obl.id], f"{kind}:{prof.id}"),
                     )

codd_dev-2.93.0/codd/stack/obligations.py

@@ -0,0 +1,171 @@
+"""Run a resolved stack contract's obligations through their registered checkers.
+
+This is the GATE SEAM: greenfield/verify call :func:`enforce_obligations` with a
+:class:`~codd.stack.compose.ResolvedStackContract` and the project context; each
+obligation is dispatched to its registered checker (design §3 obligations). An
+ERROR-severity obligation with findings is gate-blocking; a WARN one is advisory.
+
+Anti-false-green (cardinal rule): a checker that is *not real enforcement* must
+NEVER be read as "satisfied". Two distinct failure modes are surfaced, both
+gate-blocking for an ERROR obligation (Contract Kernel v2.77e):
+
+* ``unenforced`` — the obligation declares a checker ref that resolves to NOTHING
+  (missing ref / null / unregistered / a registry entry that is not callable). The
+  enforcement does not exist; an ERROR release-blocker with no checker is a failure,
+  never a silent pass.
+* ``faults`` — the checker EXISTS but did not produce a usable verdict: it raised,
+  returned ``None`` (the canonical ``checker(...) or []`` false-green this layer
+  fixes — an unimplemented checker that falls off the end returns ``None``, which
+  must NOT collapse to "no findings"), or returned a non-list malformed value. The
+  obligation could not be honestly judged → RED for an ERROR obligation.
+
+A WARN obligation that is unenforced or faults is advisory (does not block) — but is
+still reported so the run record is honest. The conformance contract
+(``tests/test_stack_obligations.py``) keeps the curated profiles' ERROR obligations
+enforceable; a runtime caller must still surface these honestly.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .adapters import resolve_checker
+from .adapters._base import ObligationFinding
+from .compose import ResolvedStackContract
+from .profile import Obligation
+
+
+@dataclass(frozen=True)
+class ObligationViolation:
+    obligation: Obligation
+    finding: ObligationFinding
+
+    @property
+    def blocking(self) -> bool:
+        return self.obligation.severity == "error"
+
+
+@dataclass(frozen=True)
+class ObligationFault:
+    """A checker that EXISTS but produced no usable verdict (raised / None / malformed).
+
+    Distinct from a :class:`ObligationViolation` (the checker ran and found a real
+    violation) and from ``unenforced`` (no checker at all): here the checker was
+    invoked but could not be honestly read as "satisfied". For an ERROR obligation
+    this is RED — the obligation could not be enforced (anti-false-green: never treat
+    a broken checker as a pass).
+    """
+
+    obligation: Obligation
+    reason: str
+
+    @property
+    def blocking(self) -> bool:
+        return self.obligation.severity == "error"
+
+
+@dataclass(frozen=True)
+class ObligationResult:
+    violations: tuple[ObligationViolation, ...]
+    unenforced: tuple[Obligation, ...]
+    faults: tuple[ObligationFault, ...] = ()
+
+    @property
+    def blocking_violations(self) -> tuple[ObligationViolation, ...]:
+        return tuple(v for v in self.violations if v.blocking)
+
+    @property
+    def blocking_faults(self) -> tuple[ObligationFault, ...]:
+        return tuple(f for f in self.faults if f.blocking)
+
+    @property
+    def passed(self) -> bool:
+        """Gate verdict: GREEN only when every ERROR obligation was genuinely
+        enforced AND satisfied. RED on ANY of: a blocking violation; an unenforced
+        ERROR obligation (no checker — claimed enforcement that does not run); a
+        blocking fault (the checker exists but raised / returned None / returned a
+        malformed value — the obligation could not be honestly judged). All three are
+        anti-false-green: a release-blocker that was not really checked is never green."""
+        if self.blocking_violations:
+            return False
+        if self.blocking_faults:
+            return False
+        return not any(o.severity == "error" for o in self.unenforced)
+
+
+def enforce_obligations(
+    contract: ResolvedStackContract,
+    *,
+    project_root=None,
+    **checker_inputs,
+) -> ObligationResult:
+    """Dispatch each obligation to its registered checker and collect the result.
+
+    ``checker_inputs`` (e.g. ``report_data=...`` / ``report_path=...``) are passed
+    through to every checker; each checker takes ``**kwargs`` and uses what it
+    needs (the Next.js guard reads ``project_root``; the Playwright guard reads
+    the report).
+
+    Hardened seam (v2.77e): a registered checker is invoked defensively. It must
+    return a ``list`` of findings (an empty list == SATISFIED). A checker that
+    raises, returns ``None``, or returns a non-list is recorded as an
+    :class:`ObligationFault` (NOT silently treated as satisfied) — the ``or []``
+    coercion that turned an unimplemented (``None``-returning) checker into a false
+    green is removed. A registry entry that is not callable is treated as
+    ``unenforced`` (no usable checker exists).
+    """
+    violations: list[ObligationViolation] = []
+    unenforced: list[Obligation] = []
+    faults: list[ObligationFault] = []
+    for obl in contract.obligations:
+        checker = resolve_checker(obl.checker)
+        if checker is None:
+            unenforced.append(obl)
+            continue
+        if not callable(checker):
+            # A registry entry that is not callable cannot enforce anything — there is
+            # no usable checker, so this is "unenforced", not a fault (same verdict for
+            # an ERROR obligation: RED).
+            unenforced.append(obl)
+            continue
+        try:
+            findings = checker(project_root=project_root, **checker_inputs)
+        except Exception as exc:  # noqa: BLE001 — a crashing checker is NOT "satisfied".
+            faults.append(
+                ObligationFault(
+                    obligation=obl,
+                    reason=f"checker {obl.checker!r} raised {type(exc).__name__}: {exc}",
+                )
+            )
+            continue
+        if findings is None:
+            faults.append(
+                ObligationFault(
+                    obligation=obl,
+                    reason=(
+                        f"checker {obl.checker!r} returned None (no verdict) — an "
+                        "unimplemented or fall-through checker is not a satisfied "
+                        "obligation (anti-false-green: never coerce None to no-findings)"
+                    ),
+                )
+            )
+            continue
+        if not isinstance(findings, list):
+            faults.append(
+                ObligationFault(
+                    obligation=obl,
+                    reason=(
+                        f"checker {obl.checker!r} returned a non-list "
+                        f"{type(findings).__name__} — a checker must return a list of "
+                        "findings (empty == satisfied); a malformed return is not a pass"
+                    ),
+                )
+            )
+            continue
+        for finding in findings:
+            violations.append(ObligationViolation(obligation=obl, finding=finding))
+    return ObligationResult(
+        violations=tuple(violations),
+        unenforced=tuple(unenforced),
+        faults=tuple(faults),
+    )

codd_dev-2.93.0/codd/stack/project.py

@@ -0,0 +1,252 @@
+"""Project-level wiring seam: resolve + enforce a project's declared stack.
+
+This is the bridge the greenfield/verify pipeline calls. A project opts into the
+framework layer by declaring a ``stack:`` block in its codd.yaml (design §1)::
+
+    stack:
+      language: typescript
+      frameworks: [nextjs]
+      addons: [prisma, playwright]
+
+* :func:`resolve_project_stack` reads that block and returns the
+  ResolvedStackContract — or ``None`` if the project declares no stack (the
+  framework layer is OPT-IN; a project without a ``stack:`` block is completely
+  unaffected, so Python/Go/plain-TS projects see no behaviour change).
+* :func:`verify_project_stack` resolves then runs the obligation checkers,
+  returning the gate result (or ``None`` for a no-stack project).
+
+The pipeline call-site reds on ``result is not None and not result.passed``.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Mapping
+
+from .compose import ResolvedStackContract
+from .obligations import ObligationResult, enforce_obligations
+from .resolve import resolve_stack_from_declaration
+
+
+def _read_stack_declaration(project_root: str | Path) -> Mapping[str, Any] | None:
+    """Return the ``stack:`` block from the project's codd.yaml, or ``None``."""
+    from codd.config import load_project_config
+
+    try:
+        config = load_project_config(Path(project_root))
+    except (FileNotFoundError, ValueError):
+        return None
+    decl = config.get("stack")
+    if not decl or not isinstance(decl, Mapping):
+        return None
+    return decl
+
+
+def resolve_project_stack(project_root: str | Path) -> ResolvedStackContract | None:
+    """Resolve a project's declared stack into a contract, or ``None`` if none.
+
+    ``None`` means "this project does not use the framework layer" — never an
+    error (the framework layer is opt-in).
+    """
+    decl = _read_stack_declaration(project_root)
+    if decl is None:
+        return None
+    return resolve_stack_from_declaration(decl)
+
+
+def verify_project_stack(
+    project_root: str | Path, **checker_inputs: Any
+) -> ObligationResult | None:
+    """Resolve + enforce a project's stack obligations (the framework verify gate).
+
+    Returns ``None`` for a project that declares no stack (no-op gate); otherwise
+    the :class:`ObligationResult` (``result.passed`` is the gate verdict;
+    ``checker_inputs`` such as ``report_data=`` / ``report_path=`` are forwarded
+    to the checkers).
+    """
+    contract = resolve_project_stack(project_root)
+    if contract is None:
+        return None
+    return enforce_obligations(contract, project_root=project_root, **checker_inputs)
+
+
+class StackObligationGateError(RuntimeError):
+    """The stack obligation-checker gate failed (Contract Kernel v2.77e).
+
+    Raised by :func:`enforce_stack_obligation_gate` when the resolved stack
+    contract's obligations are not all genuinely-enforced-and-satisfied
+    (:attr:`ObligationResult.passed` is False): a blocking violation, an unenforced
+    ERROR obligation (no registered checker), or a blocking fault (a checker that
+    raised / returned None / returned a malformed value). The call-sites translate
+    it to their context's RED — ``StageError`` in the greenfield pipeline (→
+    ``_fail``), ``SystemExit`` non-zero on the verify CLI path — exactly like
+    :class:`codd.stack.command_plan.StackCommandMaterializationError` and
+    :class:`codd.stack.command_authenticity.StackCommandAuthenticityError`.
+    """
+
+
+def build_obligation_checker_inputs(
+    contract: ResolvedStackContract,
+    project_root: str | Path,
+) -> dict[str, Any]:
+    """Assemble the obligation checkers' runtime inputs from CURRENT-RUN evidence.
+
+    Contract Kernel v2.77e. Most obligation checkers (e.g. the Next.js
+    ``ignoreBuildErrors`` guard) read only the filesystem (``project_root``) and need
+    no extra input — the gate always passes ``project_root`` to every checker. The
+    one curated obligation that needs runtime evidence is the Playwright
+    ``e2e_actually_executed`` check, which must see THIS run's e2e report.
+
+    The evidence is consumed from the SAME source the v2.77c/d materialization +
+    authenticity layer blessed — NOT re-derived or re-parsed with a divergent parser
+    (GPT-5.5 Pro consult 2026-06-21: prefer the authenticity-normalized
+    ``report_data`` to avoid parser drift / TOCTOU). For each TEST-report slot in the
+    composed command plan, the slot's current-run report is parsed by the canonical
+    ``runner_report`` adapter (the exact parser v2.77d uses) into normalized counts,
+    which are shaped into the ``report_data`` the obligation checker reads. Because
+    both layers use the canonical ``suites`` parser, a 0-test / fully-skipped e2e run
+    reds in BOTH (defense in depth on ONE evidence source, never two parsers).
+
+    Binding rule (anti-false-green): the report is passed ONLY when the current-run
+    evidence was genuinely produced AND readable this run (a stale file the executor
+    did not produce this run is NOT trusted → no report passed → a checker that needs
+    it reds on "missing report", which is the correct RED). If the plan has more than
+    one TEST-report slot the binding is AMBIGUOUS for a single ``report_data`` kwarg;
+    the curated stack has exactly one (Playwright ``e2e_test``), so this is a clean
+    single binding today — a future multi-e2e stack must disambiguate (left to the
+    step that introduces it; until then a second TEST-report slot is surfaced as an
+    error so it can never silently pick the wrong report).
+    """
+    from codd.stack.command_authenticity import (
+        StackCommandObservationKind,
+        observe_stack_command_report,
+        resolve_stack_command_observation_policy,
+    )
+    from codd.stack.command_plan import stack_command_plan
+
+    root = Path(project_root)
+    plan = stack_command_plan(contract)  # conflict gate already passed upstream; pure projection
+
+    test_report_obs: list[Any] = []
+    for slot in plan.slots:
+        policy = resolve_stack_command_observation_policy(
+            slot.slot_id, contract_policies=contract.command_observation_policies
+        )
+        if policy is None or policy.kind is not StackCommandObservationKind.TEST_REPORT:
+            continue
+        if not (slot.report_capture or slot.report_path):
+            continue
+        obs = observe_stack_command_report(slot, root, policy)
+        test_report_obs.append((slot, obs))
+
+    if not test_report_obs:
+        return {}
+    if len(test_report_obs) > 1:
+        slots = ", ".join(f"{s.slot_id}({s.owner})" for s, _ in test_report_obs)
+        raise StackObligationGateError(
+            "ambiguous obligation evidence: the resolved stack has more than one "
+            f"TEST-report command slot ({slots}); a single report binding cannot pick "
+            "one unambiguously (anti-false-green: never last-writer-wins across reports). "
+            "A multi-e2e stack must declare per-obligation evidence binding."
+        )
+
+    slot, obs = test_report_obs[0]
+    if not (obs.produced and obs.readable):
+        # The current-run evidence was NOT produced/readable this run — do NOT pass a
+        # stale or absent report. A checker that requires it then reds on "missing
+        # report" (the correct RED); we never feed it untrusted evidence.
+        return {}
+
+    # Shape the canonical-normalized counts into the report_data the obligation checker
+    # reads. ``expected`` = clean passes; ``unexpected``/``flaky`` = 0 so the checker's
+    # "executed = expected+unexpected+flaky" equals the canonical clean-pass count: a
+    # run with >=1 clean pass is GREEN; a fully-skipped/all-failed run (passed_cases==0)
+    # is RED — agreeing with the canonical parser, no divergent stats read of the file.
+    passed = int(obs.passed_cases or 0)
+    report_data = {"stats": {"expected": passed, "unexpected": 0, "flaky": 0, "skipped": 0}}
+    return {"report_data": report_data}
+
+
+def enforce_stack_obligation_gate(
+    contract: ResolvedStackContract | None,
+    project_root: str | Path,
+) -> ObligationResult | None:
+    """The Contract Kernel v2.77e GATE: run the stack obligation checkers, RED on failure.
+
+    Wired AFTER v2.77c materialization + v2.77d authenticity. Takes the ALREADY-RESOLVED
+    contract (NO re-resolution from disk — avoids the TOCTOU hole where a stack file
+    changes/deletes between materialization and this gate and the obligation gate then
+    silently skips). For ``contract is None`` (a project that declared no stack) it is a
+    no-op → ``None`` (byte-identical, no gate). Otherwise it invokes every obligation's
+    registered checker with ``project_root`` plus the current-run evidence
+    (:func:`build_obligation_checker_inputs`) and raises :class:`StackObligationGateError`
+    unless :attr:`ObligationResult.passed` (every ERROR obligation genuinely enforced and
+    satisfied; an unenforced ERROR obligation, a blocking violation, or a checker fault is
+    RED). Returns the :class:`ObligationResult` on GREEN so the caller can record it.
+    """
+    if contract is None:
+        return None
+    checker_inputs = build_obligation_checker_inputs(contract, project_root)
+    result = enforce_obligations(contract, project_root=Path(project_root), **checker_inputs)
+    if not result.passed:
+        reasons: list[str] = []
+        for v in result.blocking_violations:
+            reasons.append(f"[violation] {v.obligation.id}: {v.finding.detail}")
+        for f in result.blocking_faults:
+            reasons.append(f"[fault] {f.obligation.id}: {f.reason}")
+        for o in result.unenforced:
+            if o.severity == "error":
+                reasons.append(
+                    f"[unenforced] {o.id}: no registered checker for ref {o.checker!r} "
+                    "(an ERROR obligation with no checker is unverifiable — RED)"
+                )
+        raise StackObligationGateError(
+            f"stack obligation gate failed ({contract.stack_id}): "
+            + "; ".join(reasons)
+            + ". A framework/addon obligation was not genuinely enforced AND satisfied — "
+            "anti-false-green: a missing/disabled/faulting checker or a violated obligation "
+            "is RED, never a silent pass (Contract Kernel v2.77e)."
+        )
+    return result
+
+
+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.92.0 → codd_dev-2.93.0}/pyproject.toml

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