codd-dev 2.1.0__tar.gz → 2.3.0__tar.gz

{codd_dev-2.1.0 → codd_dev-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 2.1.0
+Version: 2.3.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.1.0 → codd_dev-2.3.0}/codd/dag/builder.py

@@ -610,6 +610,29 @@ def _add_deployment_graph(
     )
     verification_tests = extract_verification_tests(project_root, project_config, design_docs)
 
+    from codd.deployment.extractor import discover_deployment_impl_candidates
+
+    capability_patterns = _capability_patterns(project_config)
+    for impl_path in discover_deployment_impl_candidates(project_root, deployment_docs):
+        rel_id = impl_path.relative_to(project_root).as_posix()
+        if rel_id in dag.nodes:
+            continue
+        _add_node_once(
+            dag,
+            Node(
+                id=rel_id,
+                kind="impl_file",
+                path=rel_id,
+                attributes={
+                    "language": _language_for_path(impl_path),
+                    "imports": [],
+                    "runtime_evidence": _runtime_evidence_for_file(impl_path, rel_id, capability_patterns),
+                    "auto_registered_for_deployment": True,
+                },
+            ),
+        )
+        impl_nodes[rel_id] = impl_path.resolve()
+
     for deployment_doc in deployment_docs:
         _add_node_once(
             dag,

{codd_dev-2.1.0 → codd_dev-2.3.0}/codd/deployment/extractor.py

@@ -31,6 +31,17 @@ SMOKE_TEST_PATTERNS = ("tests/smoke/*.test.ts", "tests/smoke/*.spec.ts", "tests/
 E2E_TEST_PATTERNS = ("tests/e2e/*.spec.ts", "tests/e2e/*.test.ts")
 RUNTIME_CAPABILITY_INFERENCE_DEFAULTS = Path(__file__).parent / "defaults" / "runtime_capability_inference.yaml"
 
+DEPLOYMENT_SECTION_IMPL_PATTERNS: dict[str, tuple[str, ...]] = {
+    "migrate": ("prisma/migrations/**/*", "schema.prisma", "**/migrations/**/*.sql"),
+    "seed": ("prisma/seed.ts", "prisma/seed.js", "scripts/seed.ts", "scripts/seed.js"),
+    "build": ("Dockerfile", "Containerfile", "package.json"),
+    "start": (
+        "main.ts", "main.js", "server.ts", "server.js",
+        "app.ts", "app.js", "index.ts", "index.js",
+        "src/main.ts", "src/main.js", "src/server.ts", "src/server.js",
+    ),
+}
+
 
 def extract_deployment_nodes(project_root: Path, codd_config: dict[str, Any] | None = None) -> dict[str, list]:
     """Extract deployment document, runtime state, and verification test nodes."""
@@ -181,6 +192,37 @@ def extract_verification_tests(
     return [tests[key] for key in sorted(tests)]
 
 
+def discover_deployment_impl_candidates(
+    project_root: Path,
+    deployment_docs: list[DeploymentDocNode],
+) -> list[Path]:
+    """Return existing standard impl artifacts referenced by deployment doc sections.
+
+    Walks each deployment document's sections and matches keywords against
+    DEPLOYMENT_SECTION_IMPL_PATTERNS, then keeps the patterns that resolve to a
+    real file under ``project_root``. The mapping itself stays inside the
+    deployment plug-in so DAG core code can remain free of stack-specific
+    filenames; this helper just runs an existence check.
+    """
+
+    root = Path(project_root)
+    seen: dict[str, Path] = {}
+    for doc in deployment_docs:
+        for section in doc.sections or []:
+            normalized = str(section).lower()
+            for keyword, patterns in DEPLOYMENT_SECTION_IMPL_PATTERNS.items():
+                if keyword not in normalized:
+                    continue
+                for pattern in patterns:
+                    for path in root.glob(pattern):
+                        if not path.is_file():
+                            continue
+                        rel = path.relative_to(root).as_posix()
+                        if rel not in seen:
+                            seen[rel] = path
+    return list(seen.values())
+
+
 def infer_deployment_edges(
     project_root: Path,
     deployment_docs: list[DeploymentDocNode],

{codd_dev-2.1.0 → codd_dev-2.3.0}/codd/elicit/apply.py

@@ -35,6 +35,7 @@ class ElicitApplyEngine:
         pending_path = self.elicit_dir / "pending_findings.yaml"
         history_path = self.elicit_dir / "elicit_history.yaml"
         findings_md_path = self.project_root / "findings.md"
+        requirements_path = _requirements_path(self.project_root)
 
         ignored_doc = _read_yaml_mapping(ignored_path, default_key="ignored")
         pending_doc = _read_yaml_mapping(pending_path, default_key="pending")
@@ -44,8 +45,12 @@ class ElicitApplyEngine:
         pending_entries = _list_value(pending_doc, "pending")
         history_entries = _list_value(history_doc, "sessions")
 
-        existing_ids = _existing_finding_ids(ignored_entries) | _existing_finding_ids(pending_entries)
-        accepted: list[Finding] = []
+        ignored_ids = _existing_finding_ids(ignored_entries)
+        pending_ids = _existing_finding_ids(pending_entries)
+        requirements_ids = _existing_ids_in_file(requirements_path)
+        accepted_for_requirements: list[Finding] = []
+        accepted_for_review: list[Finding] = []
+        pending_review: list[Finding] = []
         rejected: list[Finding] = []
         deferred: list[Finding] = []
         duplicates: list[Finding] = []
@@ -53,31 +58,60 @@ class ElicitApplyEngine:
         for finding in approved:
             decision = _finding_decision(finding)
             if decision == "reject":
+                _remove_finding_entry(pending_entries, finding.id)
+                pending_ids.discard(finding.id)
+                if finding.id in ignored_ids:
+                    duplicates.append(finding)
+                    continue
                 rejected.append(finding)
+                ignored_ids.add(finding.id)
                 continue
             if decision == "defer":
                 deferred.append(finding)
                 continue
-            if finding.id in existing_ids:
+            if decision == "pending":
+                if finding.id in ignored_ids or finding.id in requirements_ids:
+                    duplicates.append(finding)
+                    continue
+                if finding.id in pending_ids:
+                    duplicates.append(finding)
+                    continue
+                pending_review.append(finding)
+                pending_ids.add(finding.id)
+                continue
+            if _writes_requirements(finding):
+                if finding.id in ignored_ids or finding.id in requirements_ids:
+                    duplicates.append(finding)
+                    continue
+                _remove_finding_entry(pending_entries, finding.id)
+                pending_ids.discard(finding.id)
+                accepted_for_requirements.append(finding)
+                requirements_ids.add(finding.id)
+                continue
+            if finding.id in ignored_ids or finding.id in pending_ids or finding.id in requirements_ids:
                 duplicates.append(finding)
                 continue
-            accepted.append(finding)
-            existing_ids.add(finding.id)
+            accepted_for_review.append(finding)
+            pending_ids.add(finding.id)
 
         for finding in rejected:
             ignored_entries.append(_ignored_entry(finding, timestamp))
-        for finding in accepted:
+        for finding in [*accepted_for_review, *pending_review]:
             pending_entries.append(_pending_entry(finding, timestamp))
 
         history_entries.append(
             {
                 "timestamp": timestamp,
                 "findings_total": len(approved),
-                "approved": len(accepted),
+                "approved": len(accepted_for_requirements) + len(accepted_for_review),
                 "rejected": len(rejected),
                 "deferred": len(deferred),
+                "pending": len(pending_review),
                 "duplicates": len(duplicates),
-                "findings_md": "findings.md" if accepted else None,
+                "findings_md": "findings.md" if accepted_for_review else None,
+                "requirements_md": _relative_path(requirements_path, self.project_root)
+                if accepted_for_requirements
+                else None,
             }
         )
 
@@ -89,12 +123,16 @@ class ElicitApplyEngine:
         _write_yaml(history_path, {"sessions": history_entries})
         files_updated.append(_relative_path(history_path, self.project_root))
 
-        if accepted:
-            findings_md_path.write_text(MdFormatter().format(accepted), encoding="utf-8")
+        if accepted_for_requirements:
+            _append_requirements(requirements_path, accepted_for_requirements)
+            files_updated.append(_relative_path(requirements_path, self.project_root))
+
+        if accepted_for_review:
+            findings_md_path.write_text(MdFormatter().format(accepted_for_review), encoding="utf-8")
             files_updated.append(_relative_path(findings_md_path, self.project_root))
 
         return ApplyResult(
-            applied_count=len(accepted),
+            applied_count=len(accepted_for_requirements) + len(accepted_for_review) + len(pending_review),
             skipped_count=len(rejected) + len(deferred) + len(duplicates),
             files_updated=files_updated,
         )
@@ -128,17 +166,22 @@ def _findings_from_json(raw: str) -> list[Finding]:
 
 
 _FINDING_COMMENT_RE = re.compile(r"<!--\s*codd:finding\s*(.*?)\s*-->", re.DOTALL)
+_APPROVAL_LINE_RE = re.compile(
+    r"(?m)^-\s+approval:\s*\[([^\]]*)\]\s*`?([A-Za-z0-9][A-Za-z0-9_.:-]*)`?"
+)
 
 
 def _findings_from_markdown(raw: str) -> list[Finding]:
     findings = [Finding.from_dict(json.loads(match.group(1))) for match in _FINDING_COMMENT_RE.finditer(raw)]
     if findings:
-        return findings
+        approval_states = _approval_states_from_markdown(raw)
+        return [_with_approval_state(finding, approval_states.get(finding.id)) for finding in findings]
     return _findings_from_markdown_fields(raw)
 
 
 def _findings_from_markdown_fields(raw: str) -> list[Finding]:
     findings: list[Finding] = []
+    approval_states = _approval_states_from_markdown(raw)
     for section in re.split(r"(?m)^##\s+", raw)[1:]:
         fields: dict[str, Any] = {}
         for key in ("id", "kind", "severity", "name", "question", "rationale"):
@@ -148,10 +191,36 @@ def _findings_from_markdown_fields(raw: str) -> list[Finding]:
                 if value != "N/A":
                     fields[key] = value
         if fields:
-            findings.append(Finding.from_dict(fields))
+            finding = Finding.from_dict(fields)
+            findings.append(_with_approval_state(finding, approval_states.get(finding.id)))
     return findings
 
 
+def _approval_states_from_markdown(raw: str) -> dict[str, str]:
+    states: dict[str, str] = {}
+    for match in _APPROVAL_LINE_RE.finditer(raw):
+        state = match.group(1).strip().lower()
+        finding_id = match.group(2).strip().strip("`")
+        if state:
+            states[finding_id] = state
+    return states
+
+
+def _with_approval_state(finding: Finding, state: str | None) -> Finding:
+    if state is None:
+        return finding
+    details = dict(finding.details)
+    if state in {"x", "y", "yes", "approve", "approved"}:
+        details["approval"] = "approved"
+    elif state in {"r", "n", "no", "reject", "rejected"}:
+        details["approval"] = "rejected"
+    else:
+        details["approval"] = f"unknown:{state}"
+    payload = finding.to_dict()
+    payload["details"] = details
+    return Finding.from_dict(payload)
+
+
 def _utc_timestamp() -> str:
     return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
 
@@ -197,16 +266,93 @@ def _existing_finding_ids(entries: list[Any]) -> set[str]:
     return ids
 
 
+def _remove_finding_entry(entries: list[Any], finding_id: str) -> None:
+    entries[:] = [
+        entry
+        for entry in entries
+        if _entry_finding_id(entry) != finding_id
+    ]
+
+
+def _entry_finding_id(entry: Any) -> str | None:
+    if not isinstance(entry, dict):
+        return None
+    if "id" in entry:
+        return str(entry["id"])
+    finding = entry.get("finding")
+    if isinstance(finding, dict) and "id" in finding:
+        return str(finding["id"])
+    return None
+
+
 def _finding_decision(finding: Finding) -> str:
     raw = finding.details.get("decision", finding.details.get("approval", "approve"))
     value = str(raw).strip().lower()
-    if value in {"reject", "rejected", "no", "n"}:
+    if value.startswith("unknown:"):
+        return "pending"
+    if value in {"reject", "rejected", "no", "n", "r"}:
         return "reject"
-    if value in {"defer", "deferred", "later", "pending", "d"}:
+    if value in {"pending", "unchecked", "unreviewed"}:
+        return "pending"
+    if value in {"defer", "deferred", "later", "d"}:
         return "defer"
     return "approve"
 
 
+def _writes_requirements(finding: Finding) -> bool:
+    raw = finding.details.get("decision", finding.details.get("approval"))
+    if raw is None:
+        return False
+    return str(raw).strip().lower() in {"approve", "approved", "yes", "y", "x"}
+
+
+def _requirements_path(project_root: Path) -> Path:
+    candidates = [
+        project_root / "requirements.md",
+        project_root / "docs" / "requirements" / "requirements.md",
+        project_root / "docs" / "requirements.md",
+        project_root / ".codd" / "requirements.md",
+    ]
+    for candidate in candidates:
+        if candidate.exists():
+            return candidate
+    return candidates[0]
+
+
+def _existing_ids_in_file(path: Path) -> set[str]:
+    if not path.exists():
+        return set()
+    text = path.read_text(encoding="utf-8", errors="replace")
+    return set(re.findall(r"\[([A-Za-z0-9][A-Za-z0-9_.:-]*)\]", text))
+
+
+def _append_requirements(path: Path, findings: list[Finding]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    existing = path.read_text(encoding="utf-8") if path.exists() else ""
+    entries = "\n\n".join(_requirements_entry(finding) for finding in findings)
+    parts = [existing.rstrip()]
+    heading = "## TODO (codd elicit approved findings)"
+    if heading not in existing:
+        parts.extend(["", heading])
+    parts.extend(["", entries])
+    path.write_text("\n".join(part for part in parts if part != "").rstrip() + "\n", encoding="utf-8")
+
+
+def _requirements_entry(finding: Finding) -> str:
+    lines = [f"- [ ] TODO [{finding.id}] {_summary(finding)}"]
+    if finding.question:
+        lines.append(f"  - Question: {finding.question}")
+    if finding.rationale:
+        lines.append(f"  - Rationale: {finding.rationale}")
+    if finding.related_requirement_ids:
+        lines.append(f"  - Related requirements: {', '.join(finding.related_requirement_ids)}")
+    return "\n".join(lines)
+
+
+def _summary(finding: Finding) -> str:
+    return finding.name or finding.question or finding.rationale or finding.id
+
+
 def _ignored_entry(finding: Finding, timestamp: str) -> dict[str, Any]:
     return {
         "id": finding.id,

{codd_dev-2.1.0 → codd_dev-2.3.0}/codd/elicit/engine.py

@@ -35,9 +35,16 @@ class ElicitEngine:
 
     def run(self, project_root: Path, lexicon_config: Any | None = None) -> ElicitResult:
         root = Path(project_root)
+        project_scope, project_phase = _project_scope_phase(root)
         prompt = self.build_prompt(root, lexicon_config=lexicon_config)
         raw_output = self.invoke(prompt, root)
         result = self.deserialize_result(raw_output)
+        result.findings = _apply_scope_phase(
+            result.findings,
+            lexicon_config=lexicon_config,
+            scope=project_scope,
+            phase=project_phase,
+        )
         result.findings = ElicitPersistence(root).filter_known(result.findings)
         if not result.findings and result.lexicon_coverage_report:
             non_gap = all(
@@ -173,6 +180,151 @@ def _existing_axes_text(project_root: Path) -> str:
     return yaml.safe_dump(values, sort_keys=False, allow_unicode=True).strip()
 
 
+def _project_scope_phase(project_root: Path) -> tuple[str, str]:
+    for name in ("project_lexicon.yaml", "project_lexicon.yml"):
+        path = project_root / name
+        if not path.is_file():
+            continue
+        payload = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+        if not isinstance(payload, Mapping):
+            return "full", "production"
+        return (
+            str(payload.get("scope") or "full"),
+            str(payload.get("phase") or "production"),
+        )
+    return "full", "production"
+
+
+def _apply_scope_phase(
+    findings: list[Finding],
+    *,
+    lexicon_config: Any | None,
+    scope: str,
+    phase: str,
+) -> list[Finding]:
+    axis_concerns = _axis_concern_map(lexicon_config)
+    severity_rules = _mapping_attr(lexicon_config, "severity_rules")
+    filtered: list[Finding] = []
+    for finding in findings:
+        axis = _finding_axis(finding)
+        concern = axis_concerns.get(axis) if axis is not None else None
+        if not _scope_allows_concern(scope, concern):
+            continue
+        _apply_phase_severity(
+            finding,
+            axis=axis,
+            concern=concern,
+            phase=phase,
+            scope=scope,
+            severity_rules=severity_rules,
+        )
+        filtered.append(finding)
+    return filtered
+
+
+def _axis_concern_map(lexicon_config: Any | None) -> dict[str, str]:
+    concerns: dict[str, str] = {}
+    for axis in _list_attr(lexicon_config, "coverage_axes"):
+        if not isinstance(axis, Mapping):
+            continue
+        axis_type = axis.get("axis_type")
+        concern = axis.get("concern")
+        if isinstance(axis_type, str) and isinstance(concern, str):
+            concerns[axis_type] = concern.strip().lower()
+    return concerns
+
+
+def _finding_axis(finding: Finding) -> str | None:
+    for key in ("dimension", "axis", "axis_type"):
+        value = finding.details.get(key)
+        if isinstance(value, str) and value.strip():
+            return value.strip()
+    return None
+
+
+def _scope_allows_concern(scope: str, concern: str | None) -> bool:
+    if concern is None:
+        return True
+    scope_value = scope.strip().lower()
+    concern_value = concern.strip().lower()
+    if scope_value == "system_implementation":
+        return concern_value in {"system", "both"}
+    if scope_value == "business_only":
+        return concern_value in {"business", "both"}
+    return True
+
+
+def _apply_phase_severity(
+    finding: Finding,
+    *,
+    axis: str | None,
+    concern: str | None,
+    phase: str,
+    scope: str,
+    severity_rules: Mapping[str, Any],
+) -> None:
+    phase_value = phase.strip().lower()
+    concern_value = (concern or "").strip().lower()
+    context = {
+        "axis": axis or "",
+        "dimension": axis or "",
+        "concern": concern_value,
+        "phase": phase_value,
+        "scope": scope.strip().lower(),
+        "severity": finding.severity,
+    }
+    if _apply_matching_severity_rule(finding, context, severity_rules):
+        return
+    if phase_value == "mvp" and concern_value == "business" and finding.severity != "info":
+        finding.severity = "info"
+
+
+def _apply_matching_severity_rule(
+    finding: Finding,
+    context: Mapping[str, str],
+    severity_rules: Mapping[str, Any],
+) -> bool:
+    rules = severity_rules.get("rules", [])
+    if not isinstance(rules, list):
+        return False
+    for rule in rules:
+        if not isinstance(rule, Mapping):
+            continue
+        when = rule.get("when")
+        severity = rule.get("severity")
+        if not isinstance(when, str) or not isinstance(severity, str):
+            continue
+        if _condition_matches(when, context):
+            _set_severity(finding, severity)
+            return True
+    return False
+
+
+def _condition_matches(condition: str, context: Mapping[str, str]) -> bool:
+    parts = [
+        part.strip()
+        for part in re.split(r"\bAND\b", condition, flags=re.IGNORECASE)
+        if part.strip()
+    ]
+    if not parts:
+        return False
+    for part in parts:
+        if "=" not in part:
+            return False
+        key_text, expected_text = part.split("=", 1)
+        key = key_text.strip().lower()
+        expected = expected_text.strip().lower()
+        if context.get(key, "").lower() != expected:
+            return False
+    return True
+
+
+def _set_severity(finding: Finding, severity: str) -> None:
+    cleaned = severity.strip().lower()
+    if cleaned in {"critical", "high", "medium", "info"}:
+        finding.severity = cleaned  # type: ignore[assignment]
+
+
 def _load_optional_codd_config(project_root: Path) -> dict[str, Any]:
     for dirname in ("codd", ".codd"):
         path = project_root / dirname / "codd.yaml"
@@ -237,6 +389,28 @@ def _string_attr(value: Any, name: str) -> str | None:
     return None
 
 
+def _mapping_attr(value: Any, name: str) -> Mapping[str, Any]:
+    candidate = getattr(value, name, None)
+    if isinstance(candidate, Mapping):
+        return candidate
+    if isinstance(value, Mapping):
+        candidate = value.get(name)
+        if isinstance(candidate, Mapping):
+            return candidate
+    return {}
+
+
+def _list_attr(value: Any, name: str) -> list[Any]:
+    candidate = getattr(value, name, None)
+    if isinstance(candidate, list):
+        return candidate
+    if isinstance(value, Mapping):
+        candidate = value.get(name)
+        if isinstance(candidate, list):
+            return candidate
+    return []
+
+
 def _unique_paths(paths: list[Path]) -> list[Path]:
     seen: set[Path] = set()
     unique: list[Path] = []

{codd_dev-2.1.0 → codd_dev-2.3.0}/codd/elicit/lexicon_loader.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 
@@ -18,6 +18,8 @@ class LexiconConfig:
     lexicon_name: str
     prompt_extension_content: str
     recommended_kinds: list[str]
+    coverage_axes: list[dict[str, Any]] = field(default_factory=list)
+    severity_rules: dict[str, Any] = field(default_factory=dict)
 
 
 def load_lexicon(lexicon_path: Path) -> LexiconConfig:
@@ -54,10 +56,18 @@ def load_lexicon(lexicon_path: Path) -> LexiconConfig:
         prompt_content = f"{base_prompt.rstrip()}\n\n{extension_body.lstrip()}"
 
     recommended_kinds = _load_recommended_kinds(recommended_kinds_path)
+    coverage_axes = _load_coverage_axes(manifest_dir, manifest)
+    severity_rules = _load_optional_mapping_file(
+        manifest_dir,
+        _optional_str(manifest.get("severity_rules")) or "severity_rules.yaml",
+        "severity_rules",
+    )
     return LexiconConfig(
         lexicon_name=lexicon_name,
         prompt_extension_content=prompt_content,
         recommended_kinds=recommended_kinds,
+        coverage_axes=coverage_axes,
+        severity_rules=severity_rules,
     )
 
 
@@ -154,3 +164,20 @@ def _load_recommended_kinds(path: Path) -> list[str]:
             raise LexiconLoadError(f"recommended_kinds contains duplicate entry: {kind}")
         kinds.append(kind)
     return kinds
+
+
+def _load_coverage_axes(base_dir: Path, manifest: dict[str, Any]) -> list[dict[str, Any]]:
+    lexicon_path_text = _optional_str(manifest.get("lexicon")) or "lexicon.yaml"
+    payload = _load_optional_mapping_file(base_dir, lexicon_path_text, "lexicon")
+    raw_axes = payload.get("coverage_axes", manifest.get("coverage_axes", []))
+    if not isinstance(raw_axes, list):
+        return []
+    return [dict(item) for item in raw_axes if isinstance(item, dict)]
+
+
+def _load_optional_mapping_file(base_dir: Path, declared_path: str, label: str) -> dict[str, Any]:
+    try:
+        path = _resolve_existing_path(base_dir, declared_path, label)
+    except LexiconLoadError:
+        return {}
+    return _load_yaml_mapping(path, label)

{codd_dev-2.1.0 → codd_dev-2.3.0}/codd/lexicon.py

@@ -13,6 +13,8 @@ import yaml
 SCHEMA_PATH = Path(__file__).parent / "templates" / "lexicon_schema.yaml"
 LEXICON_FILENAME = "project_lexicon.yaml"
 REQUIRED_ARTIFACT_SOURCES = {"ai_derived", "user_override", "default_template"}
+DEFAULT_SCOPE = "full"
+DEFAULT_PHASE = "production"
 
 
 @dataclass
@@ -92,6 +94,14 @@ class ProjectLexicon:
     def required_artifacts(self) -> list[dict[str, Any]]:
         return deepcopy(self._data.get("required_artifacts", []))
 
+    @property
+    def scope(self) -> str:
+        return str(self._data.get("scope") or DEFAULT_SCOPE)
+
+    @property
+    def phase(self) -> str:
+        return str(self._data.get("phase") or DEFAULT_PHASE)
+
     def set_coverage_decisions(self, decisions: list[AskItem]) -> None:
         self._data["coverage_decisions"] = [
             ask_item_to_dict(item)
@@ -293,6 +303,10 @@ def validate_lexicon(data: dict[str, Any]) -> None:
         if derived_from is not None and not isinstance(derived_from, list):
             raise LexiconError(f"required_artifacts derived_from must be a list: {artifact}")
 
+    for field_name in ("scope", "phase"):
+        if field_name in data and not isinstance(data[field_name], str):
+            raise LexiconError(f"{field_name} must be a string")
+
 
 def _load_schema() -> dict[str, Any]:
     data = yaml.safe_load(SCHEMA_PATH.read_text(encoding="utf-8"))

{codd_dev-2.1.0 → codd_dev-2.3.0}/codd/templates/extracted/schema-design.md.j2

@@ -67,6 +67,6 @@ Constraints:
 ## Prisma Enums
 
 {% for enum in prisma_enums -%}
-- `{{ enum.name }}`: {{ enum.values | join(", ") }}
+- `{{ enum.name }}`: {{ enum["values"] | join(", ") }}
 {% endfor %}
 {% endif %}

{codd_dev-2.1.0 → codd_dev-2.3.0}/codd/templates/lexicon_schema.yaml

@@ -10,6 +10,8 @@ optional_sections:
   - extractor_registry
   - coverage_decisions
   - required_artifacts
+  - scope
+  - phase
 
 required_artifact_source_values:
   - ai_derived