devcouncil 0.3.0 → 0.4.0

package/src/devcouncil/repo/ci_scaffold.py

@@ -12,15 +12,19 @@ from pathlib import Path
 from devcouncil.app.config import DevCouncilConfig, load_config
 
 WORKFLOW_RELPATH = Path(".github") / "workflows" / "devcouncil.yml"
+EVIDENCE_WORKFLOW_RELPATH = Path(".github") / "workflows" / "devcouncil-evidence.yml"
 
 _PYTHON_TOOLS = {
     "pytest", "flake8", "ruff", "mypy", "tox", "python", "python3", "uv",
-    "poetry", "black", "isort", "pyright",
+    "poetry", "black", "isort", "pyright", "pip-audit",
 }
 _NODE_TOOLS = {
     "npm", "npx", "pnpm", "yarn", "bun", "eslint", "tsc", "jest", "vitest", "node",
 }
+_GO_TOOLS = {"go", "govulncheck"}
+_RUST_TOOLS = {"cargo", "rustc", "rustfmt", "clippy-driver"}
 _PYTHON_MARKERS = ("pyproject.toml", "requirements.txt", "setup.py", "setup.cfg", "Pipfile")
+_UV_LOCK = "uv.lock"
 
 
 def detect_stacks(project_root: Path) -> set[str]:
@@ -28,8 +32,14 @@ def detect_stacks(project_root: Path) -> set[str]:
     stacks: set[str] = set()
     if any((project_root / marker).exists() for marker in _PYTHON_MARKERS):
         stacks.add("python")
+    if (project_root / _UV_LOCK).exists():
+        stacks.add("python")
     if (project_root / "package.json").exists():
         stacks.add("node")
+    if (project_root / "go.mod").exists():
+        stacks.add("go")
+    if (project_root / "Cargo.toml").exists():
+        stacks.add("rust")
     return stacks
 
 
@@ -39,6 +49,10 @@ def _command_stack(command: str) -> str | None:
         return "python"
     if tool in _NODE_TOOLS:
         return "node"
+    if tool in _GO_TOOLS:
+        return "go"
+    if tool in _RUST_TOOLS:
+        return "rust"
     return None
 
 
@@ -68,6 +82,16 @@ _AUDIT_STEPS: dict[str, list[str]] = {
         "        continue-on-error: true",
         "        run: npm audit --audit-level=high",
     ],
+    "go": [
+        "      - name: Dependency audit (govulncheck)",
+        "        continue-on-error: true",
+        "        run: govulncheck ./...",
+    ],
+    "rust": [
+        "      - name: Dependency audit (cargo audit)",
+        "        continue-on-error: true",
+        "        run: cargo audit",
+    ],
 }
 
 
@@ -86,6 +110,45 @@ def _python_version(project_root: Path) -> str:
     return "3.12"
 
 
