codd-dev 1.20.0__tar.gz → 1.22.0__tar.gz

{codd_dev-1.20.0 → codd_dev-1.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 1.20.0
+Version: 1.22.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-1.20.0 → codd_dev-1.22.0}/codd/__init__.py

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "1.20.0"
+__version__ = "1.22.0"

codd_dev-1.22.0/codd/__main__.py

@@ -0,0 +1,7 @@
+"""Module entrypoint for ``python -m codd``."""
+
+from codd.cli import main
+
+
+if __name__ == "__main__":
+    main()

{codd_dev-1.20.0 → codd_dev-1.22.0}/codd/ask_user_question_adapter.py

@@ -13,6 +13,7 @@ from codd.lexicon import AskItem
 
 
 DEFAULT_CHANNELS = ["askuserquestion", "ntfy", "lexicon"]
+SEVERITY_ORDER = ["critical", "high", "medium", "low"]
 
 
 def send_ask_items(
@@ -20,6 +21,7 @@ def send_ask_items(
     channels: list[str] = DEFAULT_CHANNELS,
     ntfy_topic: str = "",
     lexicon_path: str | Path | None = None,
+    ntfy_severity_threshold: str = "critical",
 ) -> None:
     """Send ASK items through Claude, ntfy, and lexicon channels when available."""
     normalized_channels = {channel.lower() for channel in channels}
@@ -30,6 +32,8 @@ def send_ask_items(
 
     if "ntfy" in normalized_channels and ntfy_topic:
         for item in ask_items:
+            if not _severity_at_or_above(_ask_item_severity(item), ntfy_severity_threshold):
+                continue
             _post_ntfy(ntfy_topic, format_ask_for_ntfy(item))
 
     if "lexicon" in normalized_channels and lexicon_path is not None:
@@ -65,6 +69,21 @@ def parse_user_answer(raw: str, item: AskItem) -> str:
     return answer
 
 
+def _severity_at_or_above(item_severity: str, threshold: str) -> bool:
+    """Return True when item_severity is at least as severe as threshold."""
+    try:
+        return SEVERITY_ORDER.index(item_severity) <= SEVERITY_ORDER.index(threshold)
+    except ValueError:
+        return True
+
+
+def _ask_item_severity(item: AskItem) -> str:
+    severity = getattr(item, "severity", "")
+    if isinstance(severity, str) and severity:
+        return severity.lower()
+    return "critical" if item.blocking else "high"
+
+
 def _send_ask_user_question(item: AskItem) -> bool:
     """Best-effort hook for Claude Code AskUserQuestion integrations."""
     try:

{codd_dev-1.20.0 → codd_dev-1.22.0}/codd/cli.py

@@ -1,5 +1,6 @@
-"""CoDD CLI — codd init / scan / impact / require / plan."""
-
+"""CoDD CLI — codd init / scan / impact / require / plan."""
+
+from dataclasses import asdict, is_dataclass
 import json
 import os
 import shutil
@@ -189,14 +190,86 @@ def _ensure_bootstrap_codd_yaml(
 
 @click.group()
 @click.version_option(package_name="codd-dev")
-def main():
-    """CoDD: Coherence-Driven Development."""
-    pass
-
-
-@main.command()
-@click.option("--project-name", prompt="Project name", help="Name of the project")
-@click.option("--language", prompt="Primary language", help="Primary language (python/typescript/javascript/go — full support; java — symbols only)")
+def main():
+    """CoDD: Coherence-Driven Development."""
+    pass
+
+
+@main.command("preflight")
+@click.argument("task_yaml", type=click.Path(exists=True, dir_okay=False, path_type=Path))
+@click.option("--path", "project_path", default=".", help="Project root directory")
+@click.option("--strict", is_flag=True, help="Treat high severity as halt-worthy")
+@click.option("--ntfy-topic", default="", help="ntfy topic for critical alerts")
+@click.option(
+    "--ntfy-severity-threshold",
+    default=None,
+    help="Minimum severity sent to ntfy (default: codd.yaml preflight.ntfy_severity_threshold or critical)",
+)
+def preflight(task_yaml: Path, project_path: str, strict: bool, ntfy_topic: str, ntfy_severity_threshold: str | None):
+    """Run preflight checks on a task YAML before autonomous execution."""
+    _run_preflight_command(task_yaml, project_path, strict, ntfy_topic, ntfy_severity_threshold)
+
+
+@main.command("gungi")
+@click.argument("task_yaml", type=click.Path(exists=True, dir_okay=False, path_type=Path))
+@click.option("--path", "project_path", default=".", help="Project root directory")
+@click.option("--strict", is_flag=True, help="Treat high severity as halt-worthy")
+@click.option("--ntfy-topic", default="", help="ntfy topic for critical alerts")
+@click.option(
+    "--ntfy-severity-threshold",
+    default=None,
+    help="Minimum severity sent to ntfy (default: codd.yaml preflight.ntfy_severity_threshold or critical)",
+)
+def gungi(task_yaml: Path, project_path: str, strict: bool, ntfy_topic: str, ntfy_severity_threshold: str | None):
+    """Alias for preflight."""
+    _run_preflight_command(task_yaml, project_path, strict, ntfy_topic, ntfy_severity_threshold)
+
+
+def _run_preflight_command(
+    task_yaml: Path,
+    project_path: str,
+    strict: bool,
+    ntfy_topic: str,
+    ntfy_severity_threshold: str | None,
+) -> None:
+    from codd.ask_user_question_adapter import _post_ntfy, _severity_at_or_above
+    from codd.preflight import PreflightAuditor
+
+    project_root = Path(project_path).resolve()
+    auditor = PreflightAuditor(project_root=project_root)
+    result = auditor.run(task_yaml)
+    strict_halt = strict and result.severity == "high"
+    if strict_halt:
+        result.halt_recommended = True
+
+    threshold = ntfy_severity_threshold or str(
+        auditor.preflight_config.get("ntfy_severity_threshold") or "critical"
+    )
+    if ntfy_topic and _severity_at_or_above(result.severity, threshold):
+        result.ntfy_sent = _post_ntfy(ntfy_topic, _format_preflight_ntfy(result))
+
+    for check in result.checks:
+        click.echo(f"[{check.status}] {check.name}: {check.message}")
+        for detail in check.details:
+            click.echo(f"  - {detail}")
+    click.echo(f"Overall severity: {result.severity}")
+    click.echo(f"ntfy_sent: {str(result.ntfy_sent).lower()}")
+
+    if result.halt_recommended:
+        reason = "strict high severity" if strict_halt else "critical issue found"
+        click.echo(f"HALT recommended: {reason}")
+        raise SystemExit(1)
+
+
+def _format_preflight_ntfy(result: Any) -> str:
+    failed = [check.name for check in result.checks if check.status in {"FAIL", "WARN"}]
+    suffix = f" ({', '.join(failed)})" if failed else ""
+    return f"CoDD preflight: {result.task_id} severity={result.severity}{suffix}"
+
+
+@main.command()
+@click.option("--project-name", prompt="Project name", help="Name of the project")
+@click.option("--language", prompt="Primary language", help="Primary language (python/typescript/javascript/go — full support; java — symbols only)")
 @click.option("--dest", default=".", help="Destination directory (default: current dir)")
 @click.option(
     "--requirements",
@@ -239,7 +312,7 @@ def init(project_name: str, language: str, dest: str, requirements: str | None,
     _render_template("gitignore.tmpl", codd_dir / ".gitignore", {})
 
     # Version file
-    (dest_path / ".codd_version").write_text("0.2.0\n")
+    (dest_path / ".codd_version").write_text("0.2.0\n", encoding="utf-8")
 
     # Import requirements if provided
     if requirements:
@@ -1197,7 +1270,7 @@ def repair_slice_cmd(path, files, issue, issue_file, language, source_dirs, top_
 
     issue_text = issue or ""
     if issue_file and not issue_text:
-        issue_text = Path(issue_file).read_text(errors="ignore")
+        issue_text = Path(issue_file).read_text(encoding="utf-8", errors="ignore")
 
     dirs = [d.strip() for d in source_dirs.split(",") if d.strip()] if source_dirs else None
 
@@ -1353,8 +1426,21 @@ def validate(lexicon: bool, design_tokens: bool, screen_flow: bool, edges: bool,
     type=float,
     help="Lexicon compliance threshold percentage.",
 )
+@click.option(
+    "--screen-flow-threshold",
+    default=100.0,
+    show_default=True,
+    type=float,
+    help="Screen-flow coverage threshold percentage.",
+)
 @click.option("--json", "as_json", is_flag=True, help="Output machine-readable JSON.")
-def coverage(path: str, e2e_threshold: float, lexicon_threshold: float, as_json: bool):
+def coverage(
+    path: str,
+    e2e_threshold: float,
+    lexicon_threshold: float,
+    screen_flow_threshold: float,
+    as_json: bool,
+):
     """Coverage metrics merge gate: E2E, design tokens, and lexicon."""
     from codd.coverage_metrics import run_coverage
 
@@ -1364,6 +1450,7 @@ def coverage(path: str, e2e_threshold: float, lexicon_threshold: float, as_json:
         e2e_threshold=e2e_threshold,
         design_token_threshold=0.0,
         lexicon_threshold=lexicon_threshold,
+        screen_flow_threshold=screen_flow_threshold,
     )
 
     if as_json:
@@ -2079,7 +2166,7 @@ def measure(path: str, as_json: bool):
 
 @main.command("mcp-server")
 @click.option("--project", default=".", help="Project root directory")
-def mcp_server(project: str):
+def mcp_server(project: str):
     """Start MCP server for AI tool integration (stdio).
 
     Exposes CoDD tools (validate, impact, policy, audit, scan) via the
@@ -2092,14 +2179,205 @@ def mcp_server(project: str):
     from codd.mcp_server import run_stdio
 
     project_root = Path(project).resolve()
-    _require_codd_dir(project_root)
-    run_stdio(project_root)
-
-
-@main.group()
-def hooks():
-    """Manage Git hook integration."""
-    pass
+    _require_codd_dir(project_root)
+    run_stdio(project_root)
+
+
+@main.group()
+def dag():
+    """DAG Completeness Gate commands."""
+    pass
+
+
+@dag.command("build")
+@click.option("--path", "project_path", default=".", help="Project root directory")
+@click.option(
+    "--format",
+    "output_format",
+    default="json",
+    type=click.Choice(["json", "mermaid"]),
+    help="Output format",
+)
+@click.option("--cache", is_flag=True, help="Use cached DAG if output exists")
+@click.option("--output", default=None, help="Output file (default: .codd/dag.json or .codd/dag.mmd)")
+def dag_build(project_path: str, output_format: str, cache: bool, output: str | None):
+    """Build the project DAG and output it under .codd/."""
+    from codd.dag.builder import (
+        build_dag,
+        default_dag_json_path,
+        default_dag_mermaid_path,
+        write_dag_json,
+        write_dag_mermaid,
+    )
+
+    project_root = Path(project_path).resolve()
+    default_output = default_dag_json_path(project_root) if output_format == "json" else default_dag_mermaid_path(project_root)
+    output_path = Path(output).expanduser() if output else default_output
+    if not output_path.is_absolute():
+        output_path = project_root / output_path
+
+    if cache and output_path.exists():
+        click.echo(f"Using cached DAG: {_display_path(output_path, project_root)}")
+        return
+
+    try:
+        built_dag = build_dag(project_root)
+    except (FileNotFoundError, ValueError) as exc:
+        click.echo(f"Error: {exc}")
+        raise SystemExit(1)
+
+    if output_format == "json":
+        if output_path != default_dag_json_path(project_root):
+            write_dag_json(built_dag, project_root, output_path)
+    else:
+        write_dag_mermaid(built_dag, output_path)
+
+    click.echo(
+        "Built DAG: "
+        f"{len(built_dag.nodes)} nodes, "
+        f"{len(built_dag.edges)} edges, "
+        f"{len(built_dag.detect_cycles())} cycles -> "
+        f"{_display_path(output_path, project_root)}"
+    )
+
+
+@dag.command("verify")
+@click.option("--project-path", "--path", default=".", show_default=True, help="Project root directory")
+@click.option("--check", "check_names", multiple=True, help="Run specific check(s) only")
+@click.option(
+    "--format",
+    "output_format",
+    default="text",
+    type=click.Choice(["text", "json"]),
+    help="Output format",
+)
+def dag_verify(project_path: str, check_names: tuple[str, ...], output_format: str):
+    """Run DAG completeness checks."""
+    from codd.dag.runner import run_all_checks
+
+    project_root = Path(project_path).resolve()
+    try:
+        results = run_all_checks(project_root, check_names=list(check_names) or None)
+    except (FileNotFoundError, ValueError) as exc:
+        click.echo(f"Error: {exc}")
+        raise SystemExit(1)
+
+    failed_red = [
+        result
+        for result in results
+        if not _dag_result_passed(result) and _dag_result_severity(result) == "red"
+    ]
+    amber_findings = [
+        result
+        for result in results
+        if _dag_result_severity(result) == "amber" and _dag_result_has_findings(result)
+    ]
+
+    if output_format == "json":
+        click.echo(json.dumps([_dag_result_to_dict(result) for result in results], indent=2, default=str))
+    else:
+        for result in results:
+            severity = _dag_result_severity(result)
+            if _dag_result_passed(result):
+                status = "PASS"
+            else:
+                status = "WARN" if severity == "amber" else "FAIL"
+            click.echo(f"  {status}  {_dag_result_name(result)} [{severity}]")
+            for detail in _dag_result_details(result):
+                click.echo(f"    {detail}")
+
+        if failed_red:
+            click.echo(f"\n{len(failed_red)} check(s) FAILED (severity=red)")
+        elif amber_findings:
+            click.echo(f"\n{len(amber_findings)} check(s) WARN (severity=amber, deploy allowed)")
+
+    raise SystemExit(1 if failed_red else 0)
+
+
+@dag.command("visualize")
+@click.option("--project-path", "--path", default=".", show_default=True, help="Project root directory")
+def dag_visualize(project_path: str):
+    """Build and print the project DAG as Mermaid."""
+    from codd.dag.builder import build_dag, render_mermaid
+
+    project_root = Path(project_path).resolve()
+    try:
+        built_dag = build_dag(project_root)
+    except (FileNotFoundError, ValueError) as exc:
+        click.echo(f"Error: {exc}")
+        raise SystemExit(1)
+    click.echo(render_mermaid(built_dag), nl=False)
+
+
+def _dag_result_to_dict(result: Any) -> dict[str, Any]:
+    if is_dataclass(result):
+        return asdict(result)
+    if isinstance(result, dict):
+        return result
+    return dict(vars(result))
+
+
+def _dag_result_name(result: Any) -> str:
+    return str(_dag_result_value(result, "check_name") or result.__class__.__name__)
+
+
+def _dag_result_severity(result: Any) -> str:
+    return str(_dag_result_value(result, "severity") or "red")
+
+
+def _dag_result_passed(result: Any) -> bool:
+    return _dag_result_value(result, "passed") is not False
+
+
+def _dag_result_has_findings(result: Any) -> bool:
+    for key in (
+        "violations",
+        "missing_impl_files",
+        "orphan_edges",
+        "dangling_refs",
+        "incomplete_tasks",
+        "unreachable_nodes",
+    ):
+        value = _dag_result_value(result, key)
+        if value:
+            return True
+    return False
+
+
+def _dag_result_details(result: Any) -> list[str]:
+    details: list[str] = []
+    for key in (
+        "missing_impl_files",
+        "orphan_edges",
+        "dangling_refs",
+        "violations",
+        "incomplete_tasks",
+        "unreachable_nodes",
+        "warnings",
+    ):
+        value = _dag_result_value(result, key)
+        if not value:
+            continue
+        if isinstance(value, list):
+            rendered = ", ".join(str(item) for item in value[:5])
+            if len(value) > 5:
+                rendered += f", ... {len(value) - 5} more"
+            details.append(f"{key}: {rendered}")
+        else:
+            details.append(f"{key}: {value}")
+    return details
+
+
+def _dag_result_value(result: Any, key: str) -> Any:
+    if isinstance(result, dict):
+        return result.get(key)
+    return getattr(result, key, None)
+
+
+@main.group()
+def hooks():
+    """Manage Git hook integration."""
+    pass
 
 
 @hooks.command("install")
@@ -2137,13 +2415,13 @@ def _render_template(template_name: str, dest: Path, variables: dict):
     tmpl_path = TEMPLATES_DIR / template_name
     if not tmpl_path.exists():
         # Create empty file if template doesn't exist yet
-        dest.write_text(f"# TODO: template {template_name} not yet created\n")
+        dest.write_text(f"# TODO: template {template_name} not yet created\n", encoding="utf-8")
         return
 
-    content = tmpl_path.read_text()
+    content = tmpl_path.read_text(encoding="utf-8")
     for key, value in variables.items():
         content = content.replace(f"{{{{{key}}}}}", value)
-    dest.write_text(content)
+    dest.write_text(content, encoding="utf-8")
 
 
 def _import_requirements(project_root: Path, source: Path, project_name: str) -> Path:

{codd_dev-1.20.0 → codd_dev-1.22.0}/codd/coherence_engine.py

@@ -80,6 +80,8 @@ def set_coherence_bus(bus: EventBus | None) -> None:
     """Set the opt-in coherence bus on detectors that publish DriftEvents."""
     for module_name in (
         "codd.drift",
+        "codd.drift_linkers.api",
+        "codd.deployer",
         "codd.hitl_session",
         "codd.validator",
         "codd.screen_flow_validator",
@@ -129,7 +131,7 @@ class Orchestrator:
         self._hitl_path = hitl_path
         self._ntfy_rate_limit = ntfy_rate_limit_seconds
         self._last_ntfy_time: float = 0.0
-        self._pending_amber: list[DriftEvent] = []
+        self._pending_ntfy_events: list[DriftEvent] = []
         bus.subscribe("*", self._handle)
 
     def resolve_fix_strategy(self, event: DriftEvent) -> FixStrategy:
@@ -200,8 +202,9 @@ class Orchestrator:
                 handle.write("# Pending HITL Reviews\n")
             handle.write(self._format_hitl_entry(event))
 
-        self._pending_amber.append(event)
-        self._maybe_send_ntfy()
+        if event.severity == "red":
+            self._pending_ntfy_events.append(event)
+        self._maybe_send_ntfy(event)
 
     def _format_hitl_entry(self, event: DriftEvent) -> str:
         original_severity = event.payload.get("downgraded_from", event.severity)
@@ -223,17 +226,19 @@ class Orchestrator:
             f"- **Reviewer**: (pending)\n"
         )
 
-    def _maybe_send_ntfy(self) -> None:
-        """Send at most one ntfy notification per rate-limit window."""
+    def _maybe_send_ntfy(self, event: DriftEvent) -> None:
+        """Send at most one red-severity ntfy notification per rate-limit window."""
+        if event.severity != "red":
+            return
         now = time.time()
         if now - self._last_ntfy_time < self._ntfy_rate_limit:
             return
-        count = len(self._pending_amber)
+        count = len(self._pending_ntfy_events)
         if count == 0:
             return
         self._send_ntfy(f"CoDD Coherence: {count} HITL event(s) pending review")
         self._last_ntfy_time = now
-        self._pending_amber.clear()
+        self._pending_ntfy_events.clear()
 
     def _send_ntfy(self, message: str) -> None:
         """Send an ntfy notification when NTFY_URL is configured."""

{codd_dev-1.20.0 → codd_dev-1.22.0}/codd/contracts.py

@@ -94,7 +94,7 @@ def build_interface_contracts(facts: ProjectFacts, project_root: Path) -> None:
         if init_files:
             init_path = project_root / init_files[0]
             try:
-                init_content = init_path.read_text(errors="ignore")
+                init_content = init_path.read_text(encoding="utf-8", errors="ignore")
             except Exception:
                 init_content = ""
             public = detect_init_exports(init_content)

{codd_dev-1.20.0 → codd_dev-1.22.0}/codd/coverage_metrics.py

@@ -132,7 +132,7 @@ def compute_lexicon_compliance(project_root: Path | str, threshold: float = 100.
 def compute_screen_flow_coverage(
     project_root: Path | str,
     config: dict[str, Any],
-    threshold: float = 0.0,
+    threshold: float = 100.0,
 ) -> CoverageResult:
     """Measure screen-flow drift as a coverage gate metric."""
 
@@ -153,8 +153,25 @@ def compute_screen_flow_coverage(
             details=[f"error: {exc}"],
         )
 
-    drift_count = len(drifts)
+    design_drift_details: list[str] = []
+    design_drift_count = 0
+    try:
+        from codd.drift_linkers.screen_flow import ScreenFlowGate
+
+        gate_result = ScreenFlowGate(
+            project_root=project_root,
+            settings={**config, "apply": True},
+        ).run()
+        if not gate_result.skipped:
+            design_drift_count = gate_result.drift_count
+            design_drift_details = gate_result.details
+    except Exception as exc:  # pragma: no cover - defensive gate behavior
+        return _exception_result("screen_flow_coverage", threshold, exc)
+
+    drift_count = len(drifts) + design_drift_count
     pct = 100.0 if drift_count == 0 else max(0.0, 100.0 - drift_count * 10.0)
+    details = [f"drift_count: {drift_count}"]
+    details.extend(design_drift_details)
     return CoverageResult(
         metric="screen_flow_coverage",
         total=1,
@@ -163,7 +180,49 @@ def compute_screen_flow_coverage(
         pct=pct,
         threshold=threshold,
         passed=pct >= threshold,
-        details=[f"drift_count: {drift_count}"],
+        details=details,
+    )
+
+
+def compute_dag_completeness(
+    project_root: Path | str,
+    config: dict[str, Any] | None = None,
+    threshold: float = 100.0,
+) -> CoverageResult:
+    """Measure red-severity DAG completeness checks as a coverage metric."""
+
+    try:
+        from codd.dag.runner import run_all_checks
+
+        results = run_all_checks(Path(project_root), settings=config or {})
+    except Exception as exc:  # pragma: no cover - defensive gate behavior
+        return _exception_result("dag_completeness", threshold, exc)
+
+    red_results = [result for result in results if _dag_result_severity(result) == "red"]
+    failed_red = [result for result in red_results if _dag_result_passed(result) is False]
+    amber_findings = [
+        result
+        for result in results
+        if _dag_result_severity(result) == "amber" and _dag_result_has_findings(result)
+    ]
+
+    total = len(red_results)
+    uncovered = len(failed_red)
+    covered = max(0, total - uncovered)
+    pct = _coverage_pct(covered, total)
+    details = [f"checks: {len(results)}", f"red_failures: {uncovered}"]
+    details.extend(_format_dag_result(result) for result in failed_red[:5])
+    details.extend(f"warning: {_format_dag_result(result)}" for result in amber_findings[:5])
+
+    return CoverageResult(
+        metric="dag_completeness",
+        total=total,
+        covered=covered,
+        uncovered=uncovered,
+        pct=pct,
+        threshold=threshold,
+        passed=pct >= threshold,
+        details=details,
     )
 
 
@@ -199,7 +258,7 @@ def run_coverage(
     e2e_threshold: float = 100.0,
     design_token_threshold: float = 0.0,
     lexicon_threshold: float = 100.0,
-    screen_flow_threshold: float = 0.0,
+    screen_flow_threshold: float = 100.0,
     config: dict[str, Any] | None = None,
 ) -> CoverageReport:
     """Run all coverage metrics and return an aggregated report."""
@@ -213,6 +272,7 @@ def run_coverage(
     report.add(compute_design_token_coverage(project_root, threshold=design_token_threshold))
     report.add(compute_lexicon_compliance(project_root, threshold=lexicon_threshold))
     report.add(compute_screen_flow_coverage(project_root, config, threshold=screen_flow_threshold))
+    report.add(compute_dag_completeness(project_root, config=config))
     return report
 
 
@@ -307,3 +367,53 @@ def _exception_result(metric: str, threshold: float, exc: Exception) -> Coverage
         passed=False,
         details=[f"error: {type(exc).__name__}: {exc}"],
     )
+
+
+def _dag_result_severity(result: Any) -> str:
+    return str(_dag_result_value(result, "severity") or "red")
+
+
+def _dag_result_passed(result: Any) -> bool:
+    return _dag_result_value(result, "passed") is not False
+
+
+def _dag_result_name(result: Any) -> str:
+    return str(_dag_result_value(result, "check_name") or result.__class__.__name__)
+
+
+def _dag_result_has_findings(result: Any) -> bool:
+    for key in (
+        "violations",
+        "missing_impl_files",
+        "orphan_edges",
+        "dangling_refs",
+        "incomplete_tasks",
+        "unreachable_nodes",
+    ):
+        if _dag_result_value(result, key):
+            return True
+    return False
+
+
+def _format_dag_result(result: Any) -> str:
+    details = []
+    for key in (
+        "missing_impl_files",
+        "orphan_edges",
+        "dangling_refs",
+        "violations",
+        "incomplete_tasks",
+        "unreachable_nodes",
+        "warnings",
+    ):
+        value = _dag_result_value(result, key)
+        if not value:
+            continue
+        details.append(f"{key}: {value}")
+    return f"{_dag_result_name(result)} ({'; '.join(details)})" if details else _dag_result_name(result)
+
+
+def _dag_result_value(result: Any, key: str) -> Any:
+    if isinstance(result, dict):
+        return result.get(key)
+    return getattr(result, key, None)