codd-dev 2.81.0__tar.gz → 2.83.0__tar.gz

{codd_dev-2.81.0 → codd_dev-2.83.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.81.0
+Version: 2.83.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.81.0 → codd_dev-2.83.0}/codd/__init__.py

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "2.81.0"
+__version__ = "2.83.0"

{codd_dev-2.81.0 → codd_dev-2.83.0}/codd/greenfield/pipeline.py

@@ -1133,7 +1133,9 @@ class GreenfieldPipeline:
         declared implement-time oracle.
         """
         from codd.implement_oracle import (
+            ORACLE_STATE_UNSUPPORTED_EXPLICIT,
             OracleScopeError,
+            classify_implement_oracle_state,
             resolve_implement_oracle,
             run_implement_oracle_gate,
         )
@@ -1141,17 +1143,51 @@ class GreenfieldPipeline:
         config, language, source_dirs, test_dirs = self._layout_inputs(project_root)
         project_name = self._layout_project_name(project_root, config)
 
-        # Cheap NO-OP short-circuit: if the stack declares no implement-time
-        # oracle (Python today), do not even scaffold/echo — skip silently.
-        if resolve_implement_oracle(
+        # NO-OP short-circuit — but the 4-state model decides WHICH "no oracle" this is
+        # (Contract Kernel oracle dispatch §9). ``_stage_implement`` is strict by
+        # construction: it GENERATED the code and must PROVE it. So a DECLARED-but-
+        # UNSUPPORTED stack must NOT be silently skipped here — that is the very false-
+        # green §9 closes. Only a NON-DECLARED stack (LEGACY_ABSENT) or an explicit
+        # opt-out (OPT_OUT) is genuinely skippable (the gate's visible trace covers the
+        # observability; here the short-circuit avoids needless scaffolding).
+        resolved = resolve_implement_oracle(
             project_root,
             language=language,
             project_name=project_name,
             source_dirs=source_dirs,
             test_dirs=test_dirs,
             config=config,
-        ) is None:
+        )
+        if resolved is None:
+            state = classify_implement_oracle_state(language, config, resolved=resolved)
+            if state == ORACLE_STATE_UNSUPPORTED_EXPLICIT:
+                # A declared stack CoDD cannot prove (no registered oracle adapter) —
+                # the strict greenfield implement stage RED. Mirror the gate's verdict
+                # as a StageError instead of silently advancing to verify (where the
+                # incoherence would surface later, or not at all).
+                raise StageError(
+                    f"implement-time native-oracle gate: language {language!r} is declared "
+                    "but UNSUPPORTED — no registered implement-oracle adapter, so the "
+                    "generated code's cross-artifact coherence is UNPROVEN. A declared-but-"
+                    "unsupported stack is RED, never a silent pass (add a LanguageProfile + "
+                    "oracle adapter for this stack, or opt out via implement.implement_oracle:"
+                    " false)."
+                )
+            # LEGACY_ABSENT / OPT_OUT — genuinely skippable (visible-trace cases). Run the
+            # gate once anyway so its (now VISIBLE) NO-OP trace is emitted, then return —
+            # cheap, and it keeps the observability promise (§9: NO-OP is never silent).
+            run_implement_oracle_gate(
+                project_root,
+                language=language,
+                project_name=project_name,
+                source_dirs=source_dirs,
+                test_dirs=test_dirs,
+                config=config,
+                echo=self.echo,
+            )
             return
+        # A supported oracle resolved (resolved is not None) — fall through to
+        # certify + run it below.
 
         # The oracle needs the scaffolded config (tsconfig) present NOW, at
         # implement-time — verify's scaffold runs later. Idempotent + non-

{codd_dev-2.81.0 → codd_dev-2.83.0}/codd/implement_oracle.py

@@ -121,6 +121,10 @@ from codd.implement_oracle_types import (  # noqa: F401 — re-exported for back
 
 __all__ = [
     "EVIDENCE_CATEGORIES",
+    "ORACLE_STATE_LEGACY_ABSENT",
+    "ORACLE_STATE_OPT_OUT",
+    "ORACLE_STATE_SUPPORTED",
+    "ORACLE_STATE_UNSUPPORTED_EXPLICIT",
     "ImplementOracleFinding",
     "ImplementOracleResult",
     "OracleRerunCallback",
@@ -131,10 +135,12 @@ __all__ = [
     "certify_go_oracle_scope",
     "certify_oracle_scope",
     "certify_python_oracle_scope",
+    "classify_implement_oracle_state",
     "normalize_oracle_output",
     "normalize_python_tool_output",
     "resolve_implement_oracle",
     "run_implement_oracle_gate",
+    "synthesize_minimal_layout_view",
 ]
 
 #: Internal-but-tested campaign entry point (the anti-false-green acceptance tests
@@ -207,6 +213,85 @@ def _oracle_opt_out(config: Mapping[str, Any] | None) -> bool:
     return False
 
 
+# ── the 4-state oracle dispatch model (Contract Kernel oracle dispatch §6, §9) ──
+#
+# When :func:`resolve_implement_oracle` returns ``None`` it means ONLY "no runnable
+# oracle resolved" — it COLLAPSES four very different reasons into one signal. §9
+# closes the false-green that collapse hid: a DECLARED-but-UNSUPPORTED stack (a
+# non-empty language CoDD was told to build, with NO registered oracle adapter) was
+# waved through as a silent NO-OP PASS. The gate must distinguish:
+#
+#   SUPPORTED            — a contract oracle resolved (run it; GREEN only if it
+#                          actually passes). [resolved is not None]
+#   UNSUPPORTED_EXPLICIT — a NON-EMPTY language is declared but NO oracle resolves
+#                          AND not opted out → RED (passed=False, executed=False,
+#                          code="implement_oracle_unsupported"). The §9 closure: a
+#                          declared stack CoDD cannot prove must NOT pass.
+#   LEGACY_ABSENT        — language is None/empty (NO declared stack) → NO-OP, but
+#                          a VISIBLE fallback trace; NON-RED (nothing to be
+#                          "unsupported" about — there is no declared stack).
+#   OPT_OUT              — ``implement.implement_oracle: false`` → NO-OP-WITH-TRACE
+#                          (``unsupported_oracle_allowed_by_config``), excluded from
+#                          the green-gate; NON-RED by default (preserves the
+#                          documented opt-out contract), never silent.
+#
+# Cardinal rule: false-GREEN is forbidden, but do NOT over-RED a legitimate
+# no-oracle case (no language at all, or an explicit opt-out) — those are
+# NO-OP-WITH-TRACE (visible), never silent, never RED.
+#
+# Language-FREE: the classification keys on "did a contract oracle resolve?" + "is
+# a non-empty language declared?" + "is it opted out?" — NEVER on a specific
+# language name (Cut Condition A). Adding a new compiler stack is still one profile
+# entry + one leaf adapter; it then resolves SUPPORTED with no edit here.
+ORACLE_STATE_SUPPORTED = "supported"
+ORACLE_STATE_UNSUPPORTED_EXPLICIT = "unsupported_explicit"
+ORACLE_STATE_LEGACY_ABSENT = "legacy_absent"
+ORACLE_STATE_OPT_OUT = "opt_out"
+
+
+def classify_implement_oracle_state(
+    language: str | None,
+    config: Mapping[str, Any] | None,
+    *,
+    resolved: object,
+) -> str:
+    """Classify the oracle dispatch state for ``language`` (the 4-state model, §9).
+
+    ``resolved`` is the :func:`resolve_implement_oracle` result (a ``(profile, spec)``
+    tuple, or ``None``). The classification is language-FREE — it keys on whether a
+    runnable oracle resolved, whether a NON-EMPTY language is declared, and whether
+    the gate is opted out — never on a language name (Cut Condition A):
+
+    * ``resolved is not None``                → ``SUPPORTED``.
+    * opted out                               → ``OPT_OUT`` (NO-OP-with-trace).
+    * empty/None language                     → ``LEGACY_ABSENT`` (NO-OP-with-trace).
+    * a SUPPORTED contract resolves anyway    → ``LEGACY_ABSENT`` (defensive: the
+      resolver returned ``None`` for some OTHER reason than "unsupported"; never
+      RED a stack that genuinely HAS an adapter — bound the blast radius).
+    * otherwise (non-empty language, no contract, not opted out)
+                                              → ``UNSUPPORTED_EXPLICIT`` (RED).
+
+    The OPT_OUT check precedes the language-emptiness/contract checks because an
+    opt-out on a SUPPORTED language must read as the (visible, non-RED) opt-out, not
+    as supported — :func:`resolve_implement_oracle` already short-circuits opt-out to
+    ``None`` before it ever looks at the profile.
+    """
+    if resolved is not None:
+        return ORACLE_STATE_SUPPORTED
+    if _oracle_opt_out(config):
+        return ORACLE_STATE_OPT_OUT
+    if (language or "").strip() == "":
+        return ORACLE_STATE_LEGACY_ABSENT
+    # A non-empty language with no resolved (profile, spec). If a contract oracle
+    # nonetheless resolves (a registered adapter exists), the resolver returned None
+    # for an unrelated reason — do NOT RED a stack CoDD CAN actually prove; treat it
+    # as a (visible) legacy-absent NO-OP. Only a TRULY unsupported stack (no contract)
+    # is the §9 RED.
+    if _resolve_contract_oracle(language) is not None:
+        return ORACLE_STATE_LEGACY_ABSENT
+    return ORACLE_STATE_UNSUPPORTED_EXPLICIT
+
+
 # ── broad-repair campaign config (the budgeted residual coherence campaign) ──
 #
 # When a wide-fan-out artifact forces the broad RUNG, broad's EXECUTION is no
@@ -1095,13 +1180,16 @@ def resolve_implement_oracle(
     CONTRACT-PATH languages (the language→oracle map entry): a language with no
     legacy ``LayoutProfile`` builder (Go — ``resolve_layout_profile('go')`` returns
     None) but a modeled ``implement_oracle`` whose adapter is REGISTERED resolves
-    via :func:`_resolve_registry_composite_oracle`, which synthesizes a minimal
-    ``(LayoutProfile, ImplementOracleSpec)`` (``kind="composite"``) so the existing
-    gate machinery (certify/run/retry) works unchanged; the SAME dispatch in
-    :func:`_run_oracle_command` then routes it to the Contract-Kernel contract path
-    (:func:`_run_contract_oracle` → ``run_command_sequence`` + the registered
-    adapter). The selection is GENERIC (modeled oracle + registered adapter) — no
-    ``if language=='go'`` literal in the gate.
+    via :func:`_resolve_registry_oracle`, which synthesizes a minimal
+    ``(LayoutProfile, ImplementOracleSpec)`` for ANY oracle ``kind`` (composite /
+    command / adapter) so the existing gate machinery (certify/run/retry) works
+    unchanged; the SAME dispatch in :func:`_run_oracle_command` then routes it to the
+    Contract-Kernel contract path (:func:`_run_contract_oracle` →
+    ``run_command_sequence`` for command/composite, the adapter's ``execute`` for
+    ``adapter``). The selection is GENERIC (modeled oracle + registered adapter) — no
+    ``if language=='go'`` literal in the gate, and NO kind allowlist (a synthetic
+    ``kind="command"``/``"adapter"`` language with no legacy ``LayoutProfile`` runs
+    its oracle too, never silently passes — Contract Kernel oracle dispatch §8).
     """
     if _oracle_opt_out(config):
         return None
