feat: add roadmap deferred ownership records

Author: solomonneas

CHANGELOG.md

@@ -150,6 +150,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 - `brigade roadmap audit` now reads documented commands from command snippets instead of prose and normalizes parameterized examples such as `brigade tools show <id>` to their CLI command path.
+- `brigade roadmap audit --json` now includes deferred roadmap ownership records with subsystem, owner, reason, source section, status, and suggested phase.
 - Roadmap phase headings now distinguish foundations, active work, and the phase queue so stale Current/Next warnings are actionable.
 - Public repo contents now keep live dogfood workspace files, internal planning notes, and root memory cards untracked; public templates remain under `src/brigade/templates/`.
 - Dogfood handoff defaults now use `.codex/memory-handoffs/` for new Codex-driven local configs while preserving explicit configured inbox paths such as `.claude/memory-handoffs/`.

docs/phase-61-100-plan.md

@@ -16,11 +16,15 @@ Goal: make `brigade roadmap audit` accurate enough to drive phases 61-100. Norma
 
 Acceptance: roadmap audit tests cover command normalization, parent-command examples, prose filtering, stale phase behavior, and pattern coverage. README, ROADMAP, CHANGELOG, and this plan document the phase queue.
 
+Status: implemented.
+
 ### Phase 62: Roadmap Ownership And Deferred Item Records
 Goal: add explicit roadmap ownership records for deferred items so later phases can close or re-defer them without ambiguous status text.
 
 Acceptance: roadmap audit JSON includes owner, subsystem, deferred reason, and suggested next phase for known deferred items.
 
+Status: implemented with `deferred_items` in `brigade roadmap audit --json`.
+
 ### Phase 63: Public Command Documentation Contract
 Goal: make public docs and CLI command discovery agree through a stable command contract, without relying on fragile prose scans.
 

docs/roadmap-completion-plan.md

@@ -258,6 +258,12 @@ Phase 61 status:
 - Tightened `brigade roadmap audit` command discovery so it scans command snippets, ignores prose, and normalizes parent commands and parameterized examples to known CLI command paths.
 - Closed the context-engineering pattern registry owner and test-hint gap.
 
+Phase 62 status:
+
+- Added public-safe deferred roadmap ownership records to `brigade roadmap audit --json`.
+- Each known deferred item now has an id, title, subsystem, owner, source section, deferred reason, status, and suggested phase when the item remains in scope.
+- Text audit output includes the deferred item count, while unresolved ownership or missing phase metadata would become roadmap audit warnings.
+
 ### 3. Inspiration Pattern Registry
 
 Deliverable: a bounded local record of external workflow patterns Brigade intends to support.

src/brigade/roadmap_cmd.py

@@ -170,6 +170,139 @@
     },
 )
 
