codd-dev 2.28.0__tar.gz → 2.29.0__tar.gz

{codd_dev-2.28.0 → codd_dev-2.29.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.28.0
+Version: 2.29.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.28.0 → codd_dev-2.29.0}/codd/__init__.py

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "2.28.0"
+__version__ = "2.29.0"

{codd_dev-2.28.0 → codd_dev-2.29.0}/codd/defaults.yaml

@@ -171,13 +171,16 @@ implement:
   # implement task (or a declared harness/profile contract). An orphan (a file no
   # task owns) sits OUTSIDE the artifact-contract graph -- its repair scope and
   # write-fence are undecidable, so a non-deterministic SUT can keep mutating it
-  # invisibly. 'warn' (default) observes + reports orphans after implement but
-  # never blocks (the check is heuristic; a large behaviour change rolls out as
-  # warn). 'enforce' makes an orphan a hard stage failure. 'off' disables it. A
+  # invisibly. 'warn' observes + reports orphans after implement but never blocks
+  # (heuristic; the large behaviour change first rolled out as warn, validated on
+  # the dogfood zoo, then promoted). 'enforce' (default, owner-set 2026-06-15)
+  # makes an orphan a hard stage failure -- the orphan-artifact invariant. Scaffold
+  # /harness-owned files (vitest.config.ts, tsconfig.json, ...) are profile-owned
+  # and never flagged. 'off' disables it. A
   # legitimate helper a task wrote under its OWN output directory is adopted (it
   # is dir-owned), so the warn list should be small. Only active for stacks with
   # a declared implement-time oracle + a derivable owner index.
-  orphan_artifact_gate: warn
+  orphan_artifact_gate: enforce
   # Bounded wall-clock for ONE implement-oracle command run (seconds). tsc on a
   # fresh build is fast, but a cold first run can compile a large module graph.
   # Default 600.

{codd_dev-2.28.0 → codd_dev-2.29.0}/codd/greenfield/pipeline.py

@@ -925,19 +925,52 @@ class GreenfieldPipeline:
             return None
 
     def _oracle_manifest_paths(self, project_root: Path) -> tuple[str, ...]:
-        """Manifest/config files the write-fence always permits (they are shared).
-
-        A scoped rerun may legitimately touch the build manifest/config even when
-        no task "owns" it (e.g. adding a dependency the fix needs). Only files
-        that actually exist are listed, project-relative.
+        """Harness-owned shared files the write-fence permits + the orphan gate exempts.
+
+        Two roles, one list (both legitimate for the same files):
+          * **write-fence permit** — a scoped rerun may touch shared build
+            manifest/config even when no task "owns" it (e.g. adding a dependency
+            the fix needs).
+          * **orphan-gate escape hatch** (``extra_owned``) — a scaffolded config
+            is a generated artifact owned by the HARNESS contract, not a task, so
+            it must not be mis-flagged as an unowned orphan.
+
+        Sources, unioned: (1) the active stack's :class:`LayoutProfile`
+        ``harness_owned_scaffold_paths`` (e.g. TS ``vitest.config.ts`` /
+        ``tsconfig.json`` / ``package.json`` — the files the scaffolder creates),
+        derived language-agnostically from the profile; (2) a small fallback set of
+        common lockfiles a manager may have produced that the profile does not
+        enumerate. Only files that actually EXIST are returned, project-relative.
         """
-        candidates = (
-            "package.json",
-            "tsconfig.json",
-            "package-lock.json",
-            "pnpm-lock.yaml",
-            "yarn.lock",
-        )
+        candidates: list[str] = []
+
+        def _add(rel: str) -> None:
+            if rel and rel not in candidates:
+                candidates.append(rel)
+
+        # (1) Profile-declared scaffold contract (language-agnostic, single source).
+        try:
+            from codd.project_types import resolve_layout_profile
+
+            config, language, source_dirs, test_dirs = self._layout_inputs(project_root)
+            profile = resolve_layout_profile(
+                language=language,
+                project_name=self._layout_project_name(project_root, config),
+                source_dirs=source_dirs,
+                test_dirs=test_dirs,
+                config=config,
+                project_root=project_root,
+            )
+            if profile is not None:
+                for rel in profile.harness_owned_scaffold_paths():
+                    _add(rel)
+        except Exception as exc:  # noqa: BLE001 — escape hatch is best-effort; fall back to the static set.
+            self.echo(f"[greenfield] implement-oracle: scaffold-path contract unavailable ({exc}).")
+
+        # (2) Lockfile fallbacks not necessarily enumerated by the profile.
+        for name in ("package.json", "tsconfig.json", "package-lock.json", "pnpm-lock.yaml", "yarn.lock"):
+            _add(name)
+
         present: list[str] = []
         for name in candidates:
             if (project_root / name).is_file():

{codd_dev-2.28.0 → codd_dev-2.29.0}/codd/project_types.py

@@ -540,6 +540,55 @@ class LayoutProfile:
             ),
         }
 
+    def harness_owned_scaffold_paths(self) -> tuple[str, ...]:
+        """Project-relative files the harness SCAFFOLD owns (the contract escape hatch).
+
+        These are the files :func:`scaffold_layout` creates for this stack —
+        topology + config the SUT never "owns" via a task, yet which are
+        legitimate generated artifacts (the orphan-artifact invariant's "owned by
+        a task OR an explicit harness/profile contract" branch). The orphan-gate
+        and the scoped-rerun write-fence consult this list so a scaffold file
+        (e.g. TS ``vitest.config.ts`` / ``tsconfig.json``) is never mis-flagged as
+        an unowned orphan and never reverted by the fence.
+
+        Language-agnostic: each path is DERIVED from this profile's own fields
+        (the same values the scaffolder uses) + the toolchain manifest/lock
+        filenames, so a new stack inherits the contract by populating its profile,
+        with no per-language logic in the gate. The list is a STATIC declaration of
+        what the scaffolder *can* create (not what is present on disk); callers
+        that need only existing files filter by ``is_file()``.
+        """
+        paths: list[str] = []
+
+        def _add(rel: str) -> None:
+            norm = _norm_rel(rel)
+            if norm and norm not in paths:
+                paths.append(norm)
+
+        # Dependency manifest + lockfile(s) the toolchain contract owns
+        # (package.json / package-lock.json; pyproject.toml / uv.lock; …).
+        toolchain = self.toolchain_dependencies
+        if toolchain is not None:
+            _add(toolchain.manifest_filename)
+            for lock in toolchain.lock_filenames:
+                _add(lock)
+
+        if self.language == "python":
+            # _scaffold_python: pyproject + package <__init__>/<__main__> + test <__init__>.
+            _add(_PYPROJECT_FILENAME)
+            if self.requires_package_init:
+                _add(f"{self.package_root}/__init__.py")
+                _add(f"{self.package_root}/__main__.py")
+            if self.requires_test_init:
+                _add(f"{self.test_root}/__init__.py")
+        elif self.language in ("typescript", "node"):
+            # _scaffold_typescript: tsconfig + vitest config + package.json.
+            _add(_TSCONFIG_FILENAME)
+            _add(_VITEST_CONFIG_FILENAME)
+            _add(_PACKAGE_JSON_FILENAME)
+
+        return tuple(paths)
+
 
 def normalize_package_name(project_name: str | None, *, fallback: str = "app") -> str:
     """Derive a valid Python package identifier from a project name.

{codd_dev-2.28.0 → codd_dev-2.29.0}/pyproject.toml

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