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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.13.0
+Version: 2.14.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,11 @@ 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.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.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 (next)** — C8 `ci_health` runtime mode (opt-in `ci.runtime_check: true`) polling the CI provider for latest-run-on-default-branch success.
 
 ---
 

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

@@ -113,11 +113,11 @@ 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.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.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 (next)** — C8 `ci_health` runtime mode (opt-in `ci.runtime_check: true`) polling the CI provider for latest-run-on-default-branch success.
 
 ---
 

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

codd_dev-2.14.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.14.0}/codd/dag/builder.py

@@ -222,7 +222,11 @@ 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)
@@ -256,7 +260,11 @@ 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", [])):
+    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
@@ -284,7 +292,11 @@ 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", [])):
+    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)
@@ -1067,7 +1079,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 +1091,69 @@ 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()
+    parts = relative.parts
+
+    for pattern in patterns:
+        if fnmatch.fnmatch(rel_text, pattern):
+            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
 
 
 def _expand_braces(pattern: str) -> list[str]:
@@ -1306,6 +1384,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 +1407,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.14.0}/codd/dag/checks/user_journey_coherence.py

@@ -162,11 +162,9 @@ class UserJourneyCoherenceCheck(DagCheck):
                         design_doc.id,
                         lexicon_id=ref.removeprefix("lexicon:"),
                         required_by=f"design_doc.user_journeys[{journey_index}].expected_outcome_refs",
-                        suggested_lexicon_entry={
-                            "id": ref.removeprefix("lexicon:"),
-                            "journey": journey_name,
-                            "path": f"tests/e2e/{self._slug(journey_name)}.spec.ts",
-                        },
+                        suggested_lexicon_entry=self._build_suggested_lexicon_entry(
+                            ref, journey_name
+                        ),
                         human_review_required=self._human_review_required(design_doc, journey),
                     )
                 )
@@ -835,6 +833,39 @@ class UserJourneyCoherenceCheck(DagCheck):
         slug = re.sub(r"[^a-z0-9]+", "_", value.lower()).strip("_")
         return slug or "journey"
 
+    def _build_suggested_lexicon_entry(self, ref: str, journey_name: str) -> dict[str, Any]:
+        """Return a complete-shape lexicon entry suggestion.
+
+        Includes every field that ``codd require --completeness-audit``
+        validates so the suggestion can be appended to project_lexicon.yaml
+        in a single mechanical step (no audit ping-pong).
+        """
+
+        lexicon_id = ref.removeprefix("lexicon:")
+        scope = self._suggested_scope()
+        return {
+            "id": lexicon_id,
+            "title": self._suggested_title(journey_name),
+            "scope": scope,
+            "source": "default_template",
+            "journey": journey_name,
+            "path": f"tests/e2e/{self._slug(journey_name)}.spec.ts",
+        }
+
+    def _suggested_scope(self) -> str:
+        if isinstance(self.settings, dict):
+            scope = self.settings.get("scope")
+            if isinstance(scope, str) and scope.strip():
+                return scope.strip()
+        return "web_app"
+
+    @staticmethod
+    def _suggested_title(journey_name: str) -> str:
+        humanised = journey_name.replace("_", " ").strip()
+        if not humanised:
+            return "Journey E2E"
+        return f"{humanised.capitalize()} E2E"
+
 
 def result_to_dict(result: UserJourneyCoherenceResult) -> dict[str, Any]:
     return asdict(result)

codd_dev-2.14.0/codd/defaults.py

