codd-dev 2.13.0__tar.gz → 2.15.0__tar.gz

{codd_dev-2.13.0 → codd_dev-2.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.13.0
+Version: 2.15.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,12 @@ This is what lets CoDD ship one core that works for Next.js, Django, FastAPI, Ra
 
 ## 🧭 Roadmap
 
-- **v2.13.0 (current)** — 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.10.0** — Lexicon-driven completeness, 38 plug-ins, LLM-enhanced init, scope/phase filter, auto-repair across the full DAG.
-- **v2.14.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.15.0 (current)** — `kind: common` for shared infrastructure (cmd_467). Classify cross-cutting files (DB client, middleware, config) as `common` via `common_node_patterns:` glob or frontmatter. C5 amber −79.2% on dogfood LMS (125 → 26). `**` glob translator fix. See [CHANGELOG](CHANGELOG.md).
+- **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.16.0 (next)** — `codd fix [PHENOMENON]` — express a desired change in natural language; CoDD identifies affected design docs, updates them, updates implementation and tests, then verifies the DAG. Interactive mode included.
 
 ---
 

{codd_dev-2.13.0 → codd_dev-2.15.0}/README.md

@@ -113,11 +113,12 @@ This is what lets CoDD ship one core that works for Next.js, Django, FastAPI, Ra
 
 ## 🧭 Roadmap
 
-- **v2.13.0 (current)** — 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.10.0** — Lexicon-driven completeness, 38 plug-ins, LLM-enhanced init, scope/phase filter, auto-repair across the full DAG.
-- **v2.14.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.15.0 (current)** — `kind: common` for shared infrastructure (cmd_467). Classify cross-cutting files (DB client, middleware, config) as `common` via `common_node_patterns:` glob or frontmatter. C5 amber −79.2% on dogfood LMS (125 → 26). `**` glob translator fix. See [CHANGELOG](CHANGELOG.md).
+- **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.16.0 (next)** — `codd fix [PHENOMENON]` — express a desired change in natural language; CoDD identifies affected design docs, updates them, updates implementation and tests, then verifies the DAG. Interactive mode included.
 
 ---
 

{codd_dev-2.13.0 → codd_dev-2.15.0}/codd/cli.py

@@ -4890,7 +4890,28 @@ def dag_build(project_path: str, output_format: str, cache: bool, output: str |
     type=click.Choice(["text", "json"]),
     help="Output format",
 )
-def dag_verify(project_path: str, check_names: tuple[str, ...], output_format: str):
+@click.option(
+    "--auto-repair",
+    is_flag=True,
+    default=False,
+    help="Apply violation-output suggestions mechanically (e.g. append "
+    "suggested_lexicon_entry to project_lexicon.yaml). Implies a dry-run "
+    "preview unless --apply is also supplied.",
+)
+@click.option(
+    "--apply",
+    "apply_changes",
+    is_flag=True,
+    default=False,
+    help="Write changes to disk when --auto-repair is set. Default: dry run.",
+)
+def dag_verify(
+    project_path: str,
+    check_names: tuple[str, ...],
+    output_format: str,
+    auto_repair: bool,
+    apply_changes: bool,
+):
     """Run DAG completeness checks."""
     from codd.dag.runner import run_all_checks
 
@@ -4940,6 +4961,20 @@ def dag_verify(project_path: str, check_names: tuple[str, ...], output_format: s
             for result in opt_out_results:
                 click.echo(f"  - {_dag_result_name(result)}: {_dag_result_message(result)}")
 
+    if auto_repair:
+        from codd.dag.auto_repair import apply_auto_repair
+
+        outcome = apply_auto_repair(project_root, results, dry_run=not apply_changes)
+        click.echo("")
+        verb = "Would apply" if not apply_changes else "Applied"
+        click.echo(f"{verb} {len(outcome.applied)} repair(s):")
+        for action in outcome.applied:
+            click.echo(f"  - {action.description}")
+        if outcome.skipped:
+            click.echo(f"\nSkipped {len(outcome.skipped)} non-repairable violation(s):")
+            for action in outcome.skipped:
+                click.echo(f"  - {action.description}")
+
     raise SystemExit(1 if failed_red else 0)
 
 
@@ -5240,6 +5275,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.15.0/codd/dag/auto_repair.py

@@ -0,0 +1,164 @@
+"""Mechanical auto-repair for DAG-verify violations.
+
+Reads the violation output produced by ``codd dag verify`` and applies the
+``suggested_*`` payloads to the project's filesystem without invoking AI.
+
+Currently supported repair types:
+
+* ``missing_journey_lexicon`` — append the ``suggested_lexicon_entry`` to
+  ``project_lexicon.yaml`` under ``required_artifacts``.
+
+Repair types that need a project-specific anchor (e.g. ``no_plan_task_for_journey``
+which requires the user to choose which plan section gets the new outputs)
+are listed in ``RepairOutcome.skipped`` with a human-readable reason so the
+operator knows what still has to be done by hand.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Iterable
+
+import yaml
+
+
+@dataclass(frozen=True)
+class RepairAction:
+    description: str
+
+
+@dataclass
+class RepairOutcome:
+    applied: list[RepairAction] = field(default_factory=list)
+    skipped: list[RepairAction] = field(default_factory=list)
+
+
+def apply_auto_repair(
+    project_root: Path,
+    results: Iterable[Any],
+    *,
+    dry_run: bool = True,
+) -> RepairOutcome:
+    """Apply mechanical repairs derived from DAG verify violation output.
+
+    Parameters
+    ----------
+    project_root
+        Project root used to resolve relative file paths.
+    results
+        Iterable of DAG check result objects (or dicts) as returned by
+        ``codd.dag.runner.run_all_checks``.
+    dry_run
+        When True, the function reports what *would* be applied without
+        modifying the filesystem.
+    """
+
+    outcome = RepairOutcome()
+    suggested_entries: list[dict[str, Any]] = []
+
+    for result in results:
+        violations = _result_value(result, "violations") or []
+        if not isinstance(violations, list):
+            continue
+        for violation in violations:
+            if not isinstance(violation, dict):
+                continue
+            v_type = violation.get("type")
+            if v_type == "missing_journey_lexicon":
+                entry = violation.get("suggested_lexicon_entry")
+                if isinstance(entry, dict) and entry.get("id"):
+                    suggested_entries.append(entry)
+                else:
+                    outcome.skipped.append(
+                        RepairAction(
+                            description=(
+                                "missing_journey_lexicon without suggested_lexicon_entry; "
+                                "violation cannot be auto-repaired"
+                            )
+                        )
+                    )
+                continue
+            outcome.skipped.append(
+                RepairAction(
+                    description=f"{v_type or '<unknown>'} — no mechanical repair available",
+                )
+            )
+
+    if suggested_entries:
+        repaired_ids = _apply_lexicon_entries(
+            project_root, suggested_entries, dry_run=dry_run
+        )
+        for entry_id in repaired_ids:
+            verb = "would append" if dry_run else "appended"
+            outcome.applied.append(
+                RepairAction(
+                    description=(
+                        f"project_lexicon.yaml: {verb} required_artifacts entry "
+                        f"'{entry_id}'"
+                    )
+                )
+            )
+        skipped_existing = {entry["id"] for entry in suggested_entries} - set(repaired_ids)
+        for entry_id in sorted(skipped_existing):
+            outcome.skipped.append(
+                RepairAction(
+                    description=(
+                        f"project_lexicon.yaml: required_artifacts entry "
+                        f"'{entry_id}' already declared"
+                    )
+                )
+            )
+
+    return outcome
+
+
+def _apply_lexicon_entries(
+    project_root: Path,
+    entries: list[dict[str, Any]],
+    *,
+    dry_run: bool,
+) -> list[str]:
+    lexicon_path = project_root / "project_lexicon.yaml"
+    if not lexicon_path.is_file():
+        return []
+
+    payload = yaml.safe_load(lexicon_path.read_text(encoding="utf-8")) or {}
+    if not isinstance(payload, dict):
+        return []
+
+    required_artifacts = payload.get("required_artifacts")
+    if not isinstance(required_artifacts, list):
+        required_artifacts = []
+
+    existing_ids = {
+        entry.get("id")
+        for entry in required_artifacts
+        if isinstance(entry, dict) and entry.get("id")
+    }
+
+    added_ids: list[str] = []
+    for entry in entries:
+        entry_id = entry.get("id")
+        if not entry_id or entry_id in existing_ids:
+            continue
+        required_artifacts.append(dict(entry))
+        existing_ids.add(entry_id)
+        added_ids.append(entry_id)
+
+    if not added_ids:
+        return added_ids
+
+    payload["required_artifacts"] = required_artifacts
+    if not dry_run:
+        lexicon_path.write_text(
+            yaml.safe_dump(payload, sort_keys=False, allow_unicode=True),
+            encoding="utf-8",
+        )
+    return added_ids
+
+
+def _result_value(result: Any, key: str) -> Any:
+    if isinstance(result, dict):
+        return result.get(key)
+    return getattr(result, key, None)

{codd_dev-2.13.0 → codd_dev-2.15.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.
@@ -222,18 +225,27 @@ def _add_design_docs(dag: DAG, project_root: Path, settings: dict[str, Any]) ->
     design_docs: dict[str, dict[str, Any]] = {}
     aliases: dict[str, str] = {}
     frontmatter_alias = _frontmatter_alias_settings(settings)
-    for md_path in _glob_project_paths(project_root, settings.get("design_doc_patterns", [])):
+    for md_path in _glob_project_paths(
+        project_root,
+        settings.get("design_doc_patterns", []),
+        exclude_patterns=settings.get("scan_exclude_patterns"),
+    ):
         if not md_path.is_file():
             continue
         node_id = _relative_id(md_path, project_root)
         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"],
@@ -256,7 +268,13 @@ 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
-    for file_path in _glob_project_paths(project_root, settings.get("impl_file_patterns", [])):
+    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", []),
+        exclude_patterns=settings.get("scan_exclude_patterns"),
+    ):
         if (
             not file_path.is_file()
             or file_path.suffix not in implementation_suffixes
@@ -265,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),
@@ -284,16 +307,27 @@ 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
-    for file_path in _glob_project_paths(project_root, settings.get("test_file_patterns", [])):
+    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", []),
+        exclude_patterns=settings.get("scan_exclude_patterns"),
+    ):
         if not file_path.is_file() or file_path.suffix not in test_suffixes or not _is_test_file(file_path, project_root):
             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),
@@ -1067,7 +1101,11 @@ def _alias_candidates(import_ref: str, project_root: Path, aliases: dict[str, li
     return candidates
 
 
-def _glob_project_paths(project_root: Path, patterns: Any) -> list[Path]:
+def _glob_project_paths(
+    project_root: Path,
+    patterns: Any,
+    exclude_patterns: Any = None,
+) -> list[Path]:
     paths: dict[str, Path] = {}
     for pattern in _as_list(patterns):
         if not isinstance(pattern, str) or not pattern:
@@ -1075,7 +1113,85 @@ def _glob_project_paths(project_root: Path, patterns: Any) -> list[Path]:
         for expanded in _expand_braces(pattern):
             for path in project_root.glob(expanded):
                 paths[str(path.resolve())] = path.resolve()
-    return [paths[key] for key in sorted(paths)]
+    excludes = [
+        str(pattern)
+        for pattern in _as_list(exclude_patterns)
+        if isinstance(pattern, str) and pattern.strip()
+    ]
+    if not excludes:
+        return [paths[key] for key in sorted(paths)]
+    project_root_resolved = project_root.resolve()
+    filtered: list[Path] = []
+    for key in sorted(paths):
+        path = paths[key]
+        if _path_matches_any_pattern(path, project_root_resolved, excludes):
+            continue
+        filtered.append(path)
+    return filtered
+
+
+def _path_matches_any_pattern(
+    path: Path,
+    project_root: Path,
+    patterns: list[str],
+) -> bool:
+    try:
+        relative = path.resolve().relative_to(project_root)
+    except ValueError:
+        return False
+    rel_text = relative.as_posix()
+
+    for pattern in patterns:
+        if _glob_pattern_to_regex(pattern).match(rel_text):
+            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]:
@@ -1287,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()}:"
@@ -1306,6 +1496,11 @@ def _apply_scan_patterns(settings: dict[str, Any], config: dict[str, Any]) -> No
     source_dirs = _as_list(scan.get("source_dirs"))
     test_dirs = _as_list(scan.get("test_dirs"))
     doc_dirs = _as_list(scan.get("doc_dirs"))
+    exclude_patterns = [
+        str(pattern)
+        for pattern in _as_list(scan.get("exclude"))
+        if isinstance(pattern, str) and pattern.strip()
+    ]
 
     if source_dirs:
         _extend_unique(
@@ -1324,6 +1519,8 @@ def _apply_scan_patterns(settings: dict[str, Any], config: dict[str, Any]) -> No
         )
     if doc_dirs:
         _extend_unique(settings, "design_doc_patterns", _file_patterns_for_dirs(doc_dirs, (".md",)))
+    if exclude_patterns:
+        _extend_unique(settings, "scan_exclude_patterns", exclude_patterns)
 
 
 def _normalize_dag_section(section: dict[str, Any]) -> dict[str, Any]:

{codd_dev-2.13.0 → codd_dev-2.15.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()