+DEFERRED_ROADMAP_ITEMS: tuple[dict[str, Any], ...] = (
+    {
+        "id": "deeper-roadmap-ownership-modeling",
+        "title": "Deeper roadmap ownership modeling",
+        "subsystem": "roadmap",
+        "owner": "roadmap",
+        "source_section": "Roadmap State Audit And Closure Map",
+        "deferred_reason": "Earlier roadmap audit work prioritized command visibility, JSON output, tests, and daily-loop health before richer ownership state.",
+        "suggested_phase": 62,
+        "status": "active",
+    },
+    {
+        "id": "private-pattern-source-aliases",
+        "title": "Private pattern source aliases from local config",
+        "subsystem": "roadmap",
+        "owner": "roadmap",
+        "source_section": "Inspiration Pattern Registry",
+        "deferred_reason": "Exact reference source names belong only in gitignored host-local config, while public docs should expose neutral pattern families.",
+        "suggested_phase": 62,
+        "status": "active",
+    },
+    {
+        "id": "cross-producer-provenance-audit",
+        "title": "Cross-producer provenance audits across historical sources",
+        "subsystem": "work-inbox",
+        "owner": "work",
+        "source_section": "Scanner And Inbox Closure",
+        "deferred_reason": "The scanner closeout phase tightened the common path first and left historical compatibility backfill for a focused pass.",
+        "suggested_phase": 64,
+        "status": "planned",
+    },
+    {
+        "id": "expanded-chat-export-parsers",
+        "title": "Expanded chat export provider aliases and parser fixtures",
+        "subsystem": "chat-surfaces",
+        "owner": "chat",
+        "source_section": "Chat Surface Export Completion",
+        "deferred_reason": "The no-live-API boundary kept the first implementation focused on local export contracts and privacy gates.",
+        "suggested_phase": 66,
+        "status": "planned",
+    },
+    {
+        "id": "outbound-backup-status-messages",
+        "title": "Outbound backup operator status messages",
+        "subsystem": "backup-health",
+        "owner": "backup",
+        "source_section": "Backup And Recovery Closure",
+        "deferred_reason": "Outbound notifications require product-specific surfaces and remain outside the local read-only operator loop.",
+        "suggested_phase": None,
+        "status": "out-of-scope",
+    },
+    {
+        "id": "tool-projection-parity-closeout",
+        "title": "Separate tool projection parity closeout receipt",
+        "subsystem": "tool-catalog",
+        "owner": "tools",
+        "source_section": "Shared Tool Catalog Completion",
+        "deferred_reason": "Projection state is represented in packs and sync plans first, while closeout state needs a focused compatibility pass.",
+        "suggested_phase": 68,
+        "status": "planned",
+    },
+    {
+        "id": "context-harness-destination-writes",
+        "title": "Context pack writes into harness destinations",
+        "subsystem": "context",
+        "owner": "context",
+        "source_section": "Context Engineering Packs",
+        "deferred_reason": "Context sync planning remains read-only until a future explicit context apply command exists.",
+        "suggested_phase": 70,
+        "status": "planned",
+    },
+    {
+        "id": "learning-accepted-risk-quieting",
+        "title": "Rich accepted-risk quieting across learning sources",
+        "subsystem": "learning",
+        "owner": "learn",
+        "source_section": "Self-Learning Loop Closure",
+        "deferred_reason": "Candidate import routing exists first, while source-specific quieting policies remain subsystem-owned.",
+        "suggested_phase": 74,
+        "status": "planned",
+    },
+    {
+        "id": "security-sarif-output",
+        "title": "Dependency-free security SARIF output",
+        "subsystem": "security",
+        "owner": "security",
+        "source_section": "Security Plugin Closure",
+        "deferred_reason": "JSON and Markdown evidence bundles exist, and SARIF needs a focused schema compatibility pass without new dependencies.",
+        "suggested_phase": 76,
+        "status": "planned",
+    },
+    {
+        "id": "stale-issue-repair-imports",
+        "title": "Stale active issue repair imports",
+        "subsystem": "work",
+        "owner": "work",
+        "source_section": "Issue And TDD Loop Closure",
+        "deferred_reason": "The first acceptance phase completed the local acceptance rollup before repair-import routing.",
+        "suggested_phase": 80,
+        "status": "planned",
+    },
+    {
+        "id": "repo-shareable-workflow-rule-templates",
+        "title": "Repo-shareable workflow rule templates",
+        "subsystem": "install",
+        "owner": "templates",
+        "source_section": "Issue And TDD Loop Closure",
+        "deferred_reason": "The first acceptance phase avoided mixing public workflow rules with personal preferences.",
+        "suggested_phase": 79,
+        "status": "planned",
+    },
+    {
+        "id": "safe-memory-autofix-planning",
+        "title": "Safe memory-care autofix planning",
+        "subsystem": "memory-care",
+        "owner": "memory",
+        "source_section": "Memory And Handoff Closure",
+        "deferred_reason": "Memory-care closeouts record review state first, with mutation-free repair planning left for a focused pass.",
+        "suggested_phase": 83,
+        "status": "planned",
+    },
+    {
+        "id": "recursive-repo-root-discovery",
+        "title": "Safe repo root discovery from configured roots",
+        "subsystem": "repo-fleet",
+        "owner": "repos",
+        "source_section": "Repository Fleet Readiness",
+        "deferred_reason": "Explicit repo config avoids accidentally exposing private repo names or paths; discovery needs a dry-run privacy-safe plan.",
+        "suggested_phase": 91,
+        "status": "planned",
+    },
+)
+
 
 def _roadmap_path(target: Path) -> Path:
     return target / "ROADMAP.md"