@@ -1115,43 +1203,110 @@ def resolve_implement_oracle(
             project_root=project_root,
         )
     if profile is None:
-        # No legacy LayoutProfile — try the declarative registry (Go: a composite
-        # oracle synthesized from go.yaml, reachable WITHOUT a legacy profile).
-        return _resolve_registry_composite_oracle(language)
+        # No legacy LayoutProfile — try the declarative registry. ANY kind resolves
+        # (Go's composite, a synthetic command/adapter language): the generic
+        # synthesizer builds the minimal gate-machinery ``(LayoutProfile, spec)`` and
+        # the kind-routed dispatch runs the registered adapter (no kind allowlist).
+        return _resolve_registry_oracle(language)
     if profile.implement_oracle is None:
         return None
     return profile, profile.implement_oracle
 
 
-def _resolve_registry_composite_oracle(
+def synthesize_minimal_layout_view(lang_profile: Any) -> LayoutProfile:
+    """A minimal :class:`LayoutProfile` COMPAT VIEW from a ``LanguageProfile.layout``.
+
+    GPT §5 "synthesize_minimal_layout_view": a ``kind="adapter"`` oracle (the
+    Python-style in-process composite) reads ``source_root`` / ``test_root`` /
+    ``package_root`` / ``package_name`` off ``OracleContext.layout_profile`` — fields
+    the modeled ``LayoutSpec`` does NOT carry. When such a language has NO legacy
+    ``LayoutProfile`` builder, this synthesizes those fields from the profile's
+    ``layout.source_sets`` / ``layout.test_sets`` (first set's ``root``; defensive
+    ``src`` / ``tests`` defaults) so the adapter still gets the layout view it needs.
+
+    This is a COMPAT VIEW, not the scope AUTHORITY: the real scope authority is the
+    ``LanguageProfile.layout`` + the oracle adapter's ``certify_scope`` (anti-false-
+    green). It carries only what an ``adapter``-kind oracle reads, never a per-language
+    policy. ``package_root`` defaults to ``source_root`` (a Python-style adapter
+    derives the package root from ``package_name`` when one is set; an adapter with no
+    package concept simply reads ``source_root``).
+    """
+    layout = getattr(lang_profile, "layout", None)
+    source_sets = tuple(getattr(layout, "source_sets", ()) or ()) if layout is not None else ()
+    test_sets = tuple(getattr(layout, "test_sets", ()) or ()) if layout is not None else ()
+    source_root = _norm(source_sets[0].root) if source_sets else "src"
+    test_root = _norm(test_sets[0].root) if test_sets else "tests"
+    source_root = source_root or "src"
+    test_root = test_root or "tests"
+    package_id = getattr(lang_profile, "id", "") or "app"
+    return LayoutProfile(
+        language=package_id,  # canonical id — carried for the contract re-resolve
+        package_name=package_id,
+        source_root=source_root,
+        package_root=source_root,
+        test_root=test_root,
+    )
+
+
+def _resolve_registry_oracle(
     language: str | None,
 ) -> tuple[LayoutProfile, ImplementOracleSpec] | None:
-    """Synthesize a composite ``(LayoutProfile, spec)`` from the registry, or None.
-
-    De-literalized (Contract Kernel oracle dispatch §5): the old hardcoded
-    ``{"go", "golang"}`` allowlist is gone. A language resolves to a synthesized
-    composite IFF :func:`_resolve_contract_oracle` returns a triple AND its oracle is
-    ``kind="composite"`` — i.e. a modeled COMPOSITE ``implement_oracle`` whose adapter
-    is REGISTERED. In practice this is Go (``go-toolchain``): it has NO legacy
-    ``LayoutProfile`` builder (``package_root.kind == none``), so it reaches here, and
-    we build a MINIMAL ``LayoutProfile`` carrying just ``language`` + the module root
-    (as ``source_root``) so the gate machinery (certify/run/retry) works unchanged;
-    the dispatch then routes its ``kind="composite"`` spec to the contract path
-    (:func:`_run_contract_oracle`). TS (``kind="command"``) and Python both HAVE legacy
-    ``LayoutProfile`` builders, so they never reach this synthesis path — and TS would
-    not match (it is ``command``, not ``composite``). ``None`` for any other language
-    (a stack with neither a legacy profile nor a composite contract oracle stays a
-    strict NO-OP). Best-effort: a registry error degrades to NO-OP (never a crash).
+    """Synthesize a gate-machinery ``(LayoutProfile, spec)`` from the registry, or None.
+
+    De-literalized + de-kind-allowlisted (Contract Kernel oracle dispatch §5 + §8):
+    BOTH the old hardcoded ``{"go", "golang"}`` language allowlist AND the old
+    ``kind == "composite"`` ONLY gate are gone. A language resolves to a synthesized
+    ``(LayoutProfile, spec)`` IFF :func:`_resolve_contract_oracle` returns a triple —
+    i.e. a modeled ``implement_oracle`` (ANY kind: composite / command / adapter)
+    whose adapter is REGISTERED — and it has NO legacy ``LayoutProfile`` builder (so it
+    reached here). The synthesized ``spec.kind`` MIRRORS the real declaration so the
+    SAME kind-routed dispatch in :func:`_run_oracle_command` runs the registered
+    adapter (composite/command → ``run_command_sequence``; adapter → the adapter's
+    ``execute``) — no kind allowlist, so a synthetic ``kind="command"``/``"adapter"``
+    language runs its oracle instead of falling to a silent NO-OP (the gap §8 closes).
+
+    LAYOUT VIEW per kind:
+
+    * ``command`` / ``composite`` (Go: ``go-toolchain``) — the command-sequence
+      executor reads cwd/env from ``lang_profile.layout`` (module root etc.), so the
+      synthetic ``LayoutProfile`` only needs to carry the module root (as
+      ``source_root``/etc.) + the canonical ``language`` for the contract re-resolve.
+    * ``adapter`` (a Python-style in-process composite with no legacy profile) — the
+      adapter reads ``source_root``/``test_root``/``package_root``/``package_name`` off
+      the layout VIEW, so we synthesize that view from ``LanguageProfile.layout`` via
+      :func:`synthesize_minimal_layout_view`.
+
+    In practice Go is the only BUILT-IN that reaches here (TS/Python HAVE legacy
+    ``LayoutProfile`` builders); the command/adapter branches exist so a NEW language
+    (the §8 synthetic-language proof) is addable with NO core change. ``None`` for any
+    language with neither a legacy profile nor a contract oracle (a strict NO-OP — step
+    9 will make a profile-present-but-oracle-absent case explicit RED; untouched here).
+    Best-effort: a registry error degrades to NO-OP (never a crash).
     """
     contract = _resolve_contract_oracle(language)
     if contract is None:
         return None
     lang_profile, oracle_decl, _adapter = contract
-    # Only a COMPOSITE oracle is synthesized into a LayoutProfile here (the legacy
-    # gate-machinery spec is composite-shaped); a command/adapter-kind contract
-    # oracle would route differently (none today).
-    if oracle_decl.kind != "composite":
-        return None
+    kind = getattr(oracle_decl, "kind", None)
+    if kind == "adapter":
+        # An in-process ``kind="adapter"`` oracle reads the richer layout view; build
+        # it from the profile's modeled layout (the compat-view synthesis).
+        synthetic = synthesize_minimal_layout_view(lang_profile)
+        synthetic = _with_implement_oracle(
+            synthetic,
+            ImplementOracleSpec(
+                command=f"{lang_profile.id}-adapter",  # sentinel; kind dispatch runs the contract path
+                kind="adapter",
+                # An adapter bakes its own scope policy in certify_scope; the spec scope
+                # is not the authority. Default both-required (the conservative, Python-
+                # composite-matching choice) — the adapter may still strengthen.
+                scope=OracleScopeSpec(require_source_root=True, require_test_root=True),
+                requires_node_install=False,
+            ),
+        )
+        return synthetic, synthetic.implement_oracle
+    # command / composite: a command-sequence oracle. Carry the module root for the
+    # commands' cwd; the executor reads argv/cwd/env from lang_profile.layout.
     module_root = _norm(getattr(lang_profile.layout, "module_root", ".") or ".") or "."
     synthetic = LayoutProfile(
         language=lang_profile.id,  # canonical id ("go") — carried for the contract re-resolve
@@ -1160,8 +1315,8 @@ def _resolve_registry_composite_oracle(
         package_root=module_root,
         test_root=module_root,
         implement_oracle=ImplementOracleSpec(
-            command=f"{lang_profile.id}-composite",  # sentinel; kind dispatch runs the contract path
-            kind="composite",
+            command=f"{lang_profile.id}-{kind}",  # sentinel; kind dispatch runs the contract path
+            kind=str(kind or "composite"),
             scope=OracleScopeSpec(require_source_root=True, require_test_root=False),
             requires_node_install=False,
         ),
@@ -1169,6 +1324,15 @@ def _resolve_registry_composite_oracle(
     return synthetic, synthetic.implement_oracle
 
 
+def _with_implement_oracle(
+    profile: LayoutProfile, spec: ImplementOracleSpec
+) -> LayoutProfile:
+    """Return ``profile`` with its ``implement_oracle`` set to ``spec`` (frozen-safe)."""
+    from dataclasses import replace
+
+    return replace(profile, implement_oracle=spec)
+
+
 #: The rerun callback the gate invokes to re-implement under the oracle feedback.
 #: ``scope is None`` ⇒ BROAD rerun (re-implement every task — the escalation
 #: fallback, the legacy behaviour). A non-None ``OracleRerunScope`` ⇒ a SCOPED
@@ -1239,11 +1403,76 @@ def run_implement_oracle_gate(
         profile=profile,
     )
     if resolved is None:
+        # No runnable oracle resolved — but WHY decides the verdict (§9). The 4-state
+        # model: a DECLARED-but-UNSUPPORTED stack is RED (never a silent pass); no
+        # declared stack OR an explicit opt-out is a NO-OP-WITH-TRACE (visible, non-RED).
+        state = classify_implement_oracle_state(language, config, resolved=resolved)
+        if state == ORACLE_STATE_UNSUPPORTED_EXPLICIT:
+            # The §9 closure: a non-empty language CoDD was told to build, with NO
+            # registered oracle adapter. CoDD cannot prove this stack's coherence, so it
+            # must NOT pass — an explicit unsupported RED, never a silent NO-OP.
+            echo(
+                f"[greenfield] implement-oracle: language {language!r} is declared but "
+                "UNSUPPORTED (no registered oracle adapter) — RED (a declared stack CoDD "
+                "cannot prove must not silently pass)."
+            )
+            return ImplementOracleResult(
+                passed=False,
+                executed=False,
+                command=f"{language}-oracle",
+                findings=[
+                    ImplementOracleFinding(
+                        category=EVIDENCE_ENVIRONMENT_BUILD,
+                        code="implement_oracle_unsupported",
+                        message=(
+                            f"no registered implement-oracle adapter for declared language "
+                            f"{language!r}; the implement-time coherence oracle cannot run, so "
+                            "the generated code's cross-artifact coherence is UNPROVEN. A "
+                            "declared-but-unsupported stack is RED, never a silent pass "
+                            "(add a LanguageProfile + oracle adapter for this stack, or opt "
+                            "out explicitly via implement.implement_oracle: false)."
+                        ),
+                    )
+                ],
+                detail=(
+                    f"declared-but-unsupported language {language!r}: no implement-time "
+                    "oracle adapter (unsupported → RED)"
+                ),
+            )
+        if state == ORACLE_STATE_OPT_OUT:
+            # The user explicitly opted out (implement.implement_oracle: false). NOT RED
+            # by default (preserves the documented opt-out contract; bounds blast radius),
+            # but the NO-OP is now VISIBLE + excluded from the release green-gate.
+            # [GPT §6 notes a stricter "RED in strict/greenfield" reading; we default to
+            # NO-OP-with-trace so opt-out is never silently broken. To make opt-out RED in
+            # strict mode instead, this branch would emit the unsupported RED above.]
+            echo(
+                "[greenfield] implement-oracle: opted out by config "
+                "(implement.implement_oracle=false) — skipped, excluded from the green-gate "
+                "(unsupported_oracle_allowed_by_config=true). NOT a proof."
+            )
+            return ImplementOracleResult(
+                passed=True,
+                executed=False,
+                command="",
+                detail=(
+                    "implement-time oracle opted out by config "
+                    "(implement.implement_oracle=false) — skipped, excluded from the "
+                    "green-gate (unsupported_oracle_allowed_by_config=true)"
+                ),
+            )
+        # LEGACY_ABSENT: no declared stack (language None/empty). Nothing to be
+        # "unsupported" about — a passing NO-OP, but VISIBLE (a fallback, not a proof),
+        # never silent.
+        echo(
+            "[greenfield] implement-oracle: no language declared — oracle skipped "
+            "(fallback, not a proof)."
+        )
         return ImplementOracleResult(
             passed=True,
             executed=False,
             command="",
-            detail=f"no implement-time oracle for language {language!r} (skipped)",
+            detail=f"no language declared — implement-time oracle skipped (fallback) [{language!r}]",
         )
     profile, spec = resolved
 

{codd_dev-2.81.0 → codd_dev-2.83.0}/pyproject.toml

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