+def _uses_uv(project_root: Path) -> bool:
+    return (project_root / _UV_LOCK).exists()
+
+
+def _default_install_command(project_root: Path) -> str:
+    if _uses_uv(project_root):
+        return f"uv sync --all-groups --python {_python_version(project_root)}"
+    return "pip install -e ."
+
+
+def _default_dev_command(project_root: Path) -> str:
+    if _uses_uv(project_root):
+        return f"uv run --python {_python_version(project_root)} dev"
+    return "dev"
+
+
+def _evidence_python_setup_steps(project_root: Path, *, install_command: str) -> list[str]:
+    py_version = _python_version(project_root)
+    if _uses_uv(project_root):
+        return [
+            "      - name: Install uv",
+            "        uses: astral-sh/setup-uv@v7",
+            "      - name: Set up Python",
+            "        uses: actions/setup-python@v6",
+            "        with:",
+            f'          python-version: "{py_version}"',
+            "      - name: Install DevCouncil",
+            f"        run: {install_command}",
+        ]
+    return [
+        "      - name: Set up Python",
+        "        uses: actions/setup-python@v5",
+        "        with:",
+        f'          python-version: "{py_version}"',
+        "      - name: Install DevCouncil",
+        f"        run: {install_command}",
+    ]
+
+
 def render_workflow(
     project_root: Path,
     default_branch: str = "main",
@@ -115,6 +178,20 @@ def render_workflow(
             "        with:",
             '          node-version: "20"',
         ]
+    if "go" in stacks:
+        steps += [
+            "      - name: Set up Go",
+            "        uses: actions/setup-go@v5",
+            "        with:",
+            '          go-version: "stable"',
+        ]
+    if "rust" in stacks:
+        steps += [
+            "      - name: Set up Rust",
+            "        uses: dtolnay/rust-toolchain@stable",
+            "        with:",
+            "          components: clippy",
+        ]
 
     def add_command_steps(label: str, raw_commands: list[str]) -> None:
         for command in _applicable_commands(raw_commands, stacks):
@@ -146,6 +223,104 @@ def render_workflow(
     )
 
 
+def render_evidence_workflow(
+    project_root: Path,
+    default_branch: str = "main",
+    *,
+    install_command: str | None = None,
+    dev_command: str | None = None,
+) -> str:
+    """Render a PR evidence workflow: verify → JSON/HTML artifacts → optional GitHub integrations.
+
+    Expects ``GITHUB_TOKEN`` (for Checks/comments), ``GITHUB_REPOSITORY``, ``GITHUB_SHA``,
+    and ``GITHUB_PR_NUMBER`` (or ``PR_NUMBER``) when posting PR comments. The Check
+    conclusion is blocking-only (``--fail-on-blocking``); advisory gaps stay in artifacts.
+    """
+    if install_command is None:
+        install_command = _default_install_command(project_root)
+    if dev_command is None:
+        dev_command = _default_dev_command(project_root)
+
+    stacks = detect_stacks(project_root)
+    steps: list[str] = [
+        "      - name: Checkout",
+        "        uses: actions/checkout@v4",
+        "        with:",
+        "          fetch-depth: 0",
+    ]
+    if "python" in stacks or not stacks:
+        steps += _evidence_python_setup_steps(project_root, install_command=install_command)
+    steps += [
+        "      - name: DevCouncil verify (scoped diff)",
+        "        env:",
+        "          # pull_request → base branch SHA; push → previous commit (github.event.before).",
+        "          # New branch / first push: before is all zeros — skip verify (no diff base).",
+        "          VERIFY_BASE: ${{ github.event.pull_request.base.sha || github.event.before }}",
+        "        run: |",
+        '          ZERO_SHA="0000000000000000000000000000000000000000"',
+        '          if [ "$VERIFY_BASE" = "$ZERO_SHA" ]; then',
+        '            VERIFY_BASE=""',
+        "          fi",
+        '          if [ -n "$VERIFY_BASE" ]; then',
+        f"            {dev_command} check --verify --base \"$VERIFY_BASE\" --persist --project-root .",
+        "          else",
+        '            echo "::notice::Skipping DevCouncil verify — no diff base (first push / new branch). Push again or open a PR for scoped verify."',
+        "            exit 0",
+        "          fi",
+        "      - name: Write evidence JSON artifact",
+        f"        run: {dev_command} report --evidence-json .devcouncil/evidence.json --fail-on-blocking --project-root .",
+        "      - name: Write evidence HTML artifact",
+        f"        run: {dev_command} report --evidence-html .devcouncil/evidence.html --fail-on-blocking --project-root .",
+        "      - name: Upload evidence artifacts",
+        "        uses: actions/upload-artifact@v4",
+        "        with:",
+        '          name: devcouncil-evidence',
+        "          path: |",
+        "            .devcouncil/evidence.json",
+        "            .devcouncil/evidence.html",
+        "          if-no-files-found: error",
+        "      - name: Post GitHub Check (blocking gaps only)",
+        "        if: ${{ secrets.GITHUB_TOKEN != '' }}",
+        "        env:",
+        "          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}",
+        "          GITHUB_REPOSITORY: ${{ github.repository }}",
+        "          GITHUB_SHA: ${{ github.sha }}",
+        f"        run: {dev_command} report --github --fail-on-blocking --project-root .",
+        "      - name: Post PR comment (includes advisory gaps)",
+        "        if: github.event_name == 'pull_request'",
+        "        env:",
+        "          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}",
+        "          GITHUB_REPOSITORY: ${{ github.repository }}",
+        "          GITHUB_SHA: ${{ github.sha }}",
+        "          GITHUB_PR_NUMBER: ${{ github.event.pull_request.number }}",
+        f"        run: {dev_command} report --github-pr-comment --fail-on-blocking --project-root .",
+    ]
+    body = "\n".join(steps)
+    return (
+        "# DevCouncil evidence workflow — verify, export artifacts, optional GitHub Check/comment.\n"
+        "# Generated by DevCouncil; adjust install/dev commands for your stack.\n"
+        "# Check conclusion fails only on blocking gaps; advisory gaps appear in artifacts/comments.\n"
+        "name: DevCouncil Evidence\n"
+        "\n"
+        "permissions:\n"
+        "  contents: read\n"
+        "  checks: write\n"
+        "  pull-requests: write\n"
+        "\n"
+        "on:\n"
+        "  push:\n"
+        f'    branches: ["{default_branch}"]\n'
+        "  pull_request:\n"
+        f'    branches: ["{default_branch}"]\n'
+        "\n"
+        "jobs:\n"
+        "  evidence:\n"
+        "    runs-on: ubuntu-latest\n"
+        "    steps:\n"
+        f"{body}\n"
+    )
+
+
 def scaffold_ci(project_root: Path, force: bool = False) -> Path | None:
     """Write the starter workflow. Returns the path, or None if one already exists.
 
@@ -163,3 +338,24 @@ def scaffold_ci(project_root: Path, force: bool = False) -> Path | None:
         render_workflow(project_root, default_branch, config), encoding="utf-8"
     )
     return target
+
+
+def scaffold_evidence_ci(project_root: Path, force: bool = False) -> Path | None:
+    """Write the evidence export workflow. Returns the path, or None if one already exists."""
+    project_root = project_root.resolve()
+    target = project_root / EVIDENCE_WORKFLOW_RELPATH
+    if target.exists() and not force:
+        return None
+    config = load_config(project_root)
+    default_branch = config.project.default_branch or "main"
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(
+        render_evidence_workflow(
+            project_root,
+            default_branch,
+            install_command=_default_install_command(project_root),
+            dev_command=_default_dev_command(project_root),
+        ),
+        encoding="utf-8",
+    )
+    return target

package/src/devcouncil/repo/gitignore.py

@@ -10,7 +10,6 @@ GITIGNORE_SECTIONS: tuple[tuple[str, tuple[str, ...]], ...] = (
             ".devcouncil/*",
             "!.devcouncil/",
             "!.devcouncil/config.yaml",
-            "!.devcouncil/graphify.yaml",
         ),
     ),
     (
@@ -28,7 +27,7 @@ GITIGNORE_SECTIONS: tuple[tuple[str, tuple[str, ...]], ...] = (
             ".conducor/",
             ".antigravity/",
             ".warp/",
-            ".gitnexus",
+            ".grok/",
         ),
     ),
     (

package/src/devcouncil/reporting/evidence_export.py

@@ -0,0 +1,124 @@
+"""Reviewer-facing export of the requirement→task→diff→evidence graph.
+
+This is a pure serializer over an already-loaded :class:`ArtifactGraph` (no new
+analysis): it flattens what the standard report loads into a single JSON document a
+PR reviewer can read — or attach as a CI artifact — without installing DevCouncil.
+Written by ``dev report --evidence-json PATH``.
+"""
+
+import json
+from datetime import datetime, timezone
+from typing import Any, Dict, List
+
+from devcouncil.artifacts.graph import ArtifactGraph
+from devcouncil.reporting.verdict import classify_verdict
+
+_SEVERITY_RANK = {"low": 0, "medium": 1, "high": 2, "critical": 3}
+
+
+class EvidenceExportGenerator:
+    """Serializes the artifact graph as a single reviewer-readable JSON file."""
+
+    FORMAT = "devcouncil-evidence-export"
+    VERSION = 1
+
+    @staticmethod
+    def generate(graph: ArtifactGraph, live_review: dict | None = None, wiki_refresh: dict | None = None) -> str:
+        summary = graph.coverage_summary()
+        live_blockers = len((live_review or {}).get("blocking_cards", []))
+
+        verdict, incomplete_kind = classify_verdict(graph, live_blockers=live_blockers)
+
+        # Index evidence and diffs once so requirements/tasks can nest their own slices.
+        evidence_by_ac: Dict[str, List[Dict[str, Any]]] = {}
+        for ev in graph.test_evidence:
+            evidence_by_ac.setdefault(ev.acceptance_criterion_id, []).append(
+                {
+                    "requirement_id": ev.requirement_id,
+                    "command": ev.command,
+                    "status": ev.status,  # passed | failed | not_run
+                    "mode": getattr(ev, "mode", "") or "unspecified",
+                    "summary": ev.evidence_summary,
+                }
+            )
+
+        diffs_by_task: Dict[str, List[Dict[str, Any]]] = {}
+        for de in graph.diff_evidence:
+            diffs_by_task.setdefault(de.task_id, []).append(
+                {
+                    "changed_files": de.changed_files,
+                    "added_files": de.added_files,
+                    "deleted_files": de.deleted_files,
+                    "diff_summary": de.diff_summary,
+                }
+            )
+
+        tasks_by_requirement: Dict[str, List[str]] = {}
+        for task in graph.tasks.values():
+            for req_id in task.requirement_ids:
+                tasks_by_requirement.setdefault(req_id, []).append(task.id)
+
+        unproven_ac_ids = {ac.id for _, ac in graph.acceptance_criteria_without_evidence()}
+
+        requirements = [
+            {
+                "id": req.id,
+                "title": req.title,
+                "description": req.description,
+                "priority": req.priority,
+                "task_ids": sorted(tasks_by_requirement.get(req.id, [])),
+                "acceptance_criteria": [
+                    {
+                        "id": ac.id,
+                        "description": ac.description,
+                        "verification_method": ac.verification_method,
+                        "required": ac.required,
+                        "proven": ac.id not in unproven_ac_ids,
+                        "evidence": evidence_by_ac.get(ac.id, []),
+                    }
+                    for ac in req.acceptance_criteria
+                ],
+            }
+            for req in sorted(graph.requirements.values(), key=lambda r: r.id)
+        ]
+
+        tasks = [
+            {
+                "id": task.id,
+                "title": task.title,
+                "status": task.status,
+                "requirement_ids": task.requirement_ids,
+                "acceptance_criterion_ids": task.acceptance_criterion_ids,
+                "diffs": diffs_by_task.get(task.id, []),
+            }
+            for task in sorted(graph.tasks.values(), key=lambda t: t.id)
+        ]
+
+        # All gaps (each carries its own ``blocking`` flag), blocking-first then by
+        # severity so a reviewer reads the show-stoppers before the advisories.
+        gaps = [
+            gap.model_dump()
+            for gap in sorted(
+                graph.gaps.values(),
+                key=lambda g: (not g.blocking, -_SEVERITY_RANK.get(g.severity, 0), g.id),
+            )
+        ]
+
+        report: Dict[str, Any] = {
+            "format": EvidenceExportGenerator.FORMAT,
+            "version": EvidenceExportGenerator.VERSION,
+            "generated_at": datetime.now(timezone.utc).isoformat(),
+            "verdict": verdict,
+            "coverage_summary": summary,
+            "requirements": requirements,
+            "tasks": tasks,
+            "gaps": gaps,
+        }
+        if incomplete_kind is not None:
+            report["incomplete_kind"] = incomplete_kind
+        if live_review is not None:
+            report["live_review"] = live_review
+        if wiki_refresh is not None:
+            report["wiki_refresh"] = wiki_refresh
+
+        return json.dumps(report, indent=2)

package/src/devcouncil/reporting/evidence_html.py

@@ -0,0 +1,210 @@
+"""Self-contained HTML renderer for the requirement→task→diff→evidence graph.
+
+Companion to :mod:`devcouncil.reporting.evidence_export` — same reviewer-facing
+content, browsable in CI artifact previews without installing DevCouncil.
+Written by ``dev report --evidence-html PATH``.
+"""
+
+from __future__ import annotations
+
+import html
+from datetime import datetime, timezone
+from typing import Any
+
+from devcouncil.artifacts.graph import ArtifactGraph
+from devcouncil.reporting.evidence_export import EvidenceExportGenerator
+
+_STYLE = """
+body{font:16px/1.5 -apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif;
+max-width:64rem;margin:2rem auto;padding:0 1rem;color:#1a1a1a;background:#fff}
+h1,h2,h3{line-height:1.25}a{color:#0b66c3}table{border-collapse:collapse;width:100%;margin:1rem 0}
+th,td{border:1px solid #ddd;padding:.45rem .6rem;text-align:left;vertical-align:top}
+th{background:#f6f8fa}.meta{color:#555;font-size:.92em;margin:.5rem 0}
+.verdict-passed{color:#116329}.verdict-incomplete{color:#9a6700}.verdict-blocked{color:#cf222e}
+.badge{display:inline-block;border-radius:999px;padding:.1em .55em;font-size:.78em;font-weight:600}
+.badge-pass{background:#dafbe1;color:#116329}.badge-fail{background:#ffebe9;color:#cf222e}
+.badge-warn{background:#fff8c5;color:#9a6700}.badge-advisory{background:#eef3fb;color:#0b66c3}
+.gap-blocking{font-weight:600}.section{margin:2rem 0 1rem}
+ul.compact{margin:.3rem 0;padding-left:1.2rem}code{background:#f3f3f3;padding:.1em .3em;border-radius:3px}
+""".strip()
+
+
+def _esc(text: object) -> str:
+    return html.escape(str(text), quote=True)
+
+
+def _verdict_class(verdict: str) -> str:
+    return {
+        "passed": "verdict-passed",
+        "incomplete": "verdict-incomplete",
+        "blocked": "verdict-blocked",
+    }.get(verdict, "")
+
+
+def _status_badge(status: str) -> str:
+    cls = {
+        "passed": "badge-pass",
+        "failed": "badge-fail",
+        "not_run": "badge-warn",
+    }.get(status, "badge-warn")
+    return f'<span class="badge {cls}">{_esc(status)}</span>'
+
+
+def _proven_badge(proven: bool) -> str:
+    if proven:
+        return '<span class="badge badge-pass">proven</span>'
+    return '<span class="badge badge-warn">unproven</span>'
+
+
+def _render_gaps(gaps: list[dict[str, Any]]) -> str:
+    if not gaps:
+        return "<p>No gaps recorded.</p>"
+    rows: list[str] = []
+    for gap in gaps:
+        blocking = gap.get("blocking", False)
+        severity = gap.get("severity", "")
+        row_cls = "gap-blocking" if blocking else ""
+        kind = "blocking" if blocking else "advisory"
+        badge = "badge-fail" if blocking else "badge-advisory"
+        rows.append(
+            "<tr>"
+            f'<td class="{row_cls}"><span class="badge {badge}">{_esc(kind)}</span></td>'
+            f"<td>{_esc(gap.get('id', ''))}</td>"
+            f"<td>{_esc(severity)}</td>"
+            f"<td>{_esc(gap.get('description', ''))}</td>"
+            f"<td>{_esc(gap.get('task_id', '') or '—')}</td>"
+            "</tr>"
+        )
+    return (
+        "<table><thead><tr><th>Kind</th><th>ID</th><th>Severity</th>"
+        "<th>Description</th><th>Task</th></tr></thead><tbody>"
+        + "".join(rows)
+        + "</tbody></table>"
+    )
+
+
+def _render_requirements(requirements: list[dict[str, Any]]) -> str:
+    parts: list[str] = []
+    for req in requirements:
+        parts.append(f"<h3 id=\"{_esc(req.get('id', ''))}\">{_esc(req.get('id', ''))}: {_esc(req.get('title', ''))}</h3>")
+        parts.append(f"<p class=\"meta\">{_esc(req.get('description', ''))}</p>")
+        task_ids = req.get("task_ids") or []
+        if task_ids:
+            links = ", ".join(f'<a href="#task-{_esc(tid)}">{_esc(tid)}</a>' for tid in task_ids)
+            parts.append(f"<p class=\"meta\">Tasks: {links}</p>")
+        parts.append(
+            "<table><thead><tr><th>AC</th><th>Description</th><th>Method</th>"
+            "<th>Status</th><th>Evidence</th></tr></thead><tbody>"
+        )
+        for ac in req.get("acceptance_criteria") or []:
+            evidence_items = ac.get("evidence") or []
+            if evidence_items:
+                ev_html = "<ul class=\"compact\">" + "".join(
+                    "<li>"
+                    f"{_status_badge(ev.get('status', ''))} "
+                    f"<code>{_esc(ev.get('command', ''))}</code> — {_esc(ev.get('summary', ''))}"
+                    "</li>"
+                    for ev in evidence_items
+                ) + "</ul>"
+            else:
+                ev_html = "<em>none</em>"
+            parts.append(
+                "<tr>"
+                f"<td>{_esc(ac.get('id', ''))}</td>"
+                f"<td>{_esc(ac.get('description', ''))}</td>"
+                f"<td>{_esc(ac.get('verification_method', ''))}</td>"
+                f"<td>{_proven_badge(bool(ac.get('proven')))}</td>"
+                f"<td>{ev_html}</td>"
+                "</tr>"
+            )
+        parts.append("</tbody></table>")
+    return "\n".join(parts)
+
+
+def _render_tasks(tasks: list[dict[str, Any]]) -> str:
+    parts: list[str] = []
+    for task in tasks:
+        tid = task.get("id", "")
+        parts.append(
+            f"<h3 id=\"task-{_esc(tid)}\">{_esc(tid)}: {_esc(task.get('title', ''))}</h3>"
+        )
+        parts.append(
+            f"<p class=\"meta\">Status: {_esc(task.get('status', ''))} · "
+            f"Requirements: {_esc(', '.join(task.get('requirement_ids') or []))}</p>"
+        )
+        diffs = task.get("diffs") or []
+        if not diffs:
+            parts.append("<p class=\"meta\">No diff evidence linked.</p>")
+            continue
+        parts.append("<ul class=\"compact\">")
+        for diff in diffs:
+            changed = diff.get("changed_files") or []
+            added = diff.get("added_files") or []
+            deleted = diff.get("deleted_files") or []
+            parts.append("<li>")
+            if changed:
+                parts.append(f"Changed: {_esc(', '.join(changed))}<br>")
+            if added:
+                parts.append(f"Added: {_esc(', '.join(added))}<br>")
+            if deleted:
+                parts.append(f"Deleted: {_esc(', '.join(deleted))}<br>")
+            parts.append(_esc(diff.get("diff_summary", "")))
+            parts.append("</li>")
+        parts.append("</ul>")
+    return "\n".join(parts)
+
+
+class EvidenceHtmlGenerator:
+    """Renders the artifact graph as a single self-contained HTML document."""
+
+    FORMAT = "devcouncil-evidence-html"
+    VERSION = 1
+
+    @classmethod
+    def generate(
+        cls,
+        graph: ArtifactGraph,
+        live_review: dict | None = None,
+        wiki_refresh: dict | None = None,
+    ) -> str:
+        payload = EvidenceExportGenerator.generate(
+            graph, live_review=live_review, wiki_refresh=wiki_refresh
+        )
+        import json
+
+        data = json.loads(payload)
+        verdict = data.get("verdict", "incomplete")
+        summary = data.get("coverage_summary") or {}
+        generated_at = data.get("generated_at") or datetime.now(timezone.utc).isoformat()
+
+        body = [
+            "<!DOCTYPE html>",
+            '<html lang="en">',
+            "<head>",
+            '<meta charset="utf-8">',
+            "<title>DevCouncil Evidence Report</title>",
+            f"<style>{_STYLE}</style>",
+            "</head>",
+            "<body>",
+            "<h1>DevCouncil Evidence Report</h1>",
+            f'<p class="meta">Generated {_esc(generated_at)} · format {_esc(cls.FORMAT)} v{cls.VERSION}</p>',
+            f'<p class="{_verdict_class(verdict)}"><strong>Verdict:</strong> {_esc(verdict)}</p>',
+            "<p class=\"meta\">"
+            f"Requirements: {_esc(summary.get('total_requirements', 0))} · "
+            f"Tasks: {_esc(summary.get('total_tasks', 0))} · "
+            f"Blocking gaps: {_esc(summary.get('blocking_gaps', 0))} · "
+            f"AC without evidence: {_esc(summary.get('ac_without_evidence', 0))}"
+            "</p>",
+            '<div class="section"><h2>Gaps</h2>',
+            "<p class=\"meta\">GitHub Checks fail only on blocking gaps; advisory gaps appear here for reviewers.</p>",
+            _render_gaps(data.get("gaps") or []),
+            "</div>",
+            '<div class="section"><h2>Requirements &amp; Acceptance Criteria</h2>',
+            _render_requirements(data.get("requirements") or []),
+            "</div>",
+            '<div class="section"><h2>Tasks &amp; Diffs</h2>',
+            _render_tasks(data.get("tasks") or []),
+            "</div>",
+            "</body></html>",
+        ]
+        return "\n".join(body)

package/src/devcouncil/reporting/json_report.py

@@ -1,24 +1,22 @@
 import json
+from typing import Any
+
+from devcouncil.artifacts.coverage import (
+    acceptance_criteria_evidence_matrix,
+    requirement_task_matrix,
+)
 from devcouncil.artifacts.graph import ArtifactGraph
+from devcouncil.reporting.verdict import classify_verdict
 
 class JsonReportGenerator:
     """Generates a JSON evidence report."""
     
     @staticmethod
-    def generate(graph: ArtifactGraph, live_review: dict | None = None) -> str:
+    def generate(graph: ArtifactGraph, live_review: dict | None = None, wiki_refresh: dict | None = None) -> str:
         summary = graph.coverage_summary()
         live_blockers = len((live_review or {}).get("blocking_cards", []))
         
-        # Three honest states (see markdown_report for rationale):
-        #   blocked    - positive evidence of a problem.
-        #   incomplete - nothing failing, but not every AC has passing evidence.
-        #   passed     - no blocking gaps and every AC proven.
-        if summary["blocking_gaps"] > 0 or live_blockers > 0:
-            verdict = "blocked"
-        elif summary["ac_without_evidence"] > 0:
-            verdict = "incomplete"
-        else:
-            verdict = "passed"
+        verdict, incomplete_kind = classify_verdict(graph, live_blockers=live_blockers)
         # Proof-rigor breakdown: of the criteria that ARE proven, how were they proven?
         # ``compiled``/``vote`` are precise per-criterion checks (trustworthy); ``coarse``
         # means proven only by a passing acceptance-capable command (weak). Surfacing this
@@ -29,13 +27,19 @@ class JsonReportGenerator:
             if getattr(ev, "status", "") == "passed":
                 key = getattr(ev, "mode", "") or "unspecified"
                 proof_modes[key] = proof_modes.get(key, 0) + 1
-        report = {
+        report: dict[str, Any] = {
             "verdict": verdict,
             "coverage_summary": summary,
             "proof_modes": proof_modes,
+            "requirement_task_matrix": requirement_task_matrix(graph),
+            "acceptance_criteria_evidence_matrix": acceptance_criteria_evidence_matrix(graph),
             "blocking_gaps": [g.model_dump() for g in graph.blocking_gaps()]
         }
+        if incomplete_kind is not None:
+            report["incomplete_kind"] = incomplete_kind
         if live_review is not None:
             report["live_review"] = live_review
+        if wiki_refresh is not None:
+            report["wiki_refresh"] = wiki_refresh
         
         return json.dumps(report, indent=2)