@@ -0,0 +1,32 @@
+"""Single source of truth for CoDD default values.
+
+All values here are chosen with the principle from
+``feedback_codd_default_values_policy``: a default that frequently fails
+in real use is a bug, not a default. Prefer "slow but works" over
+"fast but errors" for values like timeouts; users who want tighter
+limits override via env var or config.
+"""
+
+from __future__ import annotations
+
+
+# ---------------------------------------------------------------------------
+# AI invocation
+# ---------------------------------------------------------------------------
+
+#: Default subprocess timeout (seconds) for any CoDD-orchestrated AI call.
+#:
+#: Set to 3600s (1 hour). Heavy reasoning models with ``reasoning_effort=
+#: xhigh`` routinely take 5–20 minutes per call; the previous values of 300s
+#: and 1800s caused frequent ``TimeoutExpired`` failures in self-improvement
+#: experiments (cmd_465 Iteration 4). Override paths remain unchanged:
+#:
+#: * environment variable ``CODD_AI_TIMEOUT_SECONDS``
+#: * ``codd.yaml`` key ``llm.timeout_seconds``
+#: * legacy ``ai_timeout_seconds`` per-component config key
+AI_TIMEOUT_SECONDS: float = 3600.0
+
+
+__all__ = [
+    "AI_TIMEOUT_SECONDS",
+]

{codd_dev-2.13.0 → codd_dev-2.14.0}/codd/deployment/__init__.py

@@ -47,6 +47,15 @@ class VerificationTestNode:
     target: str
     verification_template_ref: str
     expected_outcome: Any = None
+    # Explicit "this test verifies these runtime_state identifiers" declarations
+    # parsed from sidecar YAML (``<test_path>.codd.yaml``). Used by
+    # ``infer_deployment_edges`` to add EDGE_VERIFIED_BY edges without relying
+    # on the legacy keyword-matching heuristic.
+    verified_by: list[str] = field(default_factory=list)
+    # Explicit (journey, axis_type, variant_id) coverage matrix parsed from
+    # the same sidecar. Consumed by C9 ``environment_coverage`` so a test
+    # asserts coverage without inlining the matrix in its source code.
+    axis_matrix: list[dict[str, Any]] = field(default_factory=list)
 
 
 EDGE_REQUIRES_DEPLOYMENT_STEP = "requires_deployment_step"

{codd_dev-2.13.0 → codd_dev-2.14.0}/codd/deployment/extractor.py

@@ -387,6 +387,19 @@ def infer_deployment_edges(
                     )
                 )
 
+    runtime_state_ids = {rs.identifier for rs in runtime_states}
+    for verification_test in verification_tests:
+        for state_id in verification_test.verified_by:
+            if state_id in runtime_state_ids:
+                edges.append(
+                    (
+                        state_id,
+                        verification_test.identifier,
+                        EDGE_VERIFIED_BY,
+                        {"source": "sidecar_declaration"},
+                    )
+                )
+
     for runtime_state in runtime_states:
         for verification_test in verification_tests:
             if _verification_matches_runtime(runtime_state, verification_test):
@@ -507,6 +520,10 @@ def verification_test_attributes(node: VerificationTestNode) -> dict[str, Any]:
         journey_name = node.expected_outcome.get("journey_name")
         if isinstance(journey_name, str) and journey_name:
             payload["journey_name"] = journey_name
+    # Pass sidecar declarations through unchanged so checks (C9 environment
+    # coverage, etc.) can inspect them via the node's attributes mapping.
+    payload["verified_by"] = list(node.verified_by)
+    payload["axis_matrix"] = list(node.axis_matrix)
     return payload
 
 
