codd-dev 2.35.0__tar.gz → 2.37.0__tar.gz

{codd_dev-2.35.0 → codd_dev-2.37.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.35.0
+Version: 2.37.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.35.0 → codd_dev-2.37.0}/codd/__init__.py

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "2.35.0"
+__version__ = "2.37.0"

{codd_dev-2.35.0 → codd_dev-2.37.0}/codd/defaults.yaml

@@ -189,6 +189,52 @@ implement:
   # (node stacks: npm/pnpm/yarn/bun -- so `tsc` + deps are materialized before
   # the typecheck). A cold cache can pull a large tree. Default 900.
   oracle_install_timeout_seconds: 900
+  # Broad-repair STRATEGY (incremental | legacy). When the implement-time oracle
+  # forces the BROAD rung (a wide-fan-out artifact -- a shared schema / barrel /
+  # public entrypoint imported by many files -- whose narrow repair would thrash),
+  # broad's EXECUTION is the question. 'incremental' (default) runs a BUDGETED
+  # RESIDUAL COHERENCE CAMPAIGN: re-implement only the shared exporter/supplier
+  # first, RE-RUN the whole-project oracle, then re-implement ONLY the importers it
+  # STILL proves broken (re-derived from the live residual diagnostics), in
+  # dependency order, bounded by a wall-clock budget + a recheck cap. Often the
+  # exporter fix alone clears every importer, so the whole project goes green
+  # WITHOUT re-implementing any consumer task. 'legacy' runs the old whole-project
+  # regeneration (re-implement EVERY task, ~17 tasks * ~40-50 min/attempt) -- which
+  # blew a 4h wall-clock on a strong SUT without converging. ANTI-FALSE-GREEN: in
+  # BOTH strategies the WHOLE-PROJECT oracle is the ONLY thing that can discharge
+  # the gate; a phase's local typecheck success proves nothing, and budget
+  # exhaustion / non-convergence / unresolved residual is an HONEST FAILURE with a
+  # partial-progress audit record, never a silent green.
+  oracle_broad_strategy: incremental
+  # Cumulative wall-clock budget for ONE broad CAMPAIGN, across all its phases
+  # (seconds). The campaign stops BEFORE starting a phase whose remaining budget
+  # could not also fit a verifying whole-project oracle recheck, then honest-fails
+  # (workspace changes persist for resume; never green). Default 2700 (45 min) --
+  # a residual campaign (1 supplier phase + a few importer phases) fits well
+  # inside it, vs the legacy-broad 4h blow-up. Only applies to the incremental
+  # strategy.
+  oracle_broad_wall_clock_seconds: 2700
+  # Cap on whole-project oracle RECHECKS within ONE broad campaign (each phase is
+  # followed by exactly one recheck -- the green authority). Bounds the campaign
+  # independent of the wall-clock so a fast-but-non-converging SUT still
+  # terminates. Default 8; minimum 1. Only applies to the incremental strategy.
+  oracle_broad_max_rechecks: 8
+  # Chunk size for the SUPPLIER phase of a broad campaign (how many supplier/
+  # exporter tasks to re-implement per supplier sub-phase). Default 1 -- the wide-
+  # fan-out artifact is typically a single shared module; one focused exporter fix
+  # is the highest-yield, lowest-cognitive-load step (especially for a weak SUT).
+  oracle_broad_chunk_size: 1
+  # Chunk size for the RESIDUAL IMPORTER phase (how many importer owner-tasks to
+  # re-implement per residual sub-phase). Default 2 -- residual importers are
+  # re-derived from the live diagnostics and repaired in dependency order; a small
+  # chunk keeps each rerun's allowed-paths surface and wall-clock bounded.
+  oracle_residual_chunk_size: 2
+  # Legacy whole-project broad opt-in (default false). true ⇒ a wide-fan-out
+  # artifact uses the OLD whole-project regeneration instead of the incremental
+  # campaign (equivalent to oracle_broad_strategy: legacy for the wide-fan-out
+  # trigger). Kept for parity / escape hatch; the incremental campaign is the
+  # default because legacy broad does not fit the wall-clock on real builds.
+  oracle_legacy_broad_enabled: false
   # Shared canonical output root for implement tasks WITHOUT an explicit
   # default_output_paths / implement_targets mapping (e.g. greenfield-derived
   # tasks). null = derive from scan.source_dirs[0] (usually "src/"). Every

{codd_dev-2.35.0 → codd_dev-2.37.0}/codd/greenfield/pipeline.py

@@ -1079,12 +1079,23 @@ class GreenfieldPipeline:
         except (FileNotFoundError, ValueError):
             config = {}
 
-        scoped = scope is not None and not bool(getattr(scope, "is_broad", lambda: False)())
-        if not scoped:
+        # A rerun is FENCED (scoped execution) when the scope carries non-empty
+        # ``allowed_paths`` — this covers a narrow/expanded scope AND a broad-CAMPAIGN
+        # PHASE scope (logically broad — rung=broad — but with a per-phase write-fence
+        # so the phase re-implements ONLY its tasks and out-of-scope writes revert).
+        # The LEGACY whole-project broad (scope None, OR is_broad() with NO
+        # allowed_paths and no repair_plan) re-implements every task UNFENCED.
+        scoped = scope is not None and bool(getattr(scope, "allowed_paths", ()) or ())
+        legacy_broad = scope is None or (
+            bool(getattr(scope, "is_broad", lambda: False)())
+            and not bool(getattr(scope, "allowed_paths", ()) or ())
+            and not getattr(scope, "repair_plan", None)
+        )
+        if legacy_broad or not scoped:
             self._reimplement_tasks(project_root, tasks, feedback, config)
             return
 
-        # Scoped rerun: only the scope's tasks, fenced to its allowed paths.
+        # Fenced rerun: only the scope's tasks, fenced to its allowed paths.
         target_ids = set(getattr(scope, "task_ids", ()) or ())
         scoped_tasks = [task for task in tasks if task.task_id in target_ids]
         if not scoped_tasks:
@@ -1104,16 +1115,25 @@ class GreenfieldPipeline:
         tasks: list[ImplementTaskRef],
         feedback: str,
         config: dict[str, Any],
-    ) -> None:
-        """Re-run ``implement_tasks`` for each given task carrying ``feedback``."""
+    ) -> dict[str, float]:
+        """Re-run ``implement_tasks`` for each given task carrying ``feedback``.
+
+        Returns ``{task_id: elapsed_seconds}`` so a broad-campaign caller can budget
+        + audit per-task cost. (The campaign's wall-clock gate measures elapsed
+        directly; the per-task map is the finer-grained record.)
+        """
+        import time
+
         from codd.implementer import implement_tasks
 
+        elapsed: dict[str, float] = {}
         for task in tasks:
             output_paths = (
                 list(task.output_paths)
                 if task.output_paths
                 else _output_paths_for_task(config, task)
             )
+            started = time.monotonic()
             implement_tasks(
                 project_root,
                 design=task.design_node,
@@ -1122,6 +1142,8 @@ class GreenfieldPipeline:
                 use_derived_steps=True,
                 feedback=feedback,
             )
+            elapsed[task.task_id] = time.monotonic() - started
+        return elapsed
 
     def _make_vb_rerun_callback(
         self,