Deep audit pass complete — 97 tests, smoke, operator smoke, and production audit all green.

Per-project identity (fingerprint)
project_fingerprint.py now collects industry-standard signals:

verification_commands — inferred from Makefile (make verify), npm scripts, pytest/Jest/Go/Cargo
runtime_versions — .nvmrc, .node-version, .python-version, .tool-versions
dependency_automation — Renovate / Dependabot detection
has_codeowners — GitHub CODEOWNERS presence
Cache invalidation extended for these files
These flow through steering_context, session_brief, and build_project_steering_digest.

Bootstrap fill hardening
_anti_goal() no longer returns the exact placeholder phrase — always produces project-specific anti-goals (including a library archetype)
_workflow_hint() prefers verification_commands over generic script lists
bootstrap_steering_bundle() always includes preview when requested, even when the skeleton is fully evidence-autofilled
Checkpoint context guard — "apply autofill preview" no longer triggers disk writes (only explicit write contexts do)
Agent ergonomics wiring
merge_roadmap_hint_into_result() propagates project_steering_digest and agent_next_call to the top-level tool response
format_agent_steering_line() shows Verify and Docs lines from fingerprint
Checkpoint fallback removed generic "Edit ROADMAP.md per skill" — uses recommended_next_action → validate/checkpoint/autofill
Production audit expansion
scripts/roadmap_audit.py now verifies:

Full BOOTSTRAP_PLACEHOLDER_PHRASES coverage (no unmapped or manual-only phrases)
verification_commands from Makefile projects
session_brief includes digest when bootstrap incomplete
Native write hint merge propagates digest + agent_next_call
Template brief expectations when skeleton is fully evidence-autofilled
End-to-end flow (unchanged architecture, tighter execution)
fingerprint (verify cmds, runtime, CODEOWNERS, …)
  → evidence → bootstrap_fill_plan → project_steering_digest
  → all surfaces (session / cockpit / checkpoint / write hints / doctor / progress)
  → apply_bootstrap_fill (preview/write) → validate → recommended_next_action
Evidence-driven skeletons for projects with README + Makefile can now autofill all template phrases in one pass; remaining placeholders still route through apply_bootstrap_fill with per-project replacements from fingerprint, git, and code soup audit.

Author: CardSorting

lib/agent/roadmap/agent_steering.py

@@ -40,6 +40,14 @@ def _project_context_lines(steering: dict[str, Any]) -> list[str]:
     if make_targets:
         lines.append(f"Makefile: {', '.join(make_targets[:4])}")
 
+    verify_cmds = steering.get("verification_commands") or []
+    if verify_cmds:
+        lines.append(f"Verify: {', '.join(verify_cmds[:3])}")
+
+    docs_roots = steering.get("docs_roots") or []
+    if docs_roots:
+        lines.append(f"Docs: {', '.join(docs_roots[:3])}")
+
     if steering.get("has_backstage_catalog"):
         lines.append("Backstage: catalog-info.yaml present")
         catalog = steering.get("catalog_name")

lib/agent/roadmap/bootstrap_fill.py