@@ -524,15 +541,54 @@ def _add_verification_test(
         return
     rel_path = _relative_id(path, project_root)
     identifier = f"verification:{kind.value}:{rel_path}"
+    sidecar = _load_verification_sidecar(path)
     tests[identifier] = VerificationTestNode(
         identifier=identifier,
         kind=kind,
         target=_verification_target(path),
         verification_template_ref=_verification_template_ref(path),
         expected_outcome={"source": rel_path},
+        verified_by=sidecar.get("verified_by", []),
+        axis_matrix=sidecar.get("axis_matrix", []),
     )
 
 
+def _load_verification_sidecar(test_path: Path) -> dict[str, Any]:
+    """Load opt-in YAML sidecar for a verification test.
+
+    The sidecar lives next to the test file as ``<test_path>.codd.yaml`` and
+    declares CoDD metadata that cannot be expressed inside the test file's
+    own source language (e.g. TypeScript .spec.ts files). Recognised keys:
+
+    * ``verified_by`` — list of runtime_state identifiers this test verifies
+    * ``axis_matrix`` — list of {journey, axis_type, variant_id} declarations
+    """
+
+    sidecar_path = test_path.with_suffix(test_path.suffix + ".codd.yaml")
+    if not sidecar_path.is_file():
+        return {}
+    try:
+        payload = yaml.safe_load(sidecar_path.read_text(encoding="utf-8")) or {}
+    except yaml.YAMLError:
+        return {}
+    if not isinstance(payload, dict):
+        return {}
+    result: dict[str, Any] = {}
+    raw_verified_by = payload.get("verified_by")
+    if isinstance(raw_verified_by, list):
+        result["verified_by"] = [
+            str(item).strip()
+            for item in raw_verified_by
+            if isinstance(item, str) and item.strip()
+        ]
+    raw_axis_matrix = payload.get("axis_matrix")
+    if isinstance(raw_axis_matrix, list):
+        result["axis_matrix"] = [
+            entry for entry in raw_axis_matrix if isinstance(entry, dict)
+        ]
+    return result
+
+
 def _add_cdp_browser_journey_tests(
     tests: dict[str, VerificationTestNode],
     design_docs: list | dict,

{codd_dev-2.13.0 → codd_dev-2.14.0}/codd/deployment/providers/ai_command.py

@@ -11,13 +11,14 @@ import subprocess
 from typing import Any, Callable, Mapping
 
 from codd.config import load_project_config
+from codd.defaults import AI_TIMEOUT_SECONDS as _DEFAULT_AI_TIMEOUT_SECONDS
 
 
 DEFAULT_AI_COMMAND = "ai"
-# Default 1800s (30 min): multi-lexicon elicit can chain 10+ lexicons at ~30s
-# each, so the legacy 120s default truncated long pipelines. Override via the
-# CODD_AI_COMMAND_TIMEOUT env var or `llm.timeout_seconds` in codd.yaml.
-DEFAULT_TIMEOUT_SECONDS = 1800.0
+# Default sourced from codd.defaults so every AI call site shares one SSoT
+# (see feedback_codd_default_values_policy). Override via the
+# CODD_AI_TIMEOUT_SECONDS env var or `llm.timeout_seconds` in codd.yaml.
+DEFAULT_TIMEOUT_SECONDS = _DEFAULT_AI_TIMEOUT_SECONDS
 
 RunCommand = Callable[..., subprocess.CompletedProcess[str]]
 

{codd_dev-2.13.0 → codd_dev-2.14.0}/codd/elicit/engine.py

@@ -20,6 +20,19 @@ from codd.elicit.persistence import ElicitPersistence
 DEFAULT_TEMPLATE_PATH = Path(__file__).parent / "templates" / "elicit_prompt_L0.md"
 DEFAULT_MAX_CONTEXT_CHARS = 24000
 
+# Sentinel commands that bypass AI invocation and return an empty,
+# well-formed elicit payload. Useful for AI-free integration tests and for
+# structural-findings-only runs in CI where AI cost matters.
+_MOCK_AI_COMMAND_SENTINELS = frozenset({"true", ":", "none", "mock"})
+_MOCK_AI_OUTPUT = '{"findings": [], "lexicon_coverage_report": {}}'
+
+
+def _is_mock_ai_command(ai_command: Any) -> bool:
+    if not isinstance(ai_command, str):
+        return False
+    stripped = ai_command.strip().lower()
+    return stripped in _MOCK_AI_COMMAND_SENTINELS
+
 
 class ElicitEngine:
     """Build an elicitation prompt, invoke an AI command, and parse findings."""
@@ -129,6 +142,8 @@ class ElicitEngine:
         return _replace_placeholders(template, replacements)
 
     def invoke(self, prompt: str, project_root: Path) -> str:
+        if _is_mock_ai_command(self.ai_command):
+            return _MOCK_AI_OUTPUT
         if callable(self.ai_command) and not hasattr(self.ai_command, "invoke"):
             return str(self.ai_command(prompt))
         if hasattr(self.ai_command, "invoke"):