codd-dev 2.97.0__tar.gz → 2.99.0__tar.gz

{codd_dev-2.97.0 → codd_dev-2.99.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.97.0
+Version: 2.99.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.97.0 → codd_dev-2.99.0}/codd/__init__.py

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "2.97.0"
+__version__ = "2.99.0"

{codd_dev-2.97.0 → codd_dev-2.99.0}/codd/implement_oracle.py

@@ -140,7 +140,6 @@ __all__ = [
     "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
@@ -617,11 +616,12 @@ def certify_oracle_scope(
     :func:`_resolve_contract_oracle` — with NO hardcoded language-name comparison
     (Cut Condition A; the legacy in-gate tsc certifier moved to the TS adapter).
 
-    For a ``kind="adapter"`` language (Python) the legacy ``LayoutProfile`` is handed
-    to the adapter as the layout VIEW (it reads ``source_root``/``test_root`` from it;
-    the ``LayoutSpec`` does not carry those). A command-sequence oracle (Go reads
-    ``module_root``; TS reads ``source_sets``/``test_sets``) reads from the resolved
-    ``LanguageProfile.layout`` (no override).
+    Cut A.3: the ``OracleContext.layout_profile`` is ALWAYS the resolved ``LayoutSpec``
+    (``lang_profile.layout``) — NO legacy ``LayoutProfile`` layout-VIEW override. A
+    ``kind="adapter"`` language (Python) derives its ``source_root``/``test_root`` from
+    the ``LayoutSpec`` (``source_sets``/``package_root`` template) + the gate-resolved
+    ``package_name`` carried on the context. A command-sequence oracle (Go reads
+    ``module_root``; TS reads ``source_sets``/``test_sets``) reads the SAME ``LayoutSpec``.
     """
     contract = _resolve_contract_oracle(profile.language)
     if contract is None:
@@ -637,15 +637,13 @@ def certify_oracle_scope(
     lang_profile, oracle_decl, adapter = contract
     from codd.languages.adapters.implement_oracle import OracleContext
 
-    layout_view = (
-        profile if getattr(oracle_decl, "kind", None) == "adapter" else lang_profile.layout
-    )
     ctx = OracleContext(
         project_root=project_root,
-        layout_profile=layout_view,
+        layout_profile=lang_profile.layout,
         language_profile=lang_profile,
         oracle=oracle_decl,
         config=None,
+        package_name=getattr(profile, "package_name", None),
     )
     return adapter.certify_scope(ctx)
 
@@ -995,7 +993,7 @@ def _run_contract_oracle(
     adapter: Any,
     config: Mapping[str, Any] | None,
     *,
-    layout_override: Any = None,
+    package_name: str | None = None,
 ) -> ImplementOracleResult:
     """Run a modeled oracle on the contract path (certify already done by caller).
 
@@ -1012,14 +1010,12 @@ def _run_contract_oracle(
       declared ``kind="adapter"`` with no ``execute`` is an incomplete contract →
       RED, never a silent pass).
 
-    ``layout_override`` lets a ``kind="adapter"`` language hand the adapter a RICHER
-    layout VIEW than the profile's ``LayoutSpec``: Python's ``python-composite``
-    reads ``source_root`` / ``test_root`` / ``package_root`` / ``package_name`` (the
-    legacy Python ``LayoutProfile`` carries them; ``LayoutSpec`` does not). Go's
-    command-sequence adapter still reads ``module_root`` from ``lang_profile.layout``
-    (``layout_override`` is ``None`` for it). The ``OracleContext.layout_profile``
-    field is duck-typed (the generic executor only reads ``module_root``/cwd/env from
-    it on the command-sequence path, which the adapter path does not take).
+    Cut A.3: ``OracleContext.layout_profile`` is ALWAYS ``lang_profile.layout`` (the
+    resolved ``LayoutSpec``) — there is NO legacy ``LayoutProfile`` layout-VIEW
+    override. A ``kind="adapter"`` language whose layout template carries
+    ``{package_name}`` (Python's ``src/{package_name}``) SUBSTITUTES the gate-resolved
+    ``package_name`` carried on the context; Go's command-sequence adapter reads
+    ``module_root`` from the same ``LayoutSpec`` (``package_name`` is ``None`` for it).
     """
     from codd.languages.adapters.implement_oracle import (
         OracleContext,
@@ -1029,10 +1025,11 @@ def _run_contract_oracle(
 
     ctx = OracleContext(
         project_root=project_root,
-        layout_profile=layout_override if layout_override is not None else lang_profile.layout,
+        layout_profile=lang_profile.layout,
         language_profile=lang_profile,
         oracle=oracle_decl,
         config=config,
+        package_name=package_name,
     )
 
     # Install preflight (language-free, BEFORE dispatch so run_command_sequence stays
@@ -1109,12 +1106,13 @@ def _run_oracle_command(
       in-process ``execute`` (compile + first-party import resolver + ``pytest
       --collect-only``).
 
-    For a ``kind="adapter"`` contract (Python) the legacy ``LayoutProfile`` is handed
-    to the adapter as the layout VIEW (``layout_override``): the Python adapter reads
-    ``source_root`` / ``test_root`` / ``package_root`` / ``package_name`` from it (the
-    profile's ``LayoutSpec`` does not carry those). A command-sequence oracle (Go reads
-    ``module_root``; TS reads ``source_sets``/``test_sets``) needs no override — it
-    reads from the resolved ``LanguageProfile.layout``.
+    Cut A.3: the ``OracleContext.layout_profile`` is ALWAYS the resolved ``LayoutSpec``
+    (``lang_profile.layout``) — the legacy ``LayoutProfile`` layout-VIEW override is
+    retired. The Python adapter derives its ``source_root`` / ``test_root`` /
+    ``package_root`` from the ``LayoutSpec`` (``source_sets`` / ``test_sets`` /
+    ``package_root`` template) + the gate-resolved ``package_name`` (carried on the
+    context, not a synthesized legacy profile). A command-sequence oracle (Go reads
+    ``module_root``; TS reads ``source_sets``/``test_sets``) reads the SAME ``LayoutSpec``.
 
     No contract resolves (an unsupported stack reaching here) → an honest
     ``environment_build_error`` RED, never a silent pass (anti-false-green).
@@ -1139,14 +1137,14 @@ def _run_oracle_command(
             detail=f"no contract oracle for language {profile.language!r}",
         )
     lang_profile, oracle_decl, adapter = contract
-    # A kind="adapter" oracle (Python) runs in-process and needs the richer legacy
-    # layout (source_root/test_root/package_root); hand it the gate's LayoutProfile as
-    # the layout view. A command-sequence oracle (Go/TS) reads from the profile's
-    # LayoutSpec → no override.
-    layout_override = profile if getattr(oracle_decl, "kind", None) == "adapter" else None
+    # Cut A.3: carry the gate-resolved canonical ``package_name`` (the legacy profile
+    # resolved it via ``resolve_canonical_package_name``) so a ``kind="adapter"`` oracle
+    # whose layout template carries ``{package_name}`` (Python's ``src/{package_name}``)
+    # can SUBSTITUTE it — instead of handing the adapter a legacy LayoutProfile layout
+    # view. No override mechanism; the layout authority is the LayoutSpec.
     return _run_contract_oracle(
         project_root, lang_profile, oracle_decl, adapter, config,
-        layout_override=layout_override,
+        package_name=getattr(profile, "package_name", None),
     )
 
 
@@ -1213,41 +1211,6 @@ def resolve_implement_oracle(
     return profile, profile.implement_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:
@@ -1265,16 +1228,21 @@ def _resolve_registry_oracle(
     ``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:
+    Cut A.3: the synthetic ``LayoutProfile`` is ONLY the gate's SPEC CARRIER (it
+    carries ``language`` for the contract re-resolve, ``package_name`` for the
+    context's ``{package_name}`` substitution, and the ``implement_oracle`` spec the
+    certify/run/retry machinery reads) — it is NEVER a layout AUTHORITY. The adapter
+    reads the real ``LayoutSpec`` off ``ctx.language_profile.layout`` (the
+    ``synthesize_minimal_layout_view`` compat-view bridge is retired):
 
     * ``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.
+      executor reads cwd/env from ``lang_profile.layout`` (module root etc.); the
+      synthetic ``LayoutProfile``'s ``source_root`` field is a vestigial carrier the
+      adapter does not read.
     * ``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`.
+      adapter derives its source/test/package roots from ``ctx.language_profile.layout``
+      (``source_sets``/``test_sets``/``package_root``) + ``ctx.package_name``; the
+      synthetic profile only carries ``package_name`` + the spec.
 
     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
@@ -1289,12 +1257,22 @@ def _resolve_registry_oracle(
     lang_profile, oracle_decl, _adapter = contract
     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(
+        # An in-process ``kind="adapter"`` oracle reads the LayoutSpec off the resolved
+        # LanguageProfile (Cut A.3 — no synthesized layout view). The synthetic profile
+        # is only the gate's spec carrier: ``language`` (contract re-resolve) +
+        # ``package_name`` (the context's ``{package_name}`` substitution) + the spec.
+        # The topology fields are required by the dataclass but VESTIGIAL here (the
+        # adapter never reads them — it uses ``ctx.language_profile.layout``); fill them
+        # from the LayoutSpec's first source-set so the carrier stays well-formed.
+        _src_sets = tuple(getattr(lang_profile.layout, "source_sets", ()) or ())
+        _carrier_root = _norm(_src_sets[0].root) if _src_sets else "src"
+        synthetic = LayoutProfile(
+            language=lang_profile.id,
+            package_name=lang_profile.id,
+            source_root=_carrier_root,
+            package_root=_carrier_root,
+            test_root="tests",
+            implement_oracle=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

{codd_dev-2.97.0 → codd_dev-2.99.0}/codd/languages/adapters/implement_oracle.py

@@ -55,9 +55,12 @@ class OracleContext:
 
     project_root: Path
     #: The resolved layout topology (``module_root`` / ``repo_root`` / ``manifest_root``
-    #: etc.). The generic executor substitutes these into a command's ``cwd``/``env``
-    #: placeholders before spawning. Held separately from ``language_profile`` (though
-    #: it is ``language_profile.layout``) so a caller can pass a layout VIEW.
+    #: / ``source_sets`` / ``test_sets`` / ``package_root``). It is ALWAYS the resolved
+    #: :class:`LayoutSpec` (``language_profile.layout``) — Cut A.3 retired the legacy
+    #: ``LayoutProfile`` layout-VIEW override: NO adapter reads a legacy
+    #: ``source_root``/``package_root`` off this field anymore (the Python adapter
+    #: derives its source/package/test roots from ``source_sets``/``package_root`` +
+    #: :attr:`package_name`, like the TS/Go adapters read ``source_sets``/``module_root``).
     layout_profile: LayoutSpec
     #: The resolved language contract the dispatch already produced — the adapter
     #: reads ``commands[command_id]`` from it; it NEVER re-resolves a language.
@@ -66,6 +69,15 @@ class OracleContext:
     oracle: ImplementOracleProfileSpec
     #: The run config (``implement.*`` knobs: timeouts, etc.). ``None`` ⇒ defaults.
     config: Mapping[str, Any] | None = None
+    #: The harness-owned RESOLVED package name (``resolve_canonical_package_name``:
+    #: config override → single top-level package on disk → project-name default).
+    #: The gate resolves it (it has ``project_name``); an adapter whose layout
+    #: template carries ``{package_name}`` (Python's ``src/{package_name}``)
+    #: SUBSTITUTES this — it is NOT the adapter's job to re-resolve a name. ``None``
+    #: when the stack's layout has no package-name placeholder (Go/TS): substituting
+    #: an absent ``{package_name}`` is a HARD FAIL, never a silent ``src`` fallback
+    #: (a wrong package_root is a false-green — Cut A.3 nuance).
+    package_name: str | None = None
 
 
 @dataclass(frozen=True)

{codd_dev-2.97.0 → codd_dev-2.99.0}/codd/languages/adapters/oracle_python.py

@@ -1345,13 +1345,20 @@ def _certify_python_tool_observability(
 # ═════════════════════════════════════════════════════════════════════════════
 # Layout reading (the Python-specific scope knowledge baked into the adapter).
 #
-# The OracleContext carries the legacy Python ``LayoutProfile`` as ``layout_profile``
-# (the gate passes it — it has ``source_root`` / ``test_root`` / ``package_root`` /
-# ``package_name``; ``LayoutSpec`` does not). Python's scope policy (require source_
-# root; test_root for the collect layer) is Python-specific knowledge → baked here,
-# not depending on a legacy OracleScopeSpec. ``require_test_root`` is True for the
-# Python composite (matches the legacy spec, ``OracleScopeSpec(require_source_root=
-# True, require_test_root=True)``).
+# Cut A.3: the adapter derives ``(source_root, package_root, test_root)`` from the
+# resolved ``LayoutSpec`` (``ctx.language_profile.layout`` — ``source_sets`` /
+# ``test_sets`` / ``package_root`` template) + the gate-resolved ``ctx.package_name``,
+# NOT from a legacy ``LayoutProfile.source_root`` layout VIEW (that bridge is gone).
+# This MIRRORS the TS adapter's ``_ts_layout_roots`` (reads ``layout.source_sets`` /
+# ``test_sets``), but with Python's named-package nuance: Python's single source-set
+# root is ``src/{package_name}`` (the PACKAGE dir), so the bare ``source_root`` is
+# the PARENT of the substituted ``package_root`` (``src/app`` → ``src``) — the import
+# index keys a module under ``package_root`` as ``<pkg>.mod`` and a flat module under
+# ``source_root`` outside it as a bare name, so the two roots are NOT interchangeable.
+#
+# Python's scope policy (require source root; require test root for the collect
+# layer) is Python-specific knowledge → baked here, not depending on a legacy
+# OracleScopeSpec.
 # ═════════════════════════════════════════════════════════════════════════════
 
 #: Python's composite oracle requires BOTH a source scope (the keystone resolver +
@@ -1361,20 +1368,126 @@ _REQUIRE_SOURCE_ROOT = True
 _REQUIRE_TEST_ROOT = True
 
 
-def _layout_roots(ctx: OracleContext) -> tuple[str, str, str]:
-    """``(source_root, package_root, test_root)`` from ctx's legacy Python layout.
+def _py_parent_dir(path: str) -> str:
+    """Parent directory of a POSIX relative path (``src/app`` → ``src``).
 
-    The gate builds the context with the legacy ``LayoutProfile`` (which carries
-    these). Defensive defaults mirror the Python profile's standard src-layout so a
-    minimal/synthetic layout view still anchors first-party classification.
+    Returns ``"."`` when there is no parent segment. Mirrors
+    :func:`codd.languages.compat._parent_dir` (the proven-byte-identical derivation):
+    a ``named_package`` layout always nests ``<src>/<pkg>``, so the legacy
+    ``source_root`` is the package_root's parent.
+    """
+    norm = _py_norm(path)
+    if "/" not in norm:
+        return "."
+    return norm.rsplit("/", 1)[0]
+
+
+def _py_layout_from_layout_spec(ctx: OracleContext) -> tuple[str, str, str]:
+    """``(source_root, package_root, test_root)`` derived from the resolved ``LayoutSpec``.
+
+    Cut A.3 (the Python oracle's layout AUTHORITY): the adapter reads the v3
+    ``LayoutSpec`` (``ctx.language_profile.layout``) + the gate-resolved
+    ``ctx.package_name``, NOT a legacy ``LayoutProfile.source_root``. Anti-false-green
+    is paramount — a silent wrong layout here is a false-green — so this is strict:
+
+    * **Multi-source-set / multi-(required-)test-set → HARD FAIL** (RED via
+      :class:`OracleScopeError`). Python declares exactly ONE source-set + ONE unit
+      test-set today; the import index + collect scope are single-root. Reading only
+      ``source_sets[0]`` would SILENTLY drop the v3 set-semantics (a dropped root =
+      unproven code = false-green), so >1 is an explicit unsupported RED, never a
+      silent first-root collapse. (Multi-root observe-all is a later increment +
+      Stage-5 poison test; this increment is behavior-preserving on single-root.)
+    * **package_root** = the ``package_root`` template with ``{package_name}``
+      SUBSTITUTED from ``ctx.package_name`` (``named_package`` → ``src/app``).
+    * **source_root** = the PARENT of ``package_root`` for ``named_package``
+      (``src/app`` → ``src``); the bare set root for ``path_root``.
+    * **test_root** = the single test-set's root (``tests``).
+    * **Unresolved ``{package_name}`` → HARD FAIL** (no ``src`` fallback): a leftover
+      ``{package_name}`` (gate did not resolve a name) means the package_root is
+      UNKNOWN; a ``src`` fallback would point the oracle at the wrong tree (the
+      biggest drift risk Cut A.3 flags) → RED, never a silent wrong package_root.
     """
-    layout = ctx.layout_profile
-    source_root = _py_norm(getattr(layout, "source_root", "") or "src") or "src"
-    package_root = _py_norm(getattr(layout, "package_root", "") or "")
-    test_root = _py_norm(getattr(layout, "test_root", "") or "tests") or "tests"
-    if not package_root:
-        package_name = getattr(layout, "package_name", "") or ""
-        package_root = f"{source_root}/{package_name}".strip("/") if package_name else source_root
+    layout = ctx.language_profile.layout
+    source_sets = tuple(getattr(layout, "source_sets", ()) or ())
+    test_sets = tuple(getattr(layout, "test_sets", ()) or ())
+
+    # Multi-set → hard-fail (never a silent first-root collapse — anti-false-green).
+    if len(source_sets) > 1:
+        raise OracleScopeError(
+            "python implement-time oracle cannot be certified: the resolved layout "
+            f"declares {len(source_sets)} source_sets "
+            f"({[s.id for s in source_sets]}), but the Python composite oracle is "
+            "single-source-root (its first-party import index + compile + collect "
+            "scope are rooted at ONE source tree). Observing only the first set would "
+            "SILENTLY drop the others (unproven code = false-green); a multi-source-set "
+            "Python layout is UNSUPPORTED by this oracle today (RED, never a silent "
+            "first-root collapse)."
+        )
+    # A REQUIRED (non-optional) test-set count > 1 is the same hazard for the collect
+    # scope. ``optional``/``colocated`` sets are not REQUIRED roots, so they do not
+    # trigger the hard-fail (the collect layer runs over the single required test root).
+    required_test_sets = tuple(s for s in test_sets if not getattr(s, "optional", False))
+    if len(required_test_sets) > 1:
+        raise OracleScopeError(
+            "python implement-time oracle cannot be certified: the resolved layout "
+            f"declares {len(required_test_sets)} required test_sets "
+            f"({[s.id for s in required_test_sets]}), but the Python composite oracle "
+            "collects a SINGLE test root. A multi-required-test-set Python layout is "
+            "UNSUPPORTED by this oracle today (RED, never a silent first-root collapse)."
+        )
+
+    pkg_spec = getattr(layout, "package_root", None)
+    pkg_kind = getattr(pkg_spec, "kind", "none")
+    pkg_path = getattr(pkg_spec, "path", None) or ""
+    package_name = ctx.package_name
+
+    def _subst(template: str) -> str:
+        """Substitute ``{package_name}``; a leftover placeholder is a HARD FAIL."""
+        rendered = template
+        if "{package_name}" in template:
+            if not package_name:
+                raise OracleScopeError(
+                    "python implement-time oracle cannot be certified: the layout "
+                    f"template {template!r} carries an UNRESOLVED '{{package_name}}' "
+                    "(the gate did not resolve a canonical package name), so the "
+                    "package_root is UNKNOWN. A 'src' fallback would point the oracle "
+                    "at the WRONG package tree (silent wrong layout = false-green) — "
+                    "this is a HARD FAIL, not a fallback. Ensure the project's package "
+                    "name resolves (project.package_name / a single top-level package "
+                    "on disk / the project name)."
+                )
+            rendered = template.replace("{package_name}", package_name)
+        if "{" in rendered and "}" in rendered:
+            # Any OTHER leftover placeholder ({module_path}, …) is equally undecidable.
+            raise OracleScopeError(
+                "python implement-time oracle cannot be certified: the layout template "
+                f"{template!r} has an unresolved placeholder after substitution "
+                f"({rendered!r}); the scope is undecidable (HARD FAIL, never a guess)."
+            )
+        return _py_norm(rendered)
+
+    if pkg_kind == "named_package":
+        if not pkg_path:
+            raise OracleScopeError(
+                "python implement-time oracle cannot be certified: package_root.kind="
+                "named_package but no path (the layout is incomplete; HARD FAIL)."
+            )
+        package_root = _subst(pkg_path)
+        source_root = _py_parent_dir(package_root)
+    elif pkg_kind == "path_root":
+        package_root = _subst(pkg_path) if pkg_path else ""
+        source_root = package_root
+    else:
+        # ``none`` (no single package root — Go) or unknown: derive the source root
+        # from the single source-set, package_root == source_root (no named package).
+        source_root = _subst(source_sets[0].root) if source_sets else "src"
+        package_root = source_root
+
+    if not source_root:
+        source_root = "src"
+    test_root = _subst(test_sets[0].root) if test_sets else "tests"
+    if not test_root:
+        test_root = "tests"
     return source_root, package_root, test_root
 
 
@@ -1449,10 +1562,11 @@ class PythonCompositeOracleAdapter:
         """Certify the Python oracle's concrete file-list covers the required root(s).
 
         Anti-false-green: a required source/test root with ZERO ``.py`` is a HARD
-        FAIL (:class:`OracleScopeError`, never a silent pass). Reads source_root /
-        test_root from ``ctx.layout_profile`` (the legacy Python LayoutProfile).
+        FAIL (:class:`OracleScopeError`, never a silent pass). Derives source_root /
+        test_root from the resolved ``LayoutSpec`` (``ctx.language_profile.layout`` +
+        ``ctx.package_name``) — Cut A.3: NO legacy ``LayoutProfile.source_root`` read.
         """
-        source_root, _package_root, test_root = _layout_roots(ctx)
+        source_root, _package_root, test_root = _py_layout_from_layout_spec(ctx)
         scope = _python_oracle_scope(ctx.project_root, source_root, test_root)
         missing_roots: list[str] = []
         if _REQUIRE_SOURCE_ROOT and not scope.source_files:
@@ -1485,9 +1599,11 @@ class PythonCompositeOracleAdapter:
         ``diagnostics=[]`` (no scoped Python rerun — the bounded loop falls to broad
         rerun, which is safe). Preserves EVERY tolerance precisely (third-party
         import tolerate, third-party-only collection tolerate, pytest-missing →
-        environment_build_error).
+        environment_build_error). Derives its roots from the resolved ``LayoutSpec``
+        (``ctx.language_profile.layout`` + ``ctx.package_name``) — Cut A.3: NO legacy
+        ``LayoutProfile.source_root`` read.
         """
-        source_root, package_root, test_root = _layout_roots(ctx)
+        source_root, package_root, test_root = _py_layout_from_layout_spec(ctx)
         project_root = ctx.project_root
         config = ctx.config
         scope = _python_oracle_scope(project_root, source_root, test_root)