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

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

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

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

{codd_dev-2.88.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.88.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.88.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.88.0 → codd_dev-2.89.0}/pyproject.toml

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