Another pass complete. make verify is green — smoke, audit, operator smoke, and 93 unit tests.

What changed
Doctor as a first-class operator surface
format_doctor_report() — human-readable summary with checks, bootstrap fill status, sample task, recommendations, and next command
roadmap(action='doctor') includes a report field
health.py roadmap doctor CLI subcommand prints the formatted report
Richer steering digest
build_project_steering_digest() now includes agent_next_call from the fill plan (single source for autofill → validate flow)
Evidence pipeline hardening
extend_evidence() ensures project_fingerprint is attached when upgrading light → standard/full tiers (checkpoint cache paths no longer miss fingerprint)
Native write hints carry digest
roadmap_write_hint() attaches project_steering_digest when bootstrap is incomplete (sample task + remaining count on _roadmap_write_hint)
Cockpit report
Shows sample fill replacement preview from digest when bootstrap placeholders remain
Audit & tests (+3)
Digest agent_next_call, doctor report, extend_evidence fingerprint
Tests: digest agent_next_call, doctor report, native bridge digest on write hint
Per-project steering now flows through doctor CLI, write transforms, and evidence extension — not only checkpoint/cockpit tool responses.

Author: CardSorting

health.py

@@ -649,6 +649,12 @@ def handle_dietcode_command(raw_args: str) -> Optional[str]:
                 except ImportError:
                     from lib.agent.roadmap.cockpit import format_cockpit_report
                 return format_cockpit_report()
+            if roadmap_sub == "doctor":
+                try:
+                    from plugins.dietcode.lib.agent.roadmap.doctor import format_doctor_report
+                except ImportError:
+                    from lib.agent.roadmap.doctor import format_doctor_report
+                return format_doctor_report()
             if roadmap_sub == "progress":
                 try:
                     from plugins.dietcode.lib.agent.roadmap.progress import format_progress_report, read_tail

lib/agent/roadmap/bootstrap_fill.py

@@ -498,6 +498,7 @@ def build_project_steering_digest(
                 "suggested_replacement": first.get("suggested_replacement"),
                 "evidence_source": first.get("evidence_source"),
             }
+        digest["agent_next_call"] = fill_plan.get("agent_next_call")
     return digest
 
 

lib/agent/roadmap/cockpit.py

@@ -214,6 +214,12 @@ def format_cockpit_report(*, workspace: Optional[str] = None) -> str:
         make_targets = digest.get("makefile_targets") or data.get("project_fingerprint", {}).get("makefile_targets") or []
         if make_targets:
             lines.append(f"Makefile targets: {', '.join(make_targets[:4])}")
+        sample = digest.get("sample_fill_task") or {}
+        if sample.get("suggested_replacement"):
+            repl = str(sample["suggested_replacement"])
+            if len(repl) > 90:
+                repl = repl[:89] + "…"
+            lines.append(f"Sample fill: {repl}")
     lines.append("")
     lines.append(data.get("operator_summary") or "")
     if data.get("progress_phase"):

lib/agent/roadmap/doctor.py

@@ -222,3 +222,49 @@ def _check(name: str, ok: bool, detail: str = "") -> None:
         "last_error": last_error or None,
         "recommendations": recommendations,
     }
+
+
+def format_doctor_report(*, workspace: Optional[str] = None) -> str:
+    """Human-readable roadmap doctor summary."""
+    data = run_checks(workspace=workspace)
+    lines = [
+        "🗺️ Roadmap doctor",
+        f"Workspace: {data.get('workspace') or '(unresolved)'}",
+    ]
+    if data.get("steering_brief"):
+        lines.append(f"Project: {data['steering_brief']}")
+    if data.get("stack_summary"):
+        lines.append(f"Stack: {data['stack_summary']}")
+    lines.append(f"Enabled: {data.get('enabled')}")
+    lines.append("")
+
+    for check in data.get("checks") or []:
+        mark = "✓" if check.get("ok") else "✕"
+        detail = check.get("detail") or ""
+        suffix = f" — {detail}" if detail and detail not in ("ok", "enabled", "disabled in config") else ""
+        lines.append(f"{mark} {check.get('name')}{suffix}")
+
+    digest = data.get("project_steering_digest") or {}
+    remaining = digest.get("bootstrap_remaining")
+    if remaining and int(remaining) > 0:
+        lines.append("")
+        lines.append(
+            f"Bootstrap fill: {remaining} phrase(s) — roadmap(action='apply_bootstrap_fill', context='write')"
+        )
+        sample = digest.get("sample_fill_task") or {}
+        if sample.get("template_phrase"):
+            lines.append(f"  sample: “{sample['template_phrase'][:50]}…”")
+
+    recs = data.get("recommendations") or []
+    if recs:
+        lines.append("")
+        lines.append("Recommendations:")
+        for rec in recs[:6]:
+            lines.append(f"  • {rec}")
+
+    next_rec = data.get("recommended_next_action") or {}
+    if next_rec.get("command"):
+        lines.append("")
+        lines.append(f"→ {next_rec['command']}")
+
+    return "\n".join(lines)

lib/agent/roadmap/evidence.py

@@ -335,6 +335,14 @@ def extend_evidence(
         if not evidence.get("code_soup_audit"):
             evidence["code_soup_audit"] = assess_code_soup(root, heavy_scan=heavy)
 
+    if not evidence.get("project_fingerprint"):
+        try:
+            from plugins.dietcode.lib.agent.roadmap.project_fingerprint import build_project_fingerprint
+
+            evidence["project_fingerprint"] = build_project_fingerprint(root)
+        except Exception:
+            evidence["project_fingerprint"] = {"steering_identity": root.name}
+
     return evidence
 
 

lib/agent/roadmap/native_bridge.py

@@ -152,6 +152,18 @@ def roadmap_write_hint(*, tool_name: str = "", args: Any = None, workspace: Opti
     elif project_brief:
         followup += " If bootstrap template phrases remain, preview roadmap(action='apply_bootstrap_fill') or apply with context='write'."
 
+    digest: dict[str, Any] = {}
+    if bootstrap_inc and check.get("allowed") and check.get("workspace"):
+        try:
+            from plugins.dietcode.lib.agent.roadmap.bootstrap_fill import attach_bootstrap_steering_fields
+            from plugins.dietcode.lib.agent.roadmap.steering_context import build_steering_context
+
+            steering = build_steering_context(workspace=check.get("workspace"))
+            attached = attach_bootstrap_steering_fields(steering, tier="light")
+            digest = attached.get("project_steering_digest") or {}
+        except Exception:
+            digest = {}
+
     next_action = (
         "roadmap(action='apply_bootstrap_fill', context='write') then roadmap(action='validate')"
         if bootstrap_inc
@@ -176,6 +188,8 @@ def roadmap_write_hint(*, tool_name: str = "", args: Any = None, workspace: Opti
         "roadmap_path": check.get("roadmap_path"),
         "expected_path": check.get("expected_path"),
         "project_steering_brief": project_brief,
+        "bootstrap_incomplete": bootstrap_inc,
+        "project_steering_digest": digest or None,
         "write_rejected": False,
     }
 

lib/tools/roadmap_tools.py

@@ -125,9 +125,12 @@ def _dispatch(
     if act == "doctor":
         root = resolve_workspace_root(workspace)
         install = ensure_workspace_skills(root)
+        from plugins.dietcode.lib.agent.roadmap.doctor import format_doctor_report
+
         report = run_checks(workspace=root)
         report["skill_install"] = install
         report["action"] = "doctor"
+        report["report"] = format_doctor_report(workspace=root)
         return _finish_payload(act, report)
 
     if act == "cockpit":

scripts/roadmap_audit.py

@@ -240,6 +240,28 @@ def main() -> int:
             failures.append("bootstrap_fill_plan missing now_suggestions")
         if not fill_plan.get("project_brief"):
             failures.append("bootstrap_fill_plan missing project_brief")
+        from plugins.dietcode.lib.agent.roadmap.bootstrap_fill import build_project_steering_digest
+
+        digest = build_project_steering_digest(fp, fill_plan=fill_plan)
+        if fill_plan.get("tasks") and not digest.get("agent_next_call"):
+            failures.append("steering digest missing agent_next_call")
+
+        from plugins.dietcode.lib.agent.roadmap.doctor import format_doctor_report, run_checks
+
+        dr = run_checks(workspace=str(root))
+        if not dr.get("recommended_next_action"):
+            failures.append("doctor missing recommended_next_action")
+        if "apply_bootstrap_fill" not in format_doctor_report(workspace=str(root)):
+            failures.append("doctor report missing bootstrap fill hint")
+
+        from plugins.dietcode.lib.agent.roadmap.evidence import extend_evidence
+
+        extended = extend_evidence(
+            {"workspace": str(root), "evidence_tier": "light", "git": evidence.get("git") or {}, "roadmap": evidence.get("roadmap") or {}},
+            tier="standard",
+        )
+        if not extended.get("project_fingerprint"):
+            failures.append("extend_evidence missing project_fingerprint")
 
         brief = session_brief(workspace=str(root))
         if not brief or not brief.get("roadmap_path"):

tests/test_roadmap_checkpoint.py

@@ -1126,6 +1126,46 @@ def test_explain_stale_report_includes_project(self) -> None:
         )
         self.assertIn("Stale Project", report)
 
+    def test_steering_digest_includes_agent_next_call(self) -> None:
+        from plugins.dietcode.lib.agent.roadmap.bootstrap_fill import attach_bootstrap_steering_fields
+        from plugins.dietcode.lib.agent.roadmap.steering_context import build_steering_context
+        from plugins.dietcode.lib.agent.roadmap.schema import bootstrap_skeleton
+
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            (root / "ROADMAP.md").write_text(bootstrap_skeleton(project_hint="Digest Call"), encoding="utf-8")
+            steering = build_steering_context(workspace=str(root))
+            attached = attach_bootstrap_steering_fields(steering, tier="light")
+            digest = attached.get("project_steering_digest") or {}
+            self.assertIn("apply_bootstrap_fill", digest.get("agent_next_call") or "")
+
+    def test_format_doctor_report_bootstrap_hint(self) -> None:
+        from plugins.dietcode.lib.agent.roadmap.doctor import format_doctor_report
+        from plugins.dietcode.lib.agent.roadmap.schema import bootstrap_skeleton
+
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            (root / "ROADMAP.md").write_text(bootstrap_skeleton(project_hint="Doctor Report"), encoding="utf-8")
+            report = format_doctor_report(workspace=str(root))
+            self.assertIn("Roadmap doctor", report)
+            self.assertIn("apply_bootstrap_fill", report)
+
+    def test_native_bridge_write_hint_includes_digest(self) -> None:
+        from plugins.dietcode.lib.agent.roadmap.native_bridge import roadmap_write_hint
+        from plugins.dietcode.lib.agent.roadmap.schema import bootstrap_skeleton
+
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            (root / "ROADMAP.md").write_text(bootstrap_skeleton(project_hint="Bridge Digest"), encoding="utf-8")
+            hint = roadmap_write_hint(
+                tool_name="write_file",
+                args={"path": "ROADMAP.md"},
+                workspace=str(root),
+            )
+            digest = hint.get("project_steering_digest") or {}
+            self.assertTrue(hint.get("bootstrap_incomplete"))
+            self.assertTrue(digest.get("bootstrap_remaining") or digest.get("sample_fill_task"))
+
 
 class RoadmapWorkspaceResolutionTests(unittest.TestCase):
     def setUp(self) -> None: