codd-dev 2.14.0__tar.gz → 2.16.0__tar.gz

{codd_dev-2.14.0 → codd_dev-2.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.14.0
+Version: 2.16.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
@@ -153,11 +153,13 @@ This is what lets CoDD ship one core that works for Next.js, Django, FastAPI, Ra
 
 ## 🧭 Roadmap
 
-- **v2.14.0 (current)** — 8 structural gaps closed (cmd_466 dogfood). Sidecar `<test>.codd.yaml` with `verified_by:` (C6) and `axis_matrix:` (C9); lexicon schema SSoT; completeness_audit batch; `scan.exclude` bug fix (−52% amber noise); `codd dag verify --auto-repair`; elicit mock-AI sentinel; AI timeout → 3600 s SSoT. Dogfood re-run: red 22 → 0. See [CHANGELOG](CHANGELOG.md).
-- **v2.13.0** — Opt-out protection: `OptOutPolicy` requires a `justification` + `expires_at` for every config-level opt-out (`ci.provider=none`, etc.). Silent SKIP abolished; severity preserved. `codd validate` reports policy violations. See [post-mortem](docs/post-mortems/optout_loophole.md).
-- **v2.12.0** — Test-completeness gates: C7 `actors_without_journeys` amber promotion + new C8 `ci_health` static check (workflow presence, trigger coverage, verification-in-workflow). See [post-mortem](docs/post-mortems/test_completeness_gap.md).
-- **v2.11.0** — Sprint-less `codd implement` (`--design <path> --output <dir>` directly; `implementation_plan.md` parser removed). See [migration guide](docs/migrations/v2.11.0-sprintless.md).
-- **v2.15.0 (next)** — C8 `ci_health` runtime mode (opt-in `ci.runtime_check: true`) polling the CI provider for latest-run-on-default-branch success.
+- **v2.16.0 (current)** — `codd fix [PHENOMENON]` — North Star entry-point 2 (cmd_468). Express a desired change in natural language; CoDD identifies affected design docs via Tier-1 lexicon + Tier-2 semantic scoring, updates them with LLM, runs the DAG verify gate. Full interactive HITL (candidate selection, ambiguity clarification, risk confirmation) with `--non-interactive` for CI. 66 new tests, 2908 total PASS, SKIP=0. See [CHANGELOG](CHANGELOG.md).
+- **v2.15.0** — `kind: common` for shared infrastructure (cmd_467). C5 amber −79.2% on dogfood LMS (125 → 26). `**` glob translator fix.
+- **v2.14.0** — 8 structural gaps closed (cmd_466 dogfood). Sidecar `<test>.codd.yaml` with `verified_by:` (C6) / `axis_matrix:` (C9); lexicon schema SSoT; completeness_audit batch; `scan.exclude` bug fix (−52%); `codd dag verify --auto-repair`; elicit mock-AI sentinel; AI timeout 3600 s SSoT. Red 22 → 0.
+- **v2.13.0** — Opt-out protection: `OptOutPolicy` requires `justification` + `expires_at`. Silent SKIP abolished; severity preserved.
+- **v2.12.0** — Test-completeness gates: C7 amber promotion + C8 `ci_health` static check.
+- **v2.11.0** — Sprint-less `codd implement` (`--design <path> --output <dir>` directly).
+- **v2.17.0 (next)** — impl/test auto-propagation from PHENOMENON (AC #8 completion); Codex wrapper for PHENOMENON mode.
 
 ---
 

{codd_dev-2.14.0 → codd_dev-2.16.0}/README.md

@@ -113,11 +113,13 @@ This is what lets CoDD ship one core that works for Next.js, Django, FastAPI, Ra
 
 ## 🧭 Roadmap
 
-- **v2.14.0 (current)** — 8 structural gaps closed (cmd_466 dogfood). Sidecar `<test>.codd.yaml` with `verified_by:` (C6) and `axis_matrix:` (C9); lexicon schema SSoT; completeness_audit batch; `scan.exclude` bug fix (−52% amber noise); `codd dag verify --auto-repair`; elicit mock-AI sentinel; AI timeout → 3600 s SSoT. Dogfood re-run: red 22 → 0. See [CHANGELOG](CHANGELOG.md).
-- **v2.13.0** — Opt-out protection: `OptOutPolicy` requires a `justification` + `expires_at` for every config-level opt-out (`ci.provider=none`, etc.). Silent SKIP abolished; severity preserved. `codd validate` reports policy violations. See [post-mortem](docs/post-mortems/optout_loophole.md).
-- **v2.12.0** — Test-completeness gates: C7 `actors_without_journeys` amber promotion + new C8 `ci_health` static check (workflow presence, trigger coverage, verification-in-workflow). See [post-mortem](docs/post-mortems/test_completeness_gap.md).
-- **v2.11.0** — Sprint-less `codd implement` (`--design <path> --output <dir>` directly; `implementation_plan.md` parser removed). See [migration guide](docs/migrations/v2.11.0-sprintless.md).
-- **v2.15.0 (next)** — C8 `ci_health` runtime mode (opt-in `ci.runtime_check: true`) polling the CI provider for latest-run-on-default-branch success.
+- **v2.16.0 (current)** — `codd fix [PHENOMENON]` — North Star entry-point 2 (cmd_468). Express a desired change in natural language; CoDD identifies affected design docs via Tier-1 lexicon + Tier-2 semantic scoring, updates them with LLM, runs the DAG verify gate. Full interactive HITL (candidate selection, ambiguity clarification, risk confirmation) with `--non-interactive` for CI. 66 new tests, 2908 total PASS, SKIP=0. See [CHANGELOG](CHANGELOG.md).
+- **v2.15.0** — `kind: common` for shared infrastructure (cmd_467). C5 amber −79.2% on dogfood LMS (125 → 26). `**` glob translator fix.
+- **v2.14.0** — 8 structural gaps closed (cmd_466 dogfood). Sidecar `<test>.codd.yaml` with `verified_by:` (C6) / `axis_matrix:` (C9); lexicon schema SSoT; completeness_audit batch; `scan.exclude` bug fix (−52%); `codd dag verify --auto-repair`; elicit mock-AI sentinel; AI timeout 3600 s SSoT. Red 22 → 0.
+- **v2.13.0** — Opt-out protection: `OptOutPolicy` requires `justification` + `expires_at`. Silent SKIP abolished; severity preserved.
+- **v2.12.0** — Test-completeness gates: C7 amber promotion + C8 `ci_health` static check.
+- **v2.11.0** — Sprint-less `codd implement` (`--design <path> --output <dir>` directly).
+- **v2.17.0 (next)** — impl/test auto-propagation from PHENOMENON (AC #8 completion); Codex wrapper for PHENOMENON mode.
 
 ---
 

{codd_dev-2.14.0 → codd_dev-2.16.0}/codd/cli.py

@@ -3333,6 +3333,7 @@ def risk(path: str):
 
 
 @main.command()
+@click.argument("phenomenon", nargs=-1)
 @click.option("--path", default=".", help="Project root directory")
 @click.option("--max-attempts", default=3, type=click.IntRange(min=1, max=10),
               help="Maximum fix attempts (default: 3)")
@@ -3345,32 +3346,73 @@ def risk(path: str):
 @click.option("--no-push", is_flag=True, help="Don't push fixes after successful fix")
 @click.option("--dry-run", is_flag=True, help="Show what would be fixed without making changes")
 @click.option("--ai-cmd", default=None, help="Override AI CLI command")
-def fix(path: str, max_attempts: int, test_results: str | None, ci_log: str | None,
-        ci_only: bool, local_only: bool, no_push: bool, dry_run: bool, ai_cmd: str | None):
-    """Fix test/build failures using AI guided by design documents.
+@click.option("--non-interactive", is_flag=True,
+              help="PHENOMENON mode: disable interactive prompts (use defaults)")
+@click.option("--on-ambiguity",
+              type=click.Choice(["abort", "default", "top1"]),
+              default="abort",
+              show_default=True,
+              help="PHENOMENON mode: behavior when candidates are ambiguous in --non-interactive")
+@click.option("--allow-delete", is_flag=True,
+              help="PHENOMENON mode: allow design_doc to lose existing acceptance criteria / user journeys")
+def fix(phenomenon: tuple[str, ...], path: str, max_attempts: int,
+        test_results: str | None, ci_log: str | None,
+        ci_only: bool, local_only: bool, no_push: bool, dry_run: bool,
+        ai_cmd: str | None, non_interactive: bool, on_ambiguity: str,
+        allow_delete: bool):
+    """Fix test/build failures or a user-described PHENOMENON.
 
     \b
-    Auto-detects failure source (in order):
+    Two modes:
+      codd fix                              # legacy: auto-detect failures
+      codd fix "ログインがわかりにくい"     # PHENOMENON mode
+
+    \b
+    Legacy mode (no positional argument) auto-detects failure source:
       1. Explicit --test-results / --ci-log files
       2. CI failures via `gh run view`
       3. Local test execution
-
-    Maps failures to relevant design documents via the dependency graph,
+    Maps failures to relevant design docs via the dependency graph,
     then invokes Claude Code to fix implementation code.
 
+    \b
+    PHENOMENON mode (with positional argument) drives the second entry
+    point of CoDD's north star: starting from a phenomenon the user wants
+    fixed, CoDD updates the design doc, propagates the change, and
+    verifies — the user touches nothing. Argument-less invocation
+    remains completely unchanged.
+
     \b
     Examples:
-      codd fix                     # auto-detect and fix
-      codd fix --ci                # fix latest CI failure
-      codd fix --local             # run tests locally and fix
-      codd fix --dry-run           # show plan without fixing
-      codd fix --no-push           # fix but don't push
+      codd fix                                          # auto-detect and fix
+      codd fix --ci                                     # fix latest CI failure
+      codd fix --local                                  # run tests locally and fix
+      codd fix --dry-run                                # show plan without fixing
+      codd fix --no-push                                # fix but don't push
+      codd fix "ログインエラーをわかりやすくしたい"     # PHENOMENON mode
+      codd fix "Button needs aria-label" --non-interactive
     """
-    from codd.fixer import run_fix
-
     project_root = Path(path).resolve()
     _require_codd_dir(project_root)
 
+    phenomenon_text = " ".join(phenomenon).strip()
+
+    if phenomenon_text:
+        _run_phenomenon_fix_cli(
+            project_root,
+            phenomenon_text,
+            ai_cmd=ai_cmd,
+            max_attempts=max_attempts,
+            non_interactive=non_interactive,
+            on_ambiguity=on_ambiguity,
+            allow_delete=allow_delete,
+            dry_run=dry_run,
+            push=not no_push,
+        )
+        return
+
+    from codd.fixer import run_fix
+
     if ci_only and local_only:
         click.echo("Error: --ci and --local are mutually exclusive.")
         raise SystemExit(1)
@@ -3427,6 +3469,87 @@ def fix(path: str, max_attempts: int, test_results: str | None, ci_log: str | No
         raise SystemExit(1)
 
 
+def _run_phenomenon_fix_cli(
+    project_root: Path,
+    phenomenon_text: str,
+    *,
+    ai_cmd: str | None,
+    max_attempts: int,
+    non_interactive: bool,
+    on_ambiguity: str,
+    allow_delete: bool,
+    dry_run: bool,
+    push: bool,
+) -> None:
+    """CLI adapter for the PHENOMENON-mode fix pipeline."""
+    from codd.fix import run_phenomenon_fix
+
+    if dry_run:
+        click.echo("🔍 Dry run — analyzing phenomenon without applying changes...")
+    click.echo(f"🩺 Phenomenon: {phenomenon_text}")
+
+    result = run_phenomenon_fix(
+        project_root,
+        phenomenon_text,
+        ai_command=ai_cmd,
+        non_interactive=non_interactive,
+        on_ambiguity=on_ambiguity,
+        max_attempts=max_attempts,
+        dry_run=dry_run,
+        push=push,
+        allow_delete=allow_delete,
+    )
+
+    if result.analysis is not None:
+        a = result.analysis
+        click.echo(
+            f"   intent={a.intent}, ambiguity={a.ambiguity_score:.2f}, "
+            f"subject_terms={a.subject_terms[:4]}"
+        )
+
+    if result.aborted:
+        click.echo(f"❌ Aborted: {result.abort_reason}")
+        raise SystemExit(1)
+
+    if result.selection is not None:
+        cands = result.selection.candidates
+        click.echo(f"   {len(cands)} candidate design doc(s) considered.")
+
+    if not result.attempts:
+        click.echo("ℹ️  No candidate produced a usable update.")
+        raise SystemExit(1)
+
+    applied_any = False
+    for att in result.attempts:
+        status = "✅" if att.applied else ("🔸" if att.aborted_reason == "dry_run: not applying" else "❌")
+        target_id = att.target.node_id if att.target else "(no target)"
+        click.echo(f"{status} Attempt {att.attempt} on {target_id}")
+        if att.update is not None and att.update.diff:
+            for line in att.update.diff.splitlines()[:40]:
+                click.echo(f"  {line}")
+            extra = len(att.update.diff.splitlines()) - 40
+            if extra > 0:
+                click.echo(f"  ... (+{extra} more diff lines)")
+        if att.risk is not None and att.risk.risky:
+            click.echo(f"  ⚠️ risk: {', '.join(att.risk.categories) or 'unspecified'} — {att.risk.summary}")
+        if att.aborted_reason:
+            click.echo(f"  reason: {att.aborted_reason}")
+        if att.applied:
+            applied_any = True
+
+    if dry_run:
+        click.echo("\n🔎 Dry run complete — no files were modified.")
+        return
+
+    if applied_any:
+        click.echo(f"\n✅ Updated {len(result.applied_paths)} design doc(s): "
+                   f"{', '.join(result.applied_paths)}")
+        click.echo("   Review the diff above and commit when satisfied.")
+    else:
+        click.echo("\n❌ No design doc was updated.")
+        raise SystemExit(1)
+
+
 @main.command()
 @click.option("--path", default=".", help="Project root directory")
 def policy(path: str):
@@ -5275,6 +5398,9 @@ def _dag_result_details(result: Any) -> list[str]:
             details.append(f"{key}: {rendered}")
         else:
             details.append(f"{key}: {value}")
+    common_count = _dag_result_value(result, "common_node_count")
+    if isinstance(common_count, int) and common_count > 0:
+        details.append(f"common_node_count: {common_count}")
     return details
 
 

{codd_dev-2.14.0 → codd_dev-2.16.0}/codd/dag/builder.py

@@ -125,11 +125,14 @@ def load_dag_settings(project_root: Path, settings: dict[str, Any] | None = None
     merged["test_suffixes"] = test_suffixes
     _apply_scan_patterns(merged, project_config)
     _apply_scan_patterns(merged, requested_settings)
+    _apply_common_node_patterns(merged, project_config)
+    _apply_common_node_patterns(merged, requested_settings)
     merged["coherence"] = _coherence_settings(project_config, requested_settings)
     merged["extraction"] = _extraction_settings(project_config, requested_settings)
     merged.setdefault("design_doc_patterns", [])
     merged.setdefault("impl_file_patterns", [])
     merged.setdefault("test_file_patterns", [])
+    merged.setdefault("common_node_patterns", [])
     # cmd_444 v2.11.0: implementation_plan.md is no longer the entry point.
     # `codd implement` now takes design_node + output_paths directly. Any
     # `plan_task_file` value present in legacy codd.yaml is silently ignored.
@@ -233,11 +236,16 @@ def _add_design_docs(dag: DAG, project_root: Path, settings: dict[str, Any]) ->
         metadata = extract_design_doc_metadata(md_path, frontmatter_alias=frontmatter_alias)
         attributes = metadata.get("attributes") or {}
         _validate_design_doc_journey_attributes(node_id, attributes)
+        node_kind = (
+            "common"
+            if _design_doc_declares_common(metadata.get("frontmatter"), attributes)
+            else "design_doc"
+        )
         _add_node_once(
             dag,
             Node(
                 id=node_id,
-                kind="design_doc",
+                kind=node_kind,
                 path=node_id,
                 attributes={
                     "frontmatter": metadata["frontmatter"],
@@ -260,6 +268,8 @@ def _add_impl_files(dag: DAG, project_root: Path, settings: dict[str, Any]) -> d
     impl_nodes: dict[str, Path] = {}
     capability_patterns = _capability_patterns(settings)
     implementation_suffixes = _suffix_tuple(settings.get("implementation_suffixes")) or LEGACY_IMPLEMENTATION_SUFFIXES
+    common_patterns = _common_node_patterns(settings)
+    project_root_resolved = Path(project_root).resolve()
     for file_path in _glob_project_paths(
         project_root,
         settings.get("impl_file_patterns", []),
@@ -273,11 +283,16 @@ def _add_impl_files(dag: DAG, project_root: Path, settings: dict[str, Any]) -> d
             continue
         node_id = _relative_id(file_path, project_root)
         impl_nodes[node_id] = file_path.resolve()
+        kind = "impl_file"
+        if common_patterns and _path_matches_any_pattern(
+            file_path, project_root_resolved, common_patterns
+        ):
+            kind = "common"
         _add_node_once(
             dag,
             Node(
                 id=node_id,
-                kind="impl_file",
+                kind=kind,
                 path=node_id,
                 attributes={
                     "language": _language_for_path(file_path),
@@ -292,6 +307,8 @@ def _add_impl_files(dag: DAG, project_root: Path, settings: dict[str, Any]) -> d
 def _add_test_files(dag: DAG, project_root: Path, settings: dict[str, Any]) -> dict[str, Path]:
     test_nodes: dict[str, Path] = {}
     test_suffixes = _suffix_tuple(settings.get("test_suffixes")) or LEGACY_TEST_SUFFIXES
+    common_patterns = _common_node_patterns(settings)
+    project_root_resolved = Path(project_root).resolve()
     for file_path in _glob_project_paths(
         project_root,
         settings.get("test_file_patterns", []),
@@ -301,11 +318,16 @@ def _add_test_files(dag: DAG, project_root: Path, settings: dict[str, Any]) -> d
             continue
         node_id = _relative_id(file_path, project_root)
         test_nodes[node_id] = file_path.resolve()
+        kind = "test_file"
+        if common_patterns and _path_matches_any_pattern(
+            file_path, project_root_resolved, common_patterns
+        ):
+            kind = "common"
         _add_node_once(
             dag,
             Node(
                 id=node_id,
-                kind="test_file",
+                kind=kind,
                 path=node_id,
                 attributes={
                     "language": _language_for_path(file_path),
@@ -1118,44 +1140,60 @@ def _path_matches_any_pattern(
     except ValueError:
         return False
     rel_text = relative.as_posix()
-    parts = relative.parts
 
     for pattern in patterns:
-        if fnmatch.fnmatch(rel_text, pattern):
+        if _glob_pattern_to_regex(pattern).match(rel_text):
             return True
-        # Honour shell-style "any depth" wildcards by stripping the outer
-        # ``**/`` and ``/**`` decorations and looking for the inner pattern
-        # against any path slice. Examples:
-        #   **/node_modules/**  -> "node_modules"  must appear as a path component
-        #   **/dist/**          -> "dist"          must appear as a path component
-        #   src/**/*.py         -> not stripped here; falls back to fnmatch above
-        inner = pattern
-        stripped = True
-        while stripped:
-            stripped = False
-            if inner.startswith("**/"):
-                inner = inner[3:]
-                stripped = True
-            if inner.endswith("/**"):
-                inner = inner[:-3]
-                stripped = True
-        if not inner or inner == pattern:
-            continue
-        if "/" not in inner and "*" not in inner:
-            if inner in parts:
-                return True
-            continue
-        # Inner still contains glob syntax: check every contiguous slice of
-        # the relative path against ``inner`` so e.g. ``a/b/c/d`` matches
-        # ``a/b`` or ``c/d`` etc.
-        for start in range(len(parts)):
-            for end in range(start + 1, len(parts) + 1):
-                candidate = "/".join(parts[start:end])
-                if fnmatch.fnmatch(candidate, inner):
-                    return True
     return False
 
 
+_GLOB_REGEX_CACHE: dict[str, "re.Pattern[str]"] = {}
+
+
+def _glob_pattern_to_regex(pattern: str) -> "re.Pattern[str]":
+    """Translate a glob pattern (with ``**`` recursion) into a regex.
+
+    Recognised tokens:
+
+    * ``**/`` — zero or more path segments (greedy across separators).
+    * ``**`` — anything (including ``/``); used at end of a pattern.
+    * ``*`` — any chars except ``/``.
+    * ``?`` — single char except ``/``.
+    * Anything else — literal.
+
+    Patterns such as ``**/dist/**`` match a path containing ``dist`` at any
+    depth, ``src/lib/**/*.ts`` matches both ``src/lib/x.ts`` and
+    ``src/lib/sub/x.ts``.
+    """
+
+    cached = _GLOB_REGEX_CACHE.get(pattern)
+    if cached is not None:
+        return cached
+
+    parts: list[str] = []
+    i = 0
+    n = len(pattern)
+    while i < n:
+        if pattern[i : i + 3] == "**/":
+            parts.append("(?:[^/]+/)*")
+            i += 3
+        elif pattern[i : i + 2] == "**":
+            parts.append(".*")
+            i += 2
+        elif pattern[i] == "*":
+            parts.append("[^/]*")
+            i += 1
+        elif pattern[i] == "?":
+            parts.append("[^/]")
+            i += 1
+        else:
+            parts.append(re.escape(pattern[i]))
+            i += 1
+    compiled = re.compile("^" + "".join(parts) + "$")
+    _GLOB_REGEX_CACHE[pattern] = compiled
+    return compiled
+
+
 def _expand_braces(pattern: str) -> list[str]:
     match = re.search(r"\{([^{}]+)\}", pattern)
     if not match:
@@ -1365,6 +1403,80 @@ def _capability_patterns(settings: dict[str, Any]) -> dict[str, Any]:
     return patterns if isinstance(patterns, dict) else {}
 
 
+def _apply_common_node_patterns(settings: dict[str, Any], config: dict[str, Any]) -> None:
+    """Capture ``common_node_patterns`` from project / requested config.
+
+    Recognises both ``common_node_patterns:`` at the top level (preferred,
+    sibling of ``scan:``) and ``scan.common_node_patterns:`` (nested under
+    scan for users who prefer to colocate scan-related knobs). Both feed
+    the same ``settings['common_node_patterns']`` list.
+    """
+
+    if not isinstance(config, dict):
+        return
+    patterns: list[str] = []
+    top = config.get("common_node_patterns")
+    if isinstance(top, list):
+        patterns.extend(
+            str(item) for item in top if isinstance(item, str) and item.strip()
+        )
+    scan = config.get("scan")
+    if isinstance(scan, dict):
+        nested = scan.get("common_node_patterns")
+        if isinstance(nested, list):
+            patterns.extend(
+                str(item) for item in nested if isinstance(item, str) and item.strip()
+            )
+    if patterns:
+        _extend_unique(settings, "common_node_patterns", patterns)
+
+
+def _design_doc_declares_common(
+    frontmatter: Any, attributes: Any
+) -> bool:
+    """Return True when a design doc opts into ``kind="common"`` via frontmatter.
+
+    Recognised keys (any one wins):
+    * ``codd.node_type`` (preferred, lives under the ``codd:`` block)
+    * top-level ``node_type`` (legacy / convenience)
+    """
+
+    for source in (frontmatter, attributes):
+        if not isinstance(source, dict):
+            continue
+        node_type = source.get("node_type")
+        if isinstance(node_type, str) and node_type.strip().lower() == "common":
+            return True
+        codd_block = source.get("codd")
+        if isinstance(codd_block, dict):
+            value = codd_block.get("node_type")
+            if isinstance(value, str) and value.strip().lower() == "common":
+                return True
+    return False
+
+
+def _common_node_patterns(settings: dict[str, Any]) -> list[str]:
+    """Return glob patterns that should be classified as ``kind='common'``.
+
+    Common nodes represent shared infrastructure (DB clients, middleware,
+    framework config, generated artifacts) that exist outside any single
+    design document's scope. They participate in the DAG so that change
+    impact can be traced, but they are exempt from C5 transitive_closure
+    unreachable_nodes since requiring every common file to have a parent
+    design_doc would force the entire codebase to be re-modelled as a tree.
+    """
+
+    raw = settings.get("common_node_patterns")
+    if not isinstance(raw, list):
+        return []
+    expanded: list[str] = []
+    for pattern in raw:
+        if not isinstance(pattern, str) or not pattern.strip():
+            continue
+        expanded.extend(_expand_braces(pattern.strip()))
+    return expanded
+
+
 def _runtime_evidence_for_file(file_path: Path, node_id: str, capability_patterns: dict[str, Any]) -> list[dict]:
     evidence = scan_capability_evidence(file_path, capability_patterns)
     absolute_prefix = f"{file_path.as_posix()}:"

{codd_dev-2.14.0 → codd_dev-2.16.0}/codd/dag/checks/transitive_closure.py

@@ -15,12 +15,20 @@ class TransitiveClosureResult:
     check_name: str = "transitive_closure"
     severity: str = "amber"
     unreachable_nodes: list[str] = field(default_factory=list)
+    common_node_count: int = 0
     passed: bool = True
 
 
 @register_dag_check("transitive_closure")
 class TransitiveClosureCheck:
-    """Report nodes unreachable from root design docs without blocking deploy."""
+    """Report nodes unreachable from root design docs without blocking deploy.
+
+    Nodes with ``kind == "common"`` (shared infrastructure declared via
+    ``common_node_patterns`` or frontmatter ``node_type: common``) are exempt
+    from unreachable detection. They participate in the DAG so change-impact
+    analysis still sees them, but they do not need to be the descendant of a
+    single design document.
+    """
 
     def __init__(self, dag=None, project_root: Path | None = None, settings: dict[str, Any] | None = None):
         self.dag = dag
@@ -45,8 +53,19 @@ class TransitiveClosureCheck:
         ]
 
         visited = self._reachable_from(dag, roots)
-        unreachable = [node_id for node_id in dag.nodes if node_id not in visited]
-        return TransitiveClosureResult(unreachable_nodes=unreachable, passed=True)
+        common_count = sum(
+            1 for node in dag.nodes.values() if node.kind == "common"
+        )
+        unreachable = [
+            node_id
+            for node_id, node in dag.nodes.items()
+            if node_id not in visited and node.kind != "common"
+        ]
+        return TransitiveClosureResult(
+            unreachable_nodes=unreachable,
+            common_node_count=common_count,
+            passed=True,
+        )
 
     def _reachable_from(self, dag, roots: list[str]) -> set[str]:
         visited: set[str] = set()

codd_dev-2.16.0/codd/fix/__init__.py

@@ -0,0 +1,22 @@
+"""CoDD fix — PHENOMENON-driven (operational feedback) mode.
+
+Implements the second entry point of CoDD's north star:
+"Given a phenomenon the user wants fixed, CoDD updates the design doc,
+implementation, and tests in one shot — the user touches nothing."
+
+The existing `codd fix` (argument-less, test/CI failure driven) is the
+first entry point. This package adds the second one as an additive,
+opt-in code path. The legacy run_fix() is not modified.
+"""
+
+from codd.fix.phenomenon_fixer import (
+    PhenomenonFixResult,
+    PhenomenonFixAttempt,
+    run_phenomenon_fix,
+)
+
+__all__ = [
+    "PhenomenonFixResult",
+    "PhenomenonFixAttempt",
+    "run_phenomenon_fix",
+]