@@ -360,6 +493,29 @@ def _normalize_documented_command(command: str, known_prefixes: set[str]) -> str
     return command
 
 
+def _deferred_items() -> list[dict[str, Any]]:
+    return [dict(item) for item in DEFERRED_ROADMAP_ITEMS]
+
+
+def _deferred_item_checks(items: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    missing_owner = [item["id"] for item in items if not item.get("owner")]
+    missing_phase = [item["id"] for item in items if item.get("status") != "out-of-scope" and not item.get("suggested_phase")]
+    return [
+        {
+            "status": WARN if missing_owner else OK,
+            "name": "roadmap_deferred_missing_owner",
+            "detail": f"{len(missing_owner)} deferred item(s) missing owner" if missing_owner else "none",
+            "items": missing_owner,
+        },
+        {
+            "status": WARN if missing_phase else OK,
+            "name": "roadmap_deferred_missing_phase",
+            "detail": f"{len(missing_phase)} deferred item(s) missing suggested phase" if missing_phase else "none",
+            "items": missing_phase,
+        },
+    ]
+
+
 def audit_payload(target: Path) -> dict[str, Any]:
     target = target.expanduser().resolve()
     roadmap = _parse_roadmap(target)
@@ -400,10 +556,14 @@ def audit_payload(target: Path) -> dict[str, Any]:
             "commands": missing_docs[:20],
         }
     )
+    deferred_items = _deferred_items()
+    checks.extend(_deferred_item_checks(deferred_items))
     issues = [check for check in checks if check.get("status") != OK]
     return {
         "target": str(target),
         "roadmap": roadmap,
+        "deferred_items": deferred_items,
+        "deferred_item_count": len(deferred_items),
         "documented_commands": documented,
         "normalized_documented_commands": normalized_documented,
         "cli_commands": cli_commands,
@@ -463,6 +623,7 @@ def audit(*, target: Path, json_output: bool = False, import_issues: bool = Fals
     print(f"roadmap audit: {payload['target']}")
     print(f"roadmap: {payload['roadmap']['path']}")
     print(f"sections: {len(payload['roadmap']['sections'])}")
+    print(f"deferred_items: {payload['deferred_item_count']}")
     print(f"issues: {payload['issue_count']}")
     for check in payload["checks"]:
         print(f"[{check['status']}] {check['name']}: {check['detail']}")

tests/test_roadmap_cmd.py

@@ -61,6 +61,24 @@ def test_roadmap_audit_json_and_imports(tmp_path, capsys):
     assert all(item["source"] == "roadmap-audit" for item in _read_imports(tmp_path))
 
 
+def test_roadmap_audit_includes_deferred_ownership_records(tmp_path, capsys):
+    (tmp_path / "ROADMAP.md").write_text("# Roadmap\n")
+    payload = roadmap_cmd.audit_payload(tmp_path)
+
+    deferred = {item["id"]: item for item in payload["deferred_items"]}
+    item = deferred["cross-producer-provenance-audit"]
+    assert item["owner"] == "work"
+    assert item["subsystem"] == "work-inbox"
+    assert item["deferred_reason"]
+    assert item["suggested_phase"] == 64
+    assert payload["deferred_item_count"] >= 10
+    assert all(check["status"] == "ok" for check in payload["checks"] if check["name"].startswith("roadmap_deferred_"))
+
+    assert roadmap_cmd.audit(target=tmp_path, json_output=False) == 0
+    out = capsys.readouterr().out
+    assert "deferred_items:" in out
+
+
 def test_roadmap_patterns_cover_neutral_families_and_decisions(capsys, tmp_path):
     assert roadmap_cmd.patterns(target=tmp_path, json_output=True) == 0
     payload = json.loads(capsys.readouterr().out)