devcouncil 0.2.0 → 0.3.0

package/src/devcouncil/planning/arbiter_service.py

@@ -1,9 +1,12 @@
+import logging
 from typing import List, Dict
 from pydantic import BaseModel
 from devcouncil.domain.requirement import Requirement
 from devcouncil.domain.task import Task
 from devcouncil.llm.router import ModelRouter
 
+logger = logging.getLogger(__name__)
+
 class ArbiterDecision(BaseModel):
     accepted_finding_ids: List[str]
     rejected_finding_ids: List[Dict[str, str]] # id, reason
@@ -49,9 +52,14 @@ You are the arbiter engineering manager. Your goal is to produce the final, defi
         messages = [
             {"role": "user", "content": prompt}
         ]
-        
-        return await self.router.complete_structured(
+
+        result = await self.router.complete_structured(
             role="arbiter",
             messages=messages,
             schema=ArbiterDecision
         )
+        logger.info(
+            "Arbiter decision: %d final requirement(s), %d final task(s), %d finding(s) accepted",
+            len(result.final_requirements), len(result.final_tasks), len(result.accepted_finding_ids),
+        )
+        return result

package/src/devcouncil/planning/correction_manifest.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+import logging
 import uuid
 from datetime import datetime, timezone
 from pathlib import Path
@@ -17,6 +18,8 @@ from devcouncil.storage.native import CorrectionManifestRepository
 from devcouncil.storage.repositories import EvidenceRepository, GapRepository, TaskRepository
 from devcouncil.utils.redaction import redact_text
 
+logger = logging.getLogger(__name__)
+
 # Bounds for the prior-attempt context folded into the manifest. These reach the
 # next executor's prompt verbatim, so they must stay small enough not to crowd out
 # the task spec / blow the context window while still carrying the signal the agent
@@ -56,6 +59,29 @@ class CorrectionManifest(BaseModel):
 # Severity ordering: most severe first.
 _SEVERITY_RANK = {"critical": 0, "high": 1, "medium": 2, "low": 3}
 
+# Verification methods the EXECUTOR can satisfy by writing/fixing code+tests. A criterion
+# left unproven for one of these reasons (a check that could not run, an inconclusive
+# auto-check) is remediable — worth another repair pass — whereas manual/llm_review
+# criteria cannot be closed by re-running the agent and must not drive the loop.
+_AUTOMATABLE_METHODS = {"unit_test", "integration_test", "static_check"}
+
+
+def remediable_incomplete_gaps(all_gaps: list[Gap]) -> list[Gap]:
+    """Non-blocking ``acceptance_criteria_unproven`` gaps the executor could still close.
+
+    These are the "incomplete" signals (an acceptance criterion with no passing evidence,
+    but nothing actively failing) whose verification method is automatable — so another
+    repair pass that adds/repairs a proving test can move the task to done. Manual/llm
+    criteria are excluded (re-running the agent cannot prove them)."""
+    return [
+        g for g in all_gaps
+        if not g.blocking
+        and g.gap_type == "acceptance_criteria_unproven"
+        # Unknown/None method is excluded (not assumed automatable): only drive the loop
+        # when we positively know the criterion is one the executor can prove.
+        and g.expected_verification_method in _AUTOMATABLE_METHODS
+    ]
+
 # Gap-type priority within a severity band. Lower sorts first. Executable-evidence
 # failures (a failing test / unproven acceptance criterion) are the real defect signal
 # and must outrank scope (orphan/dependency) and advisory (review/secret) gaps so the
@@ -184,8 +210,13 @@ def build_correction_manifest(
     *,
     repair_service=None,
     prior_attempts: int = 0,
+    config=None,
 ) -> CorrectionManifest:
-    config = load_config(project_root)
+    # ``config`` may be threaded in by a caller that already loaded it (e.g. the repair
+    # loop, which would otherwise reload config from disk on every attempt). Fall back
+    # to loading it when not supplied — same result, deterministic for a given root.
+    if config is None:
+        config = load_config(project_root)
     failed: list[str] = []
     failed_results: list = []
     db = get_db(project_root)
@@ -254,7 +285,9 @@ def _union(base: list[str], extra: list[str]) -> list[str]:
     return merged
 
 
-def write_correction_manifest(project_root: Path, task_id: str, *, repair_service=None) -> Path | None:
+def write_correction_manifest(
+    project_root: Path, task_id: str, *, repair_service=None, config=None, include_incomplete: bool = False
+) -> Path | None:
     db = get_db(project_root)
     if not db:
         return None
@@ -262,14 +295,24 @@ def write_correction_manifest(project_root: Path, task_id: str, *, repair_servic
         task = TaskRepository(session).get_by_id(task_id)
         if not task:
             return None
-        gaps = [g for g in GapRepository(session).get_all() if g.task_id == task_id and g.blocking]
+        gaps = GapRepository(session).get_blocking_for_task(task_id)
+        if not gaps and include_incomplete:
+            # No hard block, but the task is "incomplete" — drive a repair pass at the
+            # unproven-but-remediable acceptance criteria so arm B does not stall one
+            # proof short of done.
+            gaps = remediable_incomplete_gaps(GapRepository(session).get_for_task(task_id))
         if not gaps:
+            logger.debug("No gaps to repair for %s; skipping correction manifest", task_id)
             return None
         prior_record = CorrectionManifestRepository(session).latest_for_task(task_id)
         prior_attempts = (prior_record.attempt + 1) if prior_record else 1
 
+    logger.info(
+        "Writing correction manifest for %s: %d gap(s), prior_attempts=%d",
+        task_id, len(gaps), prior_attempts,
+    )
     manifest = build_correction_manifest(
-        project_root, task, gaps, repair_service=repair_service, prior_attempts=prior_attempts
+        project_root, task, gaps, repair_service=repair_service, prior_attempts=prior_attempts, config=config
     )
     run_id = str(uuid.uuid4())
     run_dir = project_root / ".devcouncil" / "runs" / run_id

package/src/devcouncil/planning/critique_service.py

@@ -1,8 +1,11 @@
+import logging
 from typing import List
 from pydantic import BaseModel
 from devcouncil.domain.critique import CritiqueFinding
 from devcouncil.llm.router import ModelRouter
 
+logger = logging.getLogger(__name__)
+
 class CritiqueOutput(BaseModel):
     findings: List[CritiqueFinding]
 
@@ -36,7 +39,7 @@ Every finding must include a falsifiable_check.
             {"role": "user", "content": prompt}
         ]
         
-        return await self.router.complete_structured(
+        result = await self.router.complete_structured(
             role=role,
             messages=messages,
             schema=CritiqueOutput,
@@ -44,6 +47,8 @@ Every finding must include a falsifiable_check.
             # usable plan, far better than crashing the whole planning run.
             fallback=CritiqueOutput(findings=[]),
         )
+        logger.info("Critique by %s: %d finding(s)", role, len(result.findings))
+        return result
 
     async def generate_rebuttal(self, role: str, original_plan_json: str, findings_json: str) -> RebuttalOutput:
         prompt = f"""
@@ -62,10 +67,12 @@ You are the planner who created the original plan. Review the critique findings.
             {"role": "user", "content": prompt}
         ]
         
-        return await self.router.complete_structured(
+        result = await self.router.complete_structured(
             role=role,
             messages=messages,
             schema=RebuttalOutput,
             # No rebuttals means findings stand as-is — a safe, conservative default.
             fallback=RebuttalOutput(rebuttals=[]),
         )
+        logger.info("Rebuttal by %s: %d rebuttal(s)", role, len(result.rebuttals))
+        return result

package/src/devcouncil/planning/plan_service.py

@@ -1,13 +1,72 @@
-from typing import List
+import logging
+from typing import List, Tuple
 from pydantic import BaseModel
+from devcouncil.domain.requirement import Requirement
 from devcouncil.domain.task import Task
 from devcouncil.llm.router import ModelRouter
 
+logger = logging.getLogger(__name__)
+
 class PlanOutput(BaseModel):
     id: str
     rationale: str
     tasks: List[Task]
 
+
+def backfill_acceptance_criteria(
+    tasks: List[Task], requirements: List[Requirement]
+) -> Tuple[List[Task], List[Tuple[str, str]]]:
+    """Guarantee every acceptance criterion is owned by a task.
+
+    The spec elaborates edge-case/error criteria, but a planner (especially a weak one)
+    may link only some — or none — of them to tasks via ``acceptance_criterion_ids``,
+    silently dropping the rest from per-criterion verification. That is a core reason a
+    planned+gated run can be no better than the raw prompt: the elaborated edges never
+    become something a task is accountable for building and proving.
+
+    For each criterion not covered by any task, attach it to a WRITABLE task that
+    implements its requirement (falling back to any task on that requirement). A criterion
+    whose requirement no task owns is left alone — the requirement-coverage gate already
+    flags that. Returns the (possibly rewritten) tasks and the ``(task_id, ac_id)`` links
+    that were added.
+    """
+    covered = {ac_id for task in tasks for ac_id in task.acceptance_criterion_ids}
+    assignments: dict[str, List[str]] = {}
+    for req in requirements:
+        uncovered = [ac.id for ac in req.acceptance_criteria if ac.id not in covered]
+        if not uncovered:
+            continue
+        req_ac_ids = {ac.id for ac in req.acceptance_criteria}
+        candidates = [t for t in tasks if req.id in t.requirement_ids]
+        writable = [
+            t for t in candidates
+            if any(pf.allowed_change in ("create", "modify", "delete") for pf in t.planned_files)
+        ]
+        # Prefer the writable task already implementing some of this requirement's criteria
+        # (the primary implementer — most likely where the missing behavior also belongs),
+        # so a backfilled criterion lands on the task that actually builds it rather than an
+        # unrelated sibling. Fall back to any writable task, then any task on the requirement.
+        primary = [t for t in writable if req_ac_ids.intersection(t.acceptance_criterion_ids)]
+        target = primary or writable or candidates
+        if not target:
+            continue  # no task owns this requirement; requirement-coverage gap handles it
+        assignments.setdefault(target[0].id, []).extend(uncovered)
+
+    if not assignments:
+        return tasks, []
+
+    backfilled: List[Tuple[str, str]] = []
+    new_tasks: List[Task] = []
+    for task in tasks:
+        add = assignments.get(task.id)
+        if add:
+            merged = list(dict.fromkeys([*task.acceptance_criterion_ids, *add]))
+            new_tasks.append(task.model_copy(update={"acceptance_criterion_ids": merged}))
+            backfilled.extend((task.id, ac_id) for ac_id in add)
+        else:
+            new_tasks.append(task)
+    return new_tasks, backfilled
+
 class PlanService:
     def __init__(self, router: ModelRouter):
         self.router = router
@@ -41,6 +100,11 @@ Your task is to create a detailed implementation plan.
   append-only contents) and do NOT invoke flake8/mypy/ruff/eslint/tsc/npm unless the
   repo is already configured for them.
 - Ensure each task maps back to at least one requirement.
+- Populate each task's acceptance_criterion_ids with the IDs of the specific acceptance
+  criteria that task implements. EVERY acceptance criterion in the requirements above must
+  be owned by exactly one task — do NOT drop edge-case, boundary, or error-handling
+  criteria. An unowned criterion is a behavior nobody is accountable for building, which is
+  how subtle requirements get silently missed.
 
 Role-specific instructions:
 """
@@ -52,9 +116,11 @@ Role-specific instructions:
         messages = [
             {"role": "user", "content": prompt}
         ]
-        
-        return await self.router.complete_structured(
+
+        result = await self.router.complete_structured(
             role=role,
             messages=messages,
             schema=PlanOutput
         )
+        logger.info("Plan generated by %s: %d task(s)", role, len(result.tasks))
+        return result

package/src/devcouncil/planning/prompt_enhancer_service.py

@@ -1,9 +1,12 @@
+import logging
 from pathlib import Path
 
 from pydantic import BaseModel, Field
 
 from devcouncil.llm.router import ModelRouter
 
+logger = logging.getLogger(__name__)
+
 # Cap how much skill text we feed the enhancer so a repo matching many skills
 # can't blow up the planning prompt. Domain skills are ~50 lines each.
 _MAX_SKILLS_FOR_INTAKE = 4
@@ -22,6 +25,11 @@ class PromptEnhancement(BaseModel):
     # deterministically after the model call — the LLM does not populate them.
     applied_skills: list[str] = Field(default_factory=list)
     skills_brief: str = ""
+    # Curated project knowledge (Open Knowledge Format bundles) and the project design
+    # system (design.md), selected from ``.devcouncil/knowledge`` for this goal. Like the
+    # skills fields, set deterministically after the model call.
+    applied_knowledge: list[str] = Field(default_factory=list)
+    knowledge_brief: str = ""
 
     def normalized(self, original_goal: str) -> "PromptEnhancement":
         enhanced_goal = self.enhanced_goal.strip() or original_goal
@@ -63,9 +71,65 @@ class PromptEnhancement(BaseModel):
                 "agent receives the full skill text; the plan must already assume it.",
                 self.skills_brief,
             ])
+        if self.knowledge_brief:
+            sections.extend([
+                "",
+                "## Project knowledge & design system (ground the plan in these)",
+                "Curated org/domain knowledge (Open Knowledge Format) and the project's "
+                "design.md. Honor design tokens/components and reuse known facts rather than "
+                "re-deriving or contradicting them.",
+                self.knowledge_brief,
+            ])
         return "\n".join(sections)
 
 
+# Stable copy of the enhancement that produced the CURRENTLY ACTIVE plan. Written when a
+# plan is persisted, so the executor reads the guidance tied to the plan it is running —
+# not whichever run happens to have the newest mtime (a later dry-run/replan would otherwise
+# win). Lives next to the plan state under .devcouncil/.
+_ACTIVE_ENHANCEMENT_FILE = "active_prompt_enhancement.json"
+
+
+def load_latest_prompt_enhancement(project_root: Path) -> "PromptEnhancement | None":
+    """Load the prompt-enhancement for the active plan, or None.
+
+    Prefers the stable ``.devcouncil/active_prompt_enhancement.json`` written when the plan
+    was persisted (so the executor gets the guidance tied to the plan it is running). Falls
+    back to the most recent per-run artifact for plans persisted before that file existed.
+    Best-effort: any read/parse failure returns None so prompt building never breaks."""
+    import json
+
+    def _load(path: Path) -> "PromptEnhancement | None":
+        try:
+            return PromptEnhancement.model_validate(json.loads(path.read_text(encoding="utf-8")))
+        except Exception:
+            return None
+
+    active = project_root / ".devcouncil" / _ACTIVE_ENHANCEMENT_FILE
+    if active.is_file():
+        loaded = _load(active)
+        if loaded is not None:
+            return loaded
+
+    runs = project_root / ".devcouncil" / "runs"
+    if not runs.exists():
+        return None
+    artifacts = [d / "prompt_enhancement.json" for d in runs.iterdir() if (d / "prompt_enhancement.json").is_file()]
+    if not artifacts:
+        return None
+    return _load(max(artifacts, key=lambda p: p.stat().st_mtime))
+
+
+def save_active_prompt_enhancement(project_root: Path, enhancement: "PromptEnhancement") -> None:
+    """Persist the enhancement for the active plan to the stable path. Best-effort."""
+    try:
+        path = project_root / ".devcouncil" / _ACTIVE_ENHANCEMENT_FILE
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(enhancement.model_dump_json(indent=2), encoding="utf-8")
+    except Exception:
+        pass
+
+
 class PromptEnhancerService:
     def __init__(self, router: ModelRouter):
         self.router = router
@@ -80,6 +144,12 @@ class PromptEnhancerService:
         skills = _select_skills(goal, project_root)
         skills_intake = _full_intake(skills)
         skills_brief = _compact_brief(skills)
+        if skills:
+            logger.info("Prompt enhancer matched %d skill(s): %s", len(skills), ", ".join(s.name for s in skills))
+
+        knowledge = _select_knowledge(goal, project_root)
+        knowledge_intake = _knowledge_intake(knowledge)
+        knowledge_brief = _knowledge_brief(knowledge)
 
         prompt = f"""
 Original user goal:
@@ -94,6 +164,9 @@ Code review graph context:
 Applicable engineering skills (senior-level domain intake for this codebase/goal):
 {skills_intake or "(no domain skills matched; rely on general engineering judgment)"}
 
+Project knowledge & design system (curated facts and design tokens for this codebase):
+{knowledge_intake or "(no project knowledge ingested)"}
+
 You are DevCouncil's codebase-specific prompt enhancer.
 Rewrite the user goal into a better planning prompt before it is sent to the council debate.
 
@@ -122,6 +195,8 @@ Requirements:
             update={
                 "applied_skills": [skill.name for skill in skills],
                 "skills_brief": skills_brief,
+                "applied_knowledge": [source.name for source in knowledge],
+                "knowledge_brief": knowledge_brief,
             }
         )
 
@@ -163,5 +238,54 @@ def _compact_brief(skills: list) -> str:
     return "\n".join(lines).strip()
 
 
+def _select_knowledge(goal: str, project_root: Path | None):
+    """OKF/design knowledge selection for planning; never raises (best-effort)."""
+    if project_root is None:
+        return []
+    try:
+        from devcouncil.app.config import load_config
+        from devcouncil.knowledge.sources import select_knowledge_sources
+
+        cfg = load_config(project_root).knowledge
+        if not cfg.enabled:
+            return []
+        return select_knowledge_sources(
+            goal=goal, project_root=project_root,
+            directory=cfg.directory, design_always=cfg.design_always,
+        )
+    except Exception:
+        return []
+
+
+def _knowledge_intake(sources: list) -> str:
+    """Full knowledge bodies (capped) for the one-shot enhancer call."""
+    if not sources:
+        return ""
+    blocks: list[str] = []
+    total = 0
+    for source in sources[:_MAX_SKILLS_FOR_INTAKE]:
+        body = (getattr(source, "body", "") or "").strip()
+        if not body:
+            continue
+        kind = getattr(source, "kind", "knowledge")
+        block = f"### {kind}: {getattr(source, 'name', '')}\n{body}"
+        total += len(block)
+        if total > _MAX_INTAKE_CHARS:
+            break
+        blocks.append(block)
+    return "\n\n".join(blocks).strip()
+
+
+def _knowledge_brief(sources: list) -> str:
+    """One line per knowledge source (kind + name + description) for the debate prompt."""
+    lines = []
+    for source in sources:
+        description = (getattr(source, "description", "") or "").strip()
+        kind = getattr(source, "kind", "knowledge")
+        head = f"- **{getattr(source, 'name', '')}** ({kind})"
+        lines.append(f"{head} — {description}" if description else head)
+    return "\n".join(lines).strip()
+
+
 def _clean_items(items: list[str]) -> list[str]:
     return [item.strip() for item in items if item.strip()]

package/src/devcouncil/planning/repair_service.py

@@ -1,10 +1,13 @@
 from typing import List
 import json
+import logging
 from pydantic import BaseModel
 from devcouncil.domain.gap import Gap
 from devcouncil.domain.task import Task
 from devcouncil.llm.router import ModelRouter
 
+logger = logging.getLogger(__name__)
+
 class RepairOutput(BaseModel):
     suggested_tasks: List[Task]
 
@@ -31,9 +34,12 @@ Your task is to generate focused implementation tasks to fix these gaps.
 Return a JSON object with 'suggested_tasks'.
 """
         messages = [{"role": "user", "content": prompt}]
-        
-        return await self.router.complete_structured(
+
+        logger.info("Generating repair plan from %d gap(s)", len(gaps))
+        result = await self.router.complete_structured(
             role="planner_a",  # Pragmatic tech lead is best suited for repair task generation
             messages=messages,
             schema=RepairOutput
         )
+        logger.info("Repair plan: %d suggested task(s)", len(result.suggested_tasks))
+        return result

package/src/devcouncil/planning/spec_service.py

@@ -1,9 +1,12 @@
+import logging
 from typing import List
 from pydantic import BaseModel
 from devcouncil.domain.requirement import Requirement
 from devcouncil.domain.assumption import Assumption
 from devcouncil.llm.router import ModelRouter
 
+logger = logging.getLogger(__name__)
+
 class BlockingQuestion(BaseModel):
     id: str
     question: str
@@ -62,9 +65,14 @@ Each assumption MUST have a confidence and impact level.
         messages = [
             {"role": "user", "content": prompt}
         ]
-        
-        return await self.router.complete_structured(
+
+        result = await self.router.complete_structured(
             role="spec_writer",
             messages=messages,
             schema=SpecOutput
         )
+        logger.info(
+            "Spec generated: %d requirement(s), %d assumption(s), %d blocking question(s)",
+            len(result.requirements), len(result.assumptions), len(result.blocking_questions),
+        )
+        return result

package/src/devcouncil/repo/ci_scaffold.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 
 from pathlib import Path
 
-from devcouncil.app.config import load_config
+from devcouncil.app.config import DevCouncilConfig, load_config
 
 WORKFLOW_RELPATH = Path(".github") / "workflows" / "devcouncil.yml"
 
@@ -86,9 +86,14 @@ def _python_version(project_root: Path) -> str:
     return "3.12"
 
 
-def render_workflow(project_root: Path, default_branch: str = "main") -> str:
+def render_workflow(
+    project_root: Path,
+    default_branch: str = "main",
+    config: DevCouncilConfig | None = None,
+) -> str:
     """Render the workflow YAML text deterministically from config + detected stacks."""
-    config = load_config(project_root)
+    if config is None:
+        config = load_config(project_root)
     stacks = detect_stacks(project_root)
     commands = config.commands
 
@@ -151,7 +156,10 @@ def scaffold_ci(project_root: Path, force: bool = False) -> Path | None:
     target = project_root / WORKFLOW_RELPATH
     if target.exists() and not force:
         return None
-    default_branch = load_config(project_root).project.default_branch or "main"
+    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_workflow(project_root, default_branch), encoding="utf-8")
+    target.write_text(
+        render_workflow(project_root, default_branch, config), encoding="utf-8"
+    )
     return target

package/src/devcouncil/repo/sca.py

@@ -153,11 +153,21 @@ class ScaScanner:
         # whether a tool "exists"; we skip the PATH gate so canned output flows.
         self._injected = auditor_runner is not None
         self._runner: AuditorRunner = auditor_runner or _default_runner(timeout)
+        # project_root is immutable per instance, so lockfile existence is stable;
+        # memoize per filename to avoid repeated stat calls across auditors.
+        self._lockfile_cache: dict[str, bool] = {}
 
     # -- detection -----------------------------------------------------------
 
+    def _check_cached_lockfile(self, name: str) -> bool:
+        cached = self._lockfile_cache.get(name)
+        if cached is None:
+            cached = (self.project_root / name).exists()
+            self._lockfile_cache[name] = cached
+        return cached
+
     def _has_lockfile(self, auditor: _Auditor) -> bool:
-        return any((self.project_root / name).exists() for name in auditor.lockfiles)
+        return any(self._check_cached_lockfile(name) for name in auditor.lockfiles)
 
     def _is_runnable(self, auditor: _Auditor) -> bool:
         """Relevant to the repo (lockfile present) and runnable (on PATH or injected)."""

package/src/devcouncil/reporting/json_report.py

@@ -19,9 +19,20 @@ class JsonReportGenerator:
             verdict = "incomplete"
         else:
             verdict = "passed"
+        # 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
+        # lets an auditor see that a "passed" verdict rests on rigorous, not coarse, evidence
+        # — the difference that matters most when a weak/local reviewer compiled the checks.
+        proof_modes: dict[str, int] = {}
+        for ev in getattr(graph, "test_evidence", []):
+            if getattr(ev, "status", "") == "passed":
+                key = getattr(ev, "mode", "") or "unspecified"
+                proof_modes[key] = proof_modes.get(key, 0) + 1
         report = {
             "verdict": verdict,
             "coverage_summary": summary,
+            "proof_modes": proof_modes,
             "blocking_gaps": [g.model_dump() for g in graph.blocking_gaps()]
         }
         if live_review is not None:

package/src/devcouncil/reporting/markdown_report.py

@@ -40,7 +40,20 @@ class MarkdownReportGenerator:
         md_output += "## Coverage Summary\n"
         md_output += f"- **Requirements**: {summary['total_requirements']} ({summary['requirements_without_tasks']} unmapped)\n"
         md_output += f"- **Tasks**: {summary['total_tasks']} ({summary['tasks_without_requirements']} orphaned)\n"
-        md_output += f"- **Evidence**: {summary['total_ac'] - summary['ac_without_evidence']}/{summary['total_ac']} AC verified\n\n"
+        md_output += f"- **Evidence**: {summary['total_ac'] - summary['ac_without_evidence']}/{summary['total_ac']} AC verified\n"
+        # Proof rigor: HOW the verified criteria were proven. Precise per-criterion checks
+        # (compiled/vote) are trustworthy; ``coarse`` (a passing acceptance-capable command,
+        # not a check tied to the criterion) is weak evidence worth flagging to a reader.
+        proof_modes: dict[str, int] = {}
+        for ev in getattr(graph, "test_evidence", []):
+            if getattr(ev, "status", "") == "passed":
+                proof_modes[getattr(ev, "mode", "") or "unspecified"] = (
+                    proof_modes.get(getattr(ev, "mode", "") or "unspecified", 0) + 1
+                )
+        if proof_modes:
+            rigor = ", ".join(f"{count} {mode}" for mode, count in sorted(proof_modes.items()))
+            md_output += f"- **Proof rigor**: {rigor}\n"
+        md_output += "\n"
 
         md_output += "## Requirements Coverage Table\n"
         md_output += "| Requirement | Task Mapping | Status |\n"