@@ -37,6 +37,7 @@ def _suggest_replacement(
     ci = fingerprint.get("ci_systems") or []
     scripts = fingerprint.get("entry_points") or []
     make_targets = fingerprint.get("makefile_targets") or []
+    verify_cmds = fingerprint.get("verification_commands") or []
     if make_targets:
         scripts = list(dict.fromkeys([*scripts, *make_targets[:3]]))
 
@@ -74,7 +75,7 @@ def _suggest_replacement(
             "project_fingerprint.runtime_center_hint",
         ),
         "A fragmented patch surface without a documented center of gravity.": (
-            _anti_goal(archetype),
+            _anti_goal(archetype, brief=brief),
             "project_fingerprint.project_archetype",
         ),
         "Initial roadmap bootstrap.": (
@@ -131,7 +132,7 @@ def _suggest_replacement(
             "project_fingerprint.runtime_center_hint",
         ),
         "List anti-goals that protect coherence.": (
-            _anti_goal(archetype),
+            _anti_goal(archetype, brief=brief),
             "project_fingerprint.project_archetype",
         ),
         "Describe what the project is becoming using README, architecture docs, and recent commits.": (
@@ -281,10 +282,15 @@ def _workflow_hint(
     ci: list[str],
 ) -> str:
     parts: list[str] = []
-    if scripts:
+    verify_cmds = fingerprint.get("verification_commands") or []
+    if verify_cmds:
+        parts.append(f"verify via {verify_cmds[0]}")
+    elif scripts:
         parts.append(f"dev/build via {', '.join(scripts[:3])}")
-    if tests:
+    if tests and not verify_cmds:
         parts.append(f"verify with {tests[0]}")
+    elif tests:
+        parts.append(f"tests: {tests[0]}")
     if ci:
         parts.append(f"CI: {ci[0]}")
     archetype = fingerprint.get("project_archetype") or ""
@@ -298,14 +304,19 @@ def _workflow_hint(
     return "Document primary dev, deploy, and agent-assisted workflows from README and scripts."
 
 
-def _anti_goal(archetype: str) -> str:
+def _anti_goal(archetype: str, *, brief: str = "") -> str:
     goals = {
         "hermes-plugin": "A Hermes plugin that stores ROADMAP.md outside the project workspace or drifts from kernel hook conventions.",
         "monorepo": "A monorepo without documented package boundaries and shared center of gravity.",
         "web-app": "A web app whose UI, API, and deploy surfaces diverge without documented authority boundaries.",
         "cli-tool": "A CLI whose entrypoints multiply without a documented operational center.",
+        "library": "A library whose public API surface drifts without documented stability boundaries.",
     }
-    return goals.get(archetype, "A fragmented patch surface without a documented center of gravity.")
+    if archetype in goals:
+        return goals[archetype]
+    if brief:
+        return f"Uncontrolled scope changes to {brief} without a documented center of gravity."
+    return "Uncontrolled scope sprawl without a documented center of gravity."
 
 
 def _primary_risk(evidence: dict[str, Any], fingerprint: dict[str, Any]) -> str:
@@ -482,10 +493,17 @@ def build_project_steering_digest(
         "has_ci": fingerprint.get("has_ci"),
         "has_tests": fingerprint.get("has_tests"),
         "entry_points": fingerprint.get("entry_points") or [],
+        "verification_commands": fingerprint.get("verification_commands") or [],
         "git_remote": fingerprint.get("git_remote"),
         "agent_rules_files": fingerprint.get("agent_rules_files") or [],
         "makefile_targets": fingerprint.get("makefile_targets") or [],
+        "docs_roots": fingerprint.get("docs_roots") or [],
+        "license": fingerprint.get("license"),
+        "runtime_versions": fingerprint.get("runtime_versions"),
+        "has_codeowners": fingerprint.get("has_codeowners"),
+        "dependency_automation": fingerprint.get("dependency_automation"),
         "has_backstage_catalog": fingerprint.get("has_backstage_catalog"),
+        "catalog_name": fingerprint.get("catalog_name"),
     }
     if fill_plan:
         digest["bootstrap_remaining"] = fill_plan.get("remaining_count")
@@ -516,7 +534,7 @@ def bootstrap_steering_bundle(
         "bootstrap_fill_plan": fill_plan,
         "project_steering_digest": build_project_steering_digest(fp, fill_plan=fill_plan),
     }
-    if include_preview and fill_plan.get("tasks"):
+    if include_preview:
         out["bootstrap_autofill_preview"] = apply_bootstrap_fill_draft(roadmap_text, evidence)
     if fill_plan.get("tasks"):
         out["operator_summary"] = fill_plan.get("operator_summary")

lib/agent/roadmap/native_bridge.py

@@ -209,6 +209,11 @@ def merge_roadmap_hint_into_result(result: Any, hint: dict[str, Any]) -> str:
         parsed = {"result": result}
 
     parsed["_roadmap_write_hint"] = hint
+    digest = hint.get("project_steering_digest")
+    if digest:
+        parsed["project_steering_digest"] = digest
+    if hint.get("bootstrap_incomplete") and isinstance(digest, dict) and digest.get("agent_next_call"):
+        parsed["agent_next_call"] = digest["agent_next_call"]
     try:
         from plugins.dietcode.lib.agent.roadmap.operator import build_agent_operator_hints
 

lib/agent/roadmap/project_fingerprint.py

@@ -89,7 +89,16 @@ def _fingerprint_cache_token(root: Path) -> float:
         "go.mod",
         "Makefile",
         "AGENTS.md",
+        "CONTRIBUTING.md",
         "catalog-info.yaml",
+        ".nvmrc",
+        ".node-version",
+        ".python-version",
+        ".tool-versions",
+        ".github/CODEOWNERS",
+        "CODEOWNERS",
+        "renovate.json",
+        ".github/dependabot.yml",
     ):
         path = root / rel
         if path.is_file():
@@ -439,6 +448,72 @@ def _catalog_metadata(root: Path) -> dict[str, Optional[str]]:
     return meta
 
 
+def _runtime_versions(root: Path) -> dict[str, str]:
+    versions: dict[str, str] = {}
+    for rel, label in (
+        (".nvmrc", "node"),
+        (".node-version", "node"),
+        (".python-version", "python"),
+        (".tool-versions", "asdf"),
+    ):
+        path = root / rel
+        if not path.is_file():
+            continue
+        line = _read_text(path, limit=64).strip().splitlines()
+        if line:
+            versions[label] = line[0][:32]
+    return versions
+
+
+def _dependency_automation(root: Path) -> list[str]:
+    found: list[str] = []
+    if (root / "renovate.json").is_file() or (root / ".github" / "renovate.json").is_file():
+        found.append("Renovate")
+    if (root / ".github" / "dependabot.yml").is_file() or (root / ".github" / "dependabot.yaml").is_file():
+        found.append("Dependabot")
+    return found
+
+
+def _verification_commands(
+    root: Path,
+    *,
+    entry_points: list[str],
+    makefile_targets: list[str],
+    test_frameworks: list[str],
+) -> list[str]:
+    """Industry-standard verify commands inferred from Makefile, package scripts, and test markers."""
+    cmds: list[str] = []
+    for target in ("verify", "test", "lint", "check", "ci"):
+        if target in makefile_targets:
+            cmds.append(f"make {target}")
+            break
+
+    scripts = _package_json(root).get("scripts")
+    if isinstance(scripts, dict):
+        for name in ("verify", "test", "lint", "ci", "check"):
+            if name in scripts:
+                cmd = f"npm run {name}" if (root / "package.json").is_file() else name
+                if cmd not in cmds:
+                    cmds.append(cmd)
+                break
+
+    if not cmds:
+        if "pytest" in test_frameworks:
+            cmds.append("pytest")
+        elif any(t in test_frameworks for t in ("Jest", "Vitest")):
+            cmds.append("npm test")
+        elif (root / "go.mod").is_file():
+            cmds.append("go test ./...")
+        elif (root / "Cargo.toml").is_file():
+            cmds.append("cargo test")
+        elif entry_points:
+            first = entry_points[0]
+            if first in ("test", "verify", "lint", "check"):
+                cmds.append(f"npm run {first}" if (root / "package.json").is_file() else first)
+
+    return cmds[:4]
+
+
 def _makefile_targets(root: Path) -> list[str]:
     makefile = root / "Makefile"
     if not makefile.is_file():
@@ -491,6 +566,15 @@ def _build_project_fingerprint(root: Path) -> dict[str, Any]:
     docs_roots = _docs_roots(root)
     agent_rules = _agent_rules_files(root)
     makefile_targets = _makefile_targets(root)
+    runtime_versions = _runtime_versions(root)
+    dependency_automation = _dependency_automation(root)
+    has_codeowners = (root / ".github" / "CODEOWNERS").is_file() or (root / "CODEOWNERS").is_file()
+    verification_commands = _verification_commands(
+        root,
+        entry_points=entry_points,
+        makefile_targets=makefile_targets,
+        test_frameworks=test_frameworks,
+    )
     has_backstage = (root / "catalog-info.yaml").is_file()
     catalog_meta = _catalog_metadata(root) if has_backstage else {}
 
@@ -556,6 +640,10 @@ def _build_project_fingerprint(root: Path) -> dict[str, Any]:
         "docs_roots": docs_roots,
         "agent_rules_files": agent_rules,
         "makefile_targets": makefile_targets,
+        "verification_commands": verification_commands,
+        "runtime_versions": runtime_versions or None,
+        "dependency_automation": dependency_automation or None,
+        "has_codeowners": has_codeowners,
         "has_backstage_catalog": has_backstage,
         "catalog_name": catalog_meta.get("catalog_name"),
         "catalog_description": catalog_meta.get("catalog_description"),

lib/agent/roadmap/roadmap_checkpoint.py

@@ -276,7 +276,7 @@ def checkpoint_brief(
                 if status.get("phase") == "bootstrap_fill"
                 else "roadmap(action='checkpoint')"
                 if not evidence.get("roadmap", {}).get("exists")
-                else "Edit ROADMAP.md per skill, then roadmap(action='validate'), then return checkpoint summary."
+                else "roadmap(action='validate')"
             )
         ),
     }
@@ -305,10 +305,19 @@ def checkpoint_brief(
             bootstrap_inc=True,
         )
     ctx_lower = (context or "").lower()
-    if any(
-        phrase in ctx_lower
-        for phrase in ("apply autofill", "apply bootstrap", "autofill write", "write autofill")
-    ):
+    autofill_write = (
+        any(
+            phrase in ctx_lower
+            for phrase in (
+                "apply autofill write",
+                "apply bootstrap write",
+                "autofill write",
+                "write autofill",
+            )
+        )
+        or ctx_lower.strip() in ("apply autofill", "apply bootstrap", "autofill")
+    ) and "preview" not in ctx_lower
+    if autofill_write:
         from plugins.dietcode.lib.agent.roadmap.bootstrap_fill import write_bootstrap_autofill
 
         applied = write_bootstrap_autofill(workspace=root, dry_run=False)

lib/agent/roadmap/session.py

@@ -55,6 +55,7 @@ def session_brief(*, workspace: Optional[str] = None) -> dict[str, Any] | None:
             "project_archetype": steering.get("project_archetype"),
             "agent_rules_files": steering.get("agent_rules_files"),
             "makefile_targets": steering.get("makefile_targets"),
+            "verification_commands": steering.get("verification_commands"),
             "has_backstage_catalog": steering.get("has_backstage_catalog"),
             "readme_tagline": steering.get("readme_tagline"),
             "center_of_gravity_excerpt": steering.get("center_of_gravity_excerpt"),

lib/agent/roadmap/steering_context.py

@@ -166,6 +166,10 @@ def build_steering_context(*, workspace: Optional[str] = None) -> dict[str, Any]
     "docs_roots",
     "agent_rules_files",
     "makefile_targets",
+    "verification_commands",
+    "runtime_versions",
+    "has_codeowners",
+    "dependency_automation",
     "has_backstage_catalog",
     "catalog_name",
     "catalog_description",

scripts/roadmap_audit.py

@@ -216,6 +216,8 @@ def main() -> int:
             failures.append("fingerprint should detect AGENTS.md")
         if not fp.get("makefile_targets"):
             failures.append("fingerprint should detect Makefile targets")
+        if "make verify" not in (fp.get("verification_commands") or []):
+            failures.append("fingerprint missing make verify from Makefile targets")
         if fp.get("project_archetype") not in {"project", "library", "application", "web-app", "cli-tool", "hermes-plugin", "monorepo"}:
             failures.append(f"unexpected project_archetype: {fp.get('project_archetype')}")
         roadmap_text = (root / "ROADMAP.md").read_text(encoding="utf-8")
@@ -270,6 +272,48 @@ def main() -> int:
             failures.append("session_brief missing _roadmap_operator_hints")
         if not (brief or {}).get("steering_line"):
             failures.append("session_brief missing steering_line")
+        if not (brief or {}).get("project_steering_digest"):
+            failures.append("session_brief missing project_steering_digest when bootstrap incomplete")
+
+        from plugins.dietcode.lib.agent.roadmap.schema import BOOTSTRAP_PLACEHOLDER_PHRASES
+
+        minimal_evidence = {
+            "project_fingerprint": {
+                "steering_brief": "Audit Project — test stack",
+                "purpose_hint": "Purpose line.",
+                "project_archetype": "library",
+            },
+            "git": {"recent_commits": [], "changed_files_recent": []},
+            "code_soup_audit": {"overall_risk": "Low", "signals": []},
+        }
+        for phrase in BOOTSTRAP_PLACEHOLDER_PHRASES:
+            plan = build_bootstrap_fill_plan(
+                roadmap_text=f"# Test\n\n{phrase}\n",
+                evidence=minimal_evidence,
+            )
+            tasks = plan.get("tasks") or []
+            if not tasks:
+                failures.append(f"bootstrap fill plan missing task for phrase: {phrase[:60]}")
+                continue
+            task = tasks[0]
+            if (task.get("suggested_replacement") or "") == phrase:
+                failures.append(f"bootstrap phrase unmapped (same text): {phrase[:60]}")
+            if str(task.get("evidence_source") or "").startswith("manual"):
+                failures.append(f"bootstrap phrase manual-only: {phrase[:60]}")
+
+        import json as _json
+        from plugins.dietcode.lib.agent.roadmap.native_bridge import merge_roadmap_hint_into_result, roadmap_write_hint
+
+        write_hint = roadmap_write_hint(
+            tool_name="write_file",
+            args={"path": "ROADMAP.md"},
+            workspace=str(root),
+        )
+        merged = _json.loads(merge_roadmap_hint_into_result({"ok": True}, write_hint))
+        if not merged.get("project_steering_digest"):
+            failures.append("merge_roadmap_hint missing top-level project_steering_digest")
+        if write_hint.get("bootstrap_incomplete") and not merged.get("agent_next_call"):
+            failures.append("merge_roadmap_hint missing agent_next_call when bootstrap incomplete")
 
         from plugins.dietcode.lib.agent.roadmap.agent_steering import format_agent_steering_line
 
@@ -334,8 +378,12 @@ def main() -> int:
             failures.append("template brief missing bootstrap_autofill_preview")
         if not (tmpl.get("project_steering_digest") or {}).get("steering_brief"):
             failures.append("template brief missing steering digest")
-        if "apply_bootstrap_fill" not in str((tmpl.get("bootstrap_fill_plan") or {}).get("agent_next_call") or ""):
-            failures.append("template brief fill plan should recommend apply_bootstrap_fill")
+        fill_plan = tmpl.get("bootstrap_fill_plan") or {}
+        if fill_plan.get("tasks"):
+            if "apply_bootstrap_fill" not in str(fill_plan.get("agent_next_call") or ""):
+                failures.append("template brief fill plan should recommend apply_bootstrap_fill")
+        elif not fill_plan.get("bootstrap_complete"):
+            failures.append("template brief should report bootstrap_complete when skeleton has no remaining phrases")
 
         record_validation(str(root), valid=True, phase="checkpoint")
         record_file_mutation(str(root), tool="write_file", path="ROADMAP.md")