Another deep audit and production-hardening pass is complete. 99 roadmap tests, smoke, operator smoke, and production audit all pass.

Kernel + roadmap unified cockpit
kernel_cockpit.py now merges per-project roadmap steering into the kernel operator view:

_roadmap_cockpit_brief() — pulls live session_brief() (identity, bootstrap state, digest)
build_cockpit_report() — includes roadmap_steering in the payload
format_cockpit_report() — shows project name, stack, verify command, bootstrap fill guidance, and roadmap health
Agents/operators get one screen for both kernel patch state and project-specific roadmap steering.

Richer project fingerprint
project_fingerprint.py adds industry-standard signals:

Signal	Source
compose_services
docker-compose.yml / compose.yml service names
.cursor/rules/*.mdc
Cursor rule files (alongside .md)
Runtime hint
Uses compose service names when Docker is present
These flow through steering context, digest, and agent steering lines.

Bootstrap fill — no dead-end fallbacks
_fallback_replacement() now chains through purpose_hint → operators_hint → runtime_center_hint → stack_summary → steering_brief before ever reaching manual review. Unmapped phrases get project-specific replacements whenever any fingerprint signal exists.

Dynamic gate messaging
gate.py evaluate_gate_checks() now personalizes closed gates:

Bootstrap gate — why includes project steering_brief + placeholder count
Schema gate — when bootstrap incomplete, fix prioritizes apply_bootstrap_fill before validate
collect_gate_inputs() — passes project_fingerprint through for enrichment
Cross-surface wiring
JoyZoning _merge_steering_next_actions — adds Project verify: make verify from digest
Roadmap cockpit report — shows verification commands during bootstrap fill
Agent steering lines — show Compose services when present
Audit expansion
Production audit now verifies:

JoyZoning verify hint from digest
Gate why/fix personalization with project brief
Kernel cockpit roadmap_steering payload + formatted bootstrap/verify lines
Architecture (end-to-end)
project_fingerprint (verify, compose, cursor rules, CODEOWNERS, …)
  → gate inputs + bootstrap_fill_plan → project_steering_digest
  → session / roadmap cockpit / kernel cockpit / write hints / joyzoning
  → apply_bootstrap_fill → validate → recommended_next_action
Evidence-driven skeletons with README + Makefile can still autofill all template phrases in one pass; partial placeholders route through apply_bootstrap_fill with per-project replacements from fingerprint, git, and code soup audit.

Author: CardSorting

lib/agent/joyzoning/workflow.py

@@ -58,6 +58,11 @@ def _merge_steering_next_actions(
 
         digest = roadmap_brief.get("project_steering_digest") or {}
         remaining = digest.get("bootstrap_remaining")
+        verify_cmds = digest.get("verification_commands") or []
+        if verify_cmds:
+            verify_hint = f"Project verify: {verify_cmds[0]}"
+            if verify_hint not in base and verify_hint not in hints:
+                hints.append(verify_hint)
         if remaining and int(remaining) > 0:
             fill_hint = (
                 f"Bootstrap fill: {remaining} template phrase(s) — "

lib/agent/kernel_cockpit.py

@@ -270,6 +270,20 @@ def _find_last_operation(*, action: str, status: str) -> dict[str, Any] | None:
     return None
 
 
+def _roadmap_cockpit_brief() -> dict[str, Any] | None:
+    """Per-project roadmap steering for unified kernel + roadmap operator view."""
+    try:
+        from plugins.dietcode.lib.agent.roadmap.config import get_roadmap_config
+
+        if not get_roadmap_config().enabled:
+            return None
+        from plugins.dietcode.lib.agent.roadmap.session import session_brief
+
+        return session_brief()
+    except Exception:
+        return None
+
+
 def build_cockpit_report() -> dict[str, Any]:
     try:
         from plugins.dietcode.lib.agent.kernel_progress import (
@@ -342,6 +356,7 @@ def build_cockpit_report() -> dict[str, Any]:
         "operation_state": operation_state,
         "current_operation": current_op,
         "workspace_root": gate.get("resolved_workspace_root"),
+        "roadmap_steering": _roadmap_cockpit_brief(),
         "patch_gate": {
             "patch_allowed": bool(gate.get("patch_allowed")),
             "mutations_enabled": bool(gate.get("mutations_enabled")),
@@ -392,6 +407,29 @@ def format_cockpit_report() -> str:
     ws = payload.get("workspace_root") or "(unresolved)"
     lines.append(f"Workspace: {ws}")
 
+    roadmap = payload.get("roadmap_steering") or {}
+    if roadmap.get("enabled"):
+        if roadmap.get("steering_brief") or roadmap.get("steering_identity"):
+            lines.append(f"Project: {roadmap.get('steering_brief') or roadmap.get('steering_identity')}")
+        if roadmap.get("stack_summary"):
+            lines.append(f"Stack: {roadmap['stack_summary']}")
+        digest = roadmap.get("project_steering_digest") or {}
+        verify_cmds = digest.get("verification_commands") or roadmap.get("verification_commands") or []
+        if verify_cmds:
+            lines.append(f"Verify: {verify_cmds[0]}")
+        if roadmap.get("bootstrap_complete") is False:
+            count = roadmap.get("bootstrap_placeholder_count") or digest.get("bootstrap_remaining") or "?"
+            lines.append(
+                f"Roadmap bootstrap: {count} template phrase(s) — "
+                "roadmap(action='apply_bootstrap_fill', context='write')"
+            )
+        elif roadmap.get("roadmap_exists"):
+            health = roadmap.get("health_status") or "present"
+            lines.append(f"Roadmap: health={health} | {roadmap.get('roadmap_path') or 'ROADMAP.md'}")
+        elif roadmap.get("success") is not False:
+            lines.append("Roadmap: missing — roadmap(action='checkpoint')")
+        lines.append("")
+
     pg = payload.get("patch_gate") or {}
     gate_sym = symbol("complete") if pg.get("patch_allowed") else symbol("warning")
     lines.append(

lib/agent/roadmap/agent_steering.py

@@ -44,6 +44,10 @@ def _project_context_lines(steering: dict[str, Any]) -> list[str]:
     if verify_cmds:
         lines.append(f"Verify: {', '.join(verify_cmds[:3])}")
 
+    compose = steering.get("compose_services") or []
+    if compose:
+        lines.append(f"Compose: {', '.join(compose[:4])}")
+
     docs_roots = steering.get("docs_roots") or []
     if docs_roots:
         lines.append(f"Docs: {', '.join(docs_roots[:3])}")

lib/agent/roadmap/bootstrap_fill.py

@@ -201,8 +201,17 @@ def _suggest_replacement(
 def _fallback_replacement(phrase: str, *, fingerprint: dict[str, Any]) -> tuple[str, str]:
     brief = fingerprint.get("steering_brief") or fingerprint.get("steering_identity") or ""
     purpose = fingerprint.get("purpose_hint") or ""
+    operators = fingerprint.get("operators_hint") or ""
+    runtime = fingerprint.get("runtime_center_hint") or ""
+    stack = fingerprint.get("stack_summary") or ""
     if purpose:
         return purpose, "project_fingerprint.purpose_hint"
+    if operators:
+        return operators[:240], "project_fingerprint.operators_hint"
+    if runtime:
+        return runtime[:240], "project_fingerprint.runtime_center_hint"
+    if stack and brief:
+        return f"Document project-specific detail for {brief} ({stack}).", "project_fingerprint.stack_summary"
     if brief:
         return f"Document project-specific detail for {brief}.", "project_fingerprint.steering_brief"
     return phrase, "manual — review bootstrap_fill_plan.tasks"
@@ -500,6 +509,7 @@ def build_project_steering_digest(
         "docs_roots": fingerprint.get("docs_roots") or [],
         "license": fingerprint.get("license"),
         "runtime_versions": fingerprint.get("runtime_versions"),
+        "compose_services": fingerprint.get("compose_services"),
         "has_codeowners": fingerprint.get("has_codeowners"),
         "dependency_automation": fingerprint.get("dependency_automation"),
         "has_backstage_catalog": fingerprint.get("has_backstage_catalog"),

lib/agent/roadmap/cockpit.py

@@ -214,6 +214,9 @@ 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])}")
+        verify_cmds = digest.get("verification_commands") or data.get("project_fingerprint", {}).get("verification_commands") or []
+        if verify_cmds:
+            lines.append(f"Verify: {', '.join(verify_cmds[:3])}")
         sample = digest.get("sample_fill_task") or {}
         if sample.get("suggested_replacement"):
             repl = str(sample["suggested_replacement"])

lib/agent/roadmap/gate.py

@@ -96,6 +96,7 @@ def collect_gate_inputs(
         "workspace_state": ws_state or None,
         "bootstrap_complete": bootstrap_complete,
         "bootstrap_placeholder_count": bootstrap_placeholder_count,
+        "project_fingerprint": evidence.get("project_fingerprint"),
     }
 
 
@@ -238,16 +239,30 @@ def evaluate_gate_checks(inputs: dict[str, Any]) -> tuple[list[dict[str, Any]],
     """Return (closed_gates, open_gate_ids) in kernel explain-gate shape."""
     closed: list[dict[str, Any]] = []
     open_ids: list[str] = []
+    fp = inputs.get("project_fingerprint") or {}
+    brief = fp.get("steering_brief") or fp.get("steering_identity") or ""
     for check in _GATE_CHECKS:
         is_open_fn: Callable[..., bool] = check["is_open"]
         if is_open_fn(check, inputs):
             open_ids.append(str(check["id"]))
         else:
+            why = check["why_closed"]
+            fix = check["fix"]
+            gate_id = str(check["id"])
+            if gate_id == "bootstrap_complete" and brief:
+                count = inputs.get("bootstrap_placeholder_count")
+                why = f"{brief}: {count or 'some'} unfilled bootstrap template phrase(s) remain"
+            elif gate_id == "schema_valid" and inputs.get("bootstrap_complete") is False:
+                fix = "roadmap(action='apply_bootstrap_fill', context='write') then roadmap(action='validate')"
+                if brief:
+                    why = f"{brief}: schema validation failed — bootstrap placeholders may still remain"
+            elif gate_id == "schema_valid" and brief:
+                fix = f"Repair ROADMAP.md schema for {brief}, then roadmap(action='validate')"
             closed.append({
-                "id": check["id"],
+                "id": gate_id,
                 "label": check["label"],
-                "why": check["why_closed"],
-                "fix": check["fix"],
+                "why": why,
+                "fix": fix,
                 "safe_to_apply": bool(check["safe"]),
                 "blocks_kanban_complete": bool(check.get("blocks_kanban_complete")),
             })

lib/agent/roadmap/project_fingerprint.py

@@ -99,6 +99,8 @@ def _fingerprint_cache_token(root: Path) -> float:
         "CODEOWNERS",
         "renovate.json",
         ".github/dependabot.yml",
+        "docker-compose.yml",
+        "compose.yml",
     ):
         path = root / rel
         if path.is_file():
@@ -424,15 +426,38 @@ def _agent_rules_files(root: Path) -> list[str]:
             found.append(rel)
     rules_dir = root / ".cursor" / "rules"
     if rules_dir.is_dir():
-        for path in sorted(rules_dir.glob("*.md"))[:5]:
+        for path in sorted(list(rules_dir.glob("*.md")) + list(rules_dir.glob("*.mdc")))[:5]:
             rel = f".cursor/rules/{path.name}"
             if rel not in found:
                 found.append(rel)
-        if rules_dir.is_dir() and ".cursor/rules" not in found and not any(p.suffix == ".md" for p in rules_dir.glob("*.md")):
-            found.append(".cursor/rules")
+        if not any(p.suffix in {".md", ".mdc"} for p in rules_dir.iterdir() if p.is_file()):
+            if ".cursor/rules" not in found:
+                found.append(".cursor/rules")
     return found[:8]
 
 
+def _compose_services(root: Path) -> list[str]:
+    for name in ("docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"):
+        path = root / name
+        if not path.is_file():
+            continue
+        services: list[str] = []
+        in_services = False
+        for line in _read_text(path, limit=4000).splitlines():
+            if re.match(r"^\s*services:\s*$", line):
+                in_services = True
+                continue
+            if not in_services:
+                continue
+            match = re.match(r"^\s{2}([\w-]+):\s*$", line)
+            if match:
+                services.append(match.group(1))
+            elif line.strip() and not line.startswith(" "):
+                break
+        return services[:6]
+    return []
+
+
 def _catalog_metadata(root: Path) -> dict[str, Optional[str]]:
     catalog = root / "catalog-info.yaml"
     if not catalog.is_file():
@@ -568,6 +593,7 @@ def _build_project_fingerprint(root: Path) -> dict[str, Any]:
     makefile_targets = _makefile_targets(root)
     runtime_versions = _runtime_versions(root)
     dependency_automation = _dependency_automation(root)
+    compose_services = _compose_services(root)
     has_codeowners = (root / ".github" / "CODEOWNERS").is_file() or (root / "CODEOWNERS").is_file()
     verification_commands = _verification_commands(
         root,
@@ -597,7 +623,10 @@ def _build_project_fingerprint(root: Path) -> dict[str, Any]:
     elif archetype == "web-app":
         runtime_hint = f"Web application root at {root.name} — deploy/runtime config in repo manifests"
     elif has_docker:
-        runtime_hint = "Containerized runtime — Docker/Docker Compose manifests define operational center"
+        if compose_services:
+            runtime_hint = f"Containerized runtime — services: {', '.join(compose_services[:4])}"
+        else:
+            runtime_hint = "Containerized runtime — Docker/Docker Compose manifests define operational center"
     elif frameworks:
         runtime_hint = f"Primary stack: {', '.join(frameworks[:3])} — operational truth in repo config and entrypoints"
 
@@ -644,6 +673,7 @@ def _build_project_fingerprint(root: Path) -> dict[str, Any]:
         "runtime_versions": runtime_versions or None,
         "dependency_automation": dependency_automation or None,
         "has_codeowners": has_codeowners,
+        "compose_services": compose_services or None,
         "has_backstage_catalog": has_backstage,
         "catalog_name": catalog_meta.get("catalog_name"),
         "catalog_description": catalog_meta.get("catalog_description"),

lib/agent/roadmap/steering_context.py

@@ -170,6 +170,7 @@ def build_steering_context(*, workspace: Optional[str] = None) -> dict[str, Any]
     "runtime_versions",
     "has_codeowners",
     "dependency_automation",
+    "compose_services",
     "has_backstage_catalog",
     "catalog_name",
     "catalog_description",

scripts/roadmap_audit.py

@@ -526,6 +526,83 @@ def main() -> int:
         if not any("apply_bootstrap_fill" in h for h in merged2):
             failures.append("joyzoning merge missing apply_bootstrap_fill from recommended_next_action")
 
+        merged3 = wf_mod._merge_steering_next_actions(
+            ["joyzoning(action='begin')"],
+            roadmap_brief={
+                "enabled": True,
+                "project_steering_digest": {"verification_commands": ["make verify"], "bootstrap_remaining": 2},
+            },
+        )
+        if not any("Project verify:" in h for h in merged3):
+            failures.append("joyzoning merge missing project verify hint from digest")
+
+        from plugins.dietcode.lib.agent.roadmap.gate import evaluate_gate_checks
+
+        gate_inputs = {
+            "config": get_roadmap_config() if False else None,
+            "workspace": str(root),
+            "roadmap_present": True,
+            "bootstrap_complete": False,
+            "bootstrap_placeholder_count": fill_plan.get("remaining_count", 3),
+            "project_fingerprint": fp,
+            "validation": {"valid": False},
+            "freshness": {"stale": False},
+            "workspace_state": {},
+        }
+        from plugins.dietcode.lib.agent.roadmap.config import get_roadmap_config
+
+        gate_inputs["config"] = get_roadmap_config()
+        closed_gates, _open = evaluate_gate_checks(gate_inputs)
+        bootstrap_closed = [g for g in closed_gates if g.get("id") == "bootstrap_complete"]
+        if not bootstrap_closed:
+            failures.append("gate audit expected closed bootstrap_complete gate")
+        elif "Audit Project" not in str(bootstrap_closed[0].get("why") or ""):
+            failures.append("bootstrap gate why should include project steering brief")
+        schema_closed = [g for g in closed_gates if g.get("id") == "schema_valid"]
+        if schema_closed and "apply_bootstrap_fill" not in str(schema_closed[0].get("fix") or ""):
+            failures.append("schema gate fix should prioritize bootstrap fill when placeholders remain")
+
+        try:
+            from plugins.dietcode.lib.agent import kernel_cockpit as kc_mod
+            from unittest import mock as audit_mock
+
+            fake_brief = {
+                "enabled": True,
+                "steering_brief": fp.get("steering_brief"),
+                "stack_summary": fp.get("stack_summary"),
+                "bootstrap_complete": False,
+                "bootstrap_placeholder_count": fill_plan.get("remaining_count", 3),
+                "roadmap_exists": True,
+                "health_status": "Coherent",
+                "roadmap_path": str(root / "ROADMAP.md"),
+                "project_steering_digest": digest,
+            }
+            kernel_gate = {
+                "resolved_workspace_root": str(root),
+                "patch_allowed": True,
+                "mutations_enabled": True,
+                "socket_ready": True,
+                "token_ready": True,
+                "workspace_safe_for_mutation": True,
+            }
+            kernel_router = {"raw_write_policy": "warn", "would_block_raw_writes": False, "would_warn_on_raw_write": False}
+            with audit_mock.patch.object(
+                kc_mod,
+                "_gate_context",
+                return_value={"config": None, "gate": kernel_gate, "router": kernel_router},
+            ):
+                with audit_mock.patch.object(kc_mod, "_roadmap_cockpit_brief", return_value=fake_brief):
+                    kc_payload = kc_mod.build_cockpit_report()
+                    kc_text = kc_mod.format_cockpit_report()
+            if not kc_payload.get("roadmap_steering"):
+                failures.append("kernel cockpit missing roadmap_steering brief")
+            if "apply_bootstrap_fill" not in kc_text:
+                failures.append("kernel cockpit report missing bootstrap fill guidance")
+            if "Verify:" not in kc_text:
+                failures.append("kernel cockpit report missing project verify line")
+        except ImportError:
+            pass
+
         invalidate_snapshot(str(root))
         snapshot_mod._CACHE.clear()
         t0 = time.perf_counter()

tests/test_kernel_cockpit.py

@@ -93,13 +93,26 @@ def test_cockpit_report_structure(self) -> None:
             "resolved_workspace_root": "/tmp/project",
         }
         router = {"raw_write_policy": "warn", "would_block_raw_writes": False, "would_warn_on_raw_write": True}
+        fake_roadmap = {
+            "enabled": True,
+            "steering_brief": "Demo — Python",
+            "stack_summary": "Python",
+            "bootstrap_complete": False,
+            "bootstrap_placeholder_count": 2,
+            "roadmap_exists": True,
+            "project_steering_digest": {"verification_commands": ["make verify"], "bootstrap_remaining": 2},
+        }
         with mock.patch.object(cockpit, "_gate_context", return_value={"config": KernelBridgeConfig(), "gate": gate, "router": router}):
-            payload = cockpit.build_cockpit_report()
+            with mock.patch.object(cockpit, "_roadmap_cockpit_brief", return_value=fake_roadmap):
+                payload = cockpit.build_cockpit_report()
+                text = cockpit.format_cockpit_report()
         self.assertIn("recommended_next_action", payload)
+        self.assertIn("roadmap_steering", payload)
         self.assertEqual(payload["recommended_next_action"]["action"], cockpit.ACTION_ENABLE_MUTATIONS)
-        text = cockpit.format_cockpit_report()
         self.assertIn("Kernel cockpit", text)
         self.assertIn("Next action:", text)
+        self.assertIn("apply_bootstrap_fill", text)
+        self.assertIn("Verify:", text)
 
     def test_ux_budget_enrichment(self) -> None:
         events = [