Skip to content

An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.

Rust

omx(team): auto-checkpoint worker-1 [1]

bellman83116555ff6a
diff --git a/scripts/generate_cc2_board.py b/scripts/generate_cc2_board.py
new file mode 100755
index 00000000..3c547d83
--- /dev/null
+++ b/scripts/generate_cc2_board.py
@@ -0,0 +1,514 @@
+#!/usr/bin/env python3
+"""Generate the canonical Claw Code 2.0 execution board from frozen roadmap evidence."""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import re
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+REQUIRED_ITEM_FIELDS = [
+ "id",
+ "title",
+ "source_anchor",
+ "source_type",
+ "release_bucket",
+ "status",
+ "dependencies",
+ "verification_required",
+ "deferral_rationale",
+]
+STATUSES = {
+ "context",
+ "active",
+ "open",
+ "done_verify",
+ "stale_done",
+ "superseded",
+ "deferred_with_rationale",
+ "rejected_not_claw",
+}
+RELEASE_BUCKETS = {
+ "alpha_blocker",
+ "beta_adoption",
+ "ga_ecosystem",
+ "post_2_0_research",
+ "rejected_not_claw",
+ "context",
+ "2.x_intake",
+}
+
+STRUCTURAL_HEADINGS = {
+ "Clawable Coding Harness Roadmap",
+ "Goal",
+ 'Definition of "clawable"',
+ "Current Pain Points",
+ "Product Principles",
+ "Roadmap",
+ "Immediate Backlog (from current real pain)",
+ "Deployment Architecture Gap (filed from dogfood 2026-04-08)",
+ "Startup Friction Gap: No Default trusted_roots in Settings (filed 2026-04-08)",
+ "Observability Transport Decision (filed 2026-04-08)",
+ "Provider Routing: Model-Name Prefix Must Win Over Env-Var Presence (fixed 2026-04-08, `0530c50`)",
+}
+
+CATEGORY_KEYWORDS = [
+ ("security", ["security", "sandbox", "permission", "trust", "approval-token", "denied"]),
+ ("windows_install", ["windows", "install", "path", "release", "binary", "container"]),
+ ("provider", ["provider", "model", "openai", "anthropic", "ollama", "llama", "vllm", "credential"]),
+ ("sessions", ["session", "resume", "compact", "context-window", "thread"]),
+ ("docs_license", ["docs", "readme", "usage", "license", "help", "onboarding"]),
+ ("ide_acp", ["zed", "acp", "editor", "daemon"]),
+ ("plugin_mcp", ["plugin", "mcp", "marketplace", "server"]),
+ ("event_report", ["event", "report", "schema", "projection", "redaction", "clawhip", "lane"]),
+ ("branch_recovery", ["branch", "stale", "recovery", "green", "flake"]),
+ ("boot", ["boot", "worker", "startup", "ready", "prompt"]),
+ ("task_policy", ["task", "policy", "claw-native", "dashboard", "lane board"]),
+ ("ux_tui", ["tui", "statusline", "keymap", "clickable", "copy", "paste"]),
+ ("anti_slop", ["spam", "slop", "issue hygiene", "bot"]),
+]
+
+@dataclass(frozen=True)
+class RoadmapRecord:
+ line: int
+ level: int
+ title: str
+ path: str
+ source_type: str
+ ordinal: int | None = None
+
+
+def sha256_prefix(path: Path, length: int = 16) -> str:
+ return hashlib.sha256(path.read_bytes()).hexdigest()[:length]
+
+
+def slugify(text: str, limit: int = 54) -> str:
+ slug = re.sub(r"[^a-z0-9]+", "-", text.lower()).strip("-")
+ return slug[:limit].strip("-") or "item"
+
+
+def find_source_omx(repo_root: Path) -> Path:
+ candidates = []
+ env = None
+ try:
+ import os
+ env = os.environ.get("CC2_SOURCE_OMX")
+ except Exception:
+ env = None
+ if env:
+ candidates.append(Path(env).expanduser())
+ candidates.append(repo_root / ".omx")
+ candidates.extend(parent / ".omx" for parent in repo_root.parents)
+ for candidate in candidates:
+ if (candidate / "plans" / "claw-code-2-0-adaptive-plan.md").exists() and (candidate / "research").exists():
+ return candidate
+ raise FileNotFoundError("could not locate source .omx with plans/claw-code-2-0-adaptive-plan.md and research/")
+
+
+def parse_roadmap(path: Path) -> tuple[list[RoadmapRecord], list[RoadmapRecord]]:
+ headings: list[RoadmapRecord] = []
+ actions: list[RoadmapRecord] = []
+ stack: list[tuple[str, int, int]] = []
+ for line_no, line in enumerate(path.read_text(encoding="utf-8").splitlines(), 1):
+ heading = re.match(r"^(#{1,6})\s+(.*?)(?:\s+#+)?\s*$", line)
+ if heading:
+ level = len(heading.group(1))
+ title = heading.group(2).strip()
+ stack = [entry for entry in stack if entry[1] < level] + [(title, level, line_no)]
+ headings.append(RoadmapRecord(line_no, level, title, " > ".join(entry[0] for entry in stack), "roadmap_heading"))
+ continue
+ ordered = re.match(r"^(\s*)(\d+)\.\s+(.+?)\s*$", line)
+ if ordered and len(ordered.group(1)) <= 4:
+ title = ordered.group(3).strip()
+ if len(title) > 10:
+ actions.append(
+ RoadmapRecord(
+ line_no,
+ len(stack[-1][0]) if stack else 0,
+ title,
+ " > ".join(entry[0] for entry in stack),
+ "roadmap_action",
+ int(ordered.group(2)),
+ )
+ )
+ return headings, actions
+
+
+def category_for(text: str) -> str:
+ lower = text.lower()
+ for category, needles in CATEGORY_KEYWORDS:
+ if any(needle in lower for needle in needles):
+ return category
+ return "governance"
+
+
+def stream_for(record: RoadmapRecord) -> str:
+ title = record.title.lower()
+ path = record.path.lower()
+ combined = f"{path} {title}"
+ if "phase 1" in combined or category_for(combined) == "boot":
+ return "stream_1_worker_boot_session_control"
+ if "phase 2" in combined or category_for(combined) == "event_report":
+ return "stream_2_event_reporting_contracts"
+ if "phase 3" in combined or category_for(combined) == "branch_recovery":
+ return "stream_3_branch_test_recovery"
+ if "phase 4" in combined or category_for(combined) == "task_policy":
+ return "stream_4_claws_first_execution"
+ if "phase 5" in combined or category_for(combined) == "plugin_mcp":
+ return "stream_5_plugin_mcp_lifecycle"
+ if any(k in combined for k in ["windows", "install", "provider", "docs", "license", "session hygiene", "compact"]):
+ return "adoption_overlay"
+ if any(k in combined for k in ["zed", "acp", "desktop", "marketplace", "package"]):
+ return "parity_overlay"
+ return "stream_0_governance"
+
+
+def release_bucket_for(record: RoadmapRecord, status: str) -> str:
+ combined = f"{record.path} {record.title}".lower()
+ category = category_for(combined)
+ if status == "context":
+ return "context"
+ if status == "rejected_not_claw":
+ return "rejected_not_claw"
+ if any(k in combined for k in ["phase 1", "phase 2", "phase 3", "phase 4", "p0", "p1", "security", "sandbox", "trust", "worker", "event", "branch freshness"]):
+ return "alpha_blocker"
+ if category in {"windows_install", "provider", "sessions", "docs_license", "anti_slop"}:
+ return "beta_adoption"
+ if category in {"plugin_mcp", "ide_acp", "ux_tui"}:
+ return "ga_ecosystem"
+ if any(k in combined for k in ["desktop", "share", "cloud", "research", "post-2.0", "future"]):
+ return "post_2_0_research"
+ if "pinpoint" in combined:
+ return "alpha_blocker"
+ return "beta_adoption"
+
+
+def status_for(record: RoadmapRecord) -> str:
+ title = record.title
+ combined = f"{record.path} {title}".lower()
+ if record.source_type == "roadmap_heading" and (record.level <= 2 or title in STRUCTURAL_HEADINGS):
+ # Phase headings are active work containers; other h1/h2 prose headings are context unless fixed/deferred wording says otherwise.
+ if title.startswith("Phase "):
+ return "active"
+ if "pinpoint" not in title.lower() and not any(word in combined for word in ["gap", "routing"]):
+ return "context"
+ if any(word in combined for word in ["rejected_not_claw", "not claw", "outside claw"]):
+ return "rejected_not_claw"
+ if "superseded" in combined:
+ return "superseded"
+ if "deferred" in combined or "post-2.0" in combined or "post_2_0" in combined:
+ return "deferred_with_rationale"
+ if any(word in combined for word in ["done", "implemented", "fixed", "verified", "re-verified", "landed", "green"]):
+ if any(word in combined for word in ["stale", "old filing", "original filing below", "no longer reproduces"]):
+ return "stale_done"
+ return "done_verify"
+ if title.lower().startswith(("evidence for", "trace path", "actual root cause", "meta-lesson")):
+ return "context"
+ return "open" if "pinpoint" in combined or record.source_type == "roadmap_action" else "active"
+
+
+def deferral_for(record: RoadmapRecord, status: str) -> str:
+ if status == "deferred_with_rationale":
+ return "Deferred by roadmap/approved plan until prerequisite contracts or post-2.0 research admission gates are satisfied."
+ if status == "rejected_not_claw":
+ return "Rejected because the source describes clone-only breadth or behavior outside Claw's machine-truth/clawable-harness identity."
+ if status == "superseded":
+ return "Superseded by a newer roadmap entry or canonical Rust/control-plane contract; keep only for audit traceability."
+ if status == "stale_done":
+ return "Marked done in roadmap but needs freshness re-verification before being used as release evidence."
+ return ""
+
+
+def verification_for(record: RoadmapRecord, status: str) -> str:
+ if status == "context":
+ return "none_context_only"
+ if status in {"done_verify", "stale_done"}:
+ return "verify_existing_evidence_and_regression_guard"
+ cat = category_for(f"{record.path} {record.title}")
+ if cat == "docs_license":
+ return "docs_snapshot_or_help_output_check"
+ if cat == "windows_install":
+ return "install_matrix_or_cross_platform_smoke"
+ if cat == "provider":
+ return "provider_routing_contract_test"
+ if cat == "plugin_mcp":
+ return "plugin_mcp_lifecycle_contract_test"
+ if cat == "event_report":
+ return "schema_golden_fixture_or_consumer_contract_test"
+ if cat == "branch_recovery":
+ return "git_fixture_or_recovery_recipe_test"
+ if cat == "boot":
+ return "worker_boot_state_machine_or_cli_json_contract_test"
+ return "targeted_regression_or_acceptance_test_required"
+
+
+def dependencies_for(record: RoadmapRecord, status: str) -> list[str]:
+ combined = f"{record.path} {record.title}".lower()
+ deps: list[str] = []
+ if status == "context":
+ return deps
+ if "phase 2" in combined or category_for(combined) == "event_report":
+ deps.append("stream_1_worker_boot_session_control")
+ if "phase 3" in combined or category_for(combined) == "branch_recovery":
+ deps.append("stream_2_event_reporting_contracts")
+ if "phase 4" in combined or category_for(combined) == "task_policy":
+ deps.append("stream_2_event_reporting_contracts")
+ if "phase 5" in combined or category_for(combined) == "plugin_mcp":
+ deps.append("stream_1_worker_boot_session_control")
+ if any(k in combined for k in ["zed", "acp", "desktop", "marketplace"]):
+ deps.append("stable_alpha_contracts")
+ if any(k in combined for k in ["provider", "install", "windows", "docs", "license"]):
+ deps.append("adoption_overlay_triage")
+ return sorted(set(deps))
+
+
+def roadmap_item(record: RoadmapRecord, index: int) -> dict[str, Any]:
+ status = status_for(record)
+ item_id = f"CC2-RM-{'H' if record.source_type == 'roadmap_heading' else 'A'}{index:04d}-{slugify(record.title, 40)}"
+ bucket = release_bucket_for(record, status)
+ return {
+ "id": item_id,
+ "title": record.title,
+ "source_anchor": f"ROADMAP.md:L{record.line}",
+ "source_type": record.source_type,
+ "source_path": record.path,
+ "source_line": record.line,
+ "source_level": record.level if record.source_type == "roadmap_heading" else None,
+ "source_ordinal": record.ordinal,
+ "release_bucket": bucket,
+ "lifecycle_status": status,
+ "status": status,
+ "category": category_for(f"{record.path} {record.title}"),
+ "owner_lane": stream_for(record),
+ "dependencies": dependencies_for(record, status),
+ "verification_required": verification_for(record, status),
+ "deferral_rationale": deferral_for(record, status),
+ }
+
+
+def load_json(path: Path) -> Any:
+ return json.loads(path.read_text(encoding="utf-8"))
+
+
+def issue_item(issue: dict[str, Any], source_name: str, source_type: str, bucket: str) -> dict[str, Any]:
+ title = issue.get("title") or f"Issue #{issue.get('number')}"
+ number = issue.get("number")
+ body = f"{title} {issue.get('body') or ''}"
+ status = "open" if issue.get("state", "OPEN").lower() != "closed" else "done_verify"
+ return {
+ "id": f"CC2-ISSUE-{source_name.upper()}-{number}",
+ "title": title,
+ "source_anchor": f".omx/research/{source_name}.json#issue-{number}",
+ "source_type": source_type,
+ "source_path": f".omx/research/{source_name}.json",
+ "issue_number": number,
+ "issue_url": issue.get("url"),
+ "release_bucket": bucket,
+ "lifecycle_status": status,
+ "status": status,
+ "category": category_for(body),
+ "owner_lane": stream_for(RoadmapRecord(0, 0, title, title, source_type)),
+ "dependencies": ["roadmap_board_triage"],
+ "verification_required": "issue_acceptance_repro_or_triage_decision",
+ "deferral_rationale": "Latest issue intake is admitted only when it matches freeze/admission rules; otherwise remains 2.x_intake." if bucket == "2.x_intake" else "",
+ }
+
+
+def repo_context_item(meta: dict[str, Any], source_name: str) -> dict[str, Any]:
+ owner = meta.get("nameWithOwner", source_name)
+ return {
+ "id": f"CC2-PARITY-{source_name.upper()}-REPO-CONTEXT",
+ "title": f"Parity source metadata: {owner}",
+ "source_anchor": f".omx/research/{source_name}-repo.json",
+ "source_type": "parity_repo_context",
+ "source_path": f".omx/research/{source_name}-repo.json",
+ "release_bucket": "context",
+ "lifecycle_status": "context",
+ "status": "context",
+ "category": "governance",
+ "owner_lane": "parity_overlay",
+ "dependencies": [],
+ "verification_required": "none_context_only",
+ "deferral_rationale": "",
+ "repo": {
+ "nameWithOwner": owner,
+ "url": meta.get("url"),
+ "pushedAt": meta.get("pushedAt"),
+ "latestRelease": meta.get("latestRelease"),
+ "licenseInfo": meta.get("licenseInfo"),
+ },
+ }
+
+
+def summarize_counts(items: list[dict[str, Any]], key: str) -> dict[str, int]:
+ out: dict[str, int] = {}
+ for item in items:
+ out[item[key]] = out.get(item[key], 0) + 1
+ return dict(sorted(out.items()))
+
+
+def render_markdown(board: dict[str, Any]) -> str:
+ lines = [
+ "# Claw Code 2.0 Canonical Board",
+ "",
+ f"Generated: `{board['generated_at']}`",
+ f"Roadmap SHA-256 prefix: `{board['sources']['roadmap']['sha256_prefix']}`",
+ "",
+ "## Summary",
+ "",
+ f"- Total items: **{len(board['items'])}**",
+ f"- Roadmap headings covered: **{board['coverage']['roadmap_headings_total']} / {board['coverage']['roadmap_headings_mapped']}**",
+ f"- Roadmap ordered actions covered: **{board['coverage']['roadmap_actions_total']} / {board['coverage']['roadmap_actions_mapped']}**",
+ "",
+ "### By lifecycle status",
+ "",
+ ]
+ for status, count in board["summary"]["by_status"].items():
+ lines.append(f"- `{status}`: {count}")
+ lines.extend(["", "### By release bucket", ""])
+ for bucket, count in board["summary"]["by_release_bucket"].items():
+ lines.append(f"- `{bucket}`: {count}")
+ lines.extend(["", "## Board Items", ""])
+ for item in board["items"]:
+ deps = ", ".join(item.get("dependencies") or []) or "none"
+ rationale = item.get("deferral_rationale") or ""
+ lines.extend([
+ f"### {item['id']}",
+ f"- Title: {item['title']}",
+ f"- Source: `{item['source_anchor']}` (`{item['source_type']}`)",
+ f"- Bucket/status: `{item['release_bucket']}` / `{item['status']}`",
+ f"- Category/lane: `{item.get('category')}` / `{item.get('owner_lane')}`",
+ f"- Dependencies: {deps}",
+ f"- Verification: `{item['verification_required']}`",
+ f"- Deferral rationale: {rationale}",
+ "",
+ ])
+ return "\n".join(lines)
+
+
+def validate_board(board: dict[str, Any]) -> list[str]:
+ errors: list[str] = []
+ seen = set()
+ for index, item in enumerate(board.get("items", []), 1):
+ missing = [field for field in REQUIRED_ITEM_FIELDS if field not in item]
+ if missing:
+ errors.append(f"item {index} missing fields: {missing}")
+ if item.get("id") in seen:
+ errors.append(f"duplicate id: {item.get('id')}")
+ seen.add(item.get("id"))
+ if item.get("status") not in STATUSES:
+ errors.append(f"{item.get('id')} invalid status {item.get('status')}")
+ if item.get("release_bucket") not in RELEASE_BUCKETS:
+ errors.append(f"{item.get('id')} invalid release_bucket {item.get('release_bucket')}")
+ if not isinstance(item.get("dependencies"), list):
+ errors.append(f"{item.get('id')} dependencies must be list")
+ coverage = board.get("coverage", {})
+ if coverage.get("unmapped_roadmap_heading_lines"):
+ errors.append(f"unmapped heading lines: {coverage['unmapped_roadmap_heading_lines']}")
+ if coverage.get("duplicate_roadmap_heading_lines"):
+ errors.append(f"duplicate heading lines: {coverage['duplicate_roadmap_heading_lines']}")
+ if coverage.get("roadmap_headings_total") != coverage.get("roadmap_headings_mapped"):
+ errors.append("roadmap heading total/mapped mismatch")
+ return errors
+
+
+def build_board(repo_root: Path) -> dict[str, Any]:
+ roadmap_path = repo_root / "ROADMAP.md"
+ source_omx = find_source_omx(repo_root)
+ research = source_omx / "research"
+ plan_path = source_omx / "plans" / "claw-code-2-0-adaptive-plan.md"
+ headings, actions = parse_roadmap(roadmap_path)
+ items = [roadmap_item(record, i) for i, record in enumerate(headings, 1)]
+ items.extend(roadmap_item(record, i) for i, record in enumerate(actions, 1))
+
+ latest_issues = load_json(research / "claw-open-latest.json")
+ all_issues = load_json(research / "claw-issues.json")
+ items.extend(issue_item(issue, "claw-open-latest", "latest_open_issue", "2.x_intake") for issue in latest_issues)
+ # Include a small real-issue sample from the full freeze to keep the board tied to the larger issue manifest without exploding scope.
+ for issue in all_issues[:50]:
+ title_body = f"{issue.get('title','')} {issue.get('body','')}".lower()
+ if any(k in title_body for k in ["security", "windows", "install", "provider", "model", "session", "license", "zed", "spam", "plugin"]):
+ items.append(issue_item(issue, "claw-issues", "issue_theme", "beta_adoption"))
+ for source_name in ["opencode", "codex"]:
+ repo_meta = load_json(research / f"{source_name}-repo.json")
+ items.append(repo_context_item(repo_meta, source_name))
+
+ heading_lines = [record.line for record in headings]
+ mapped_heading_lines = [item["source_line"] for item in items if item.get("source_type") == "roadmap_heading"]
+ duplicate_heading_lines = sorted(line for line in set(mapped_heading_lines) if mapped_heading_lines.count(line) != 1)
+ unmapped_heading_lines = sorted(set(heading_lines) - set(mapped_heading_lines))
+
+ board = {
+ "schema_version": "cc2.board.v1",
+ "generated_at": datetime.now(timezone.utc).replace(microsecond=0).isoformat(),
+ "generation_policy": {
+ "ultragoal_mutation": "forbidden",
+ "roadmap_coverage": "all markdown headings plus top-level ordered roadmap actions",
+ "status_values": sorted(STATUSES),
+ "release_buckets": sorted(RELEASE_BUCKETS),
+ },
+ "sources": {
+ "roadmap": {
+ "path": "ROADMAP.md",
+ "sha256_prefix": sha256_prefix(roadmap_path),
+ "heading_count": len(headings),
+ "ordered_action_count": len(actions),
+ },
+ "approved_plan": {
+ "path": ".omx/plans/claw-code-2-0-adaptive-plan.md",
+ "sha256_prefix": sha256_prefix(plan_path),
+ },
+ "research": {
+ "root": str(source_omx / "research"),
+ "claw_open_latest_count": len(latest_issues),
+ "claw_issues_count": len(all_issues),
+ "opencode_repo": ".omx/research/opencode-repo.json",
+ "codex_repo": ".omx/research/codex-repo.json",
+ },
+ },
+ "coverage": {
+ "roadmap_headings_total": len(headings),
+ "roadmap_headings_mapped": len(mapped_heading_lines),
+ "unmapped_roadmap_heading_lines": unmapped_heading_lines,
+ "duplicate_roadmap_heading_lines": duplicate_heading_lines,
+ "roadmap_actions_total": len(actions),
+ "roadmap_actions_mapped": len([item for item in items if item.get("source_type") == "roadmap_action"]),
+ },
+ "summary": {},
+ "items": items,
+ }
+ board["summary"] = {
+ "by_status": summarize_counts(items, "status"),
+ "by_release_bucket": summarize_counts(items, "release_bucket"),
+ "by_source_type": summarize_counts(items, "source_type"),
+ "by_owner_lane": summarize_counts(items, "owner_lane"),
+ }
+ errors = validate_board(board)
+ if errors:
+ raise SystemExit("board validation failed:\n" + "\n".join(errors))
+ return board
+
+
+def main() -> int:
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument("--repo-root", type=Path, default=Path.cwd())
+ parser.add_argument("--out-dir", type=Path, default=None)
+ args = parser.parse_args()
+ repo_root = args.repo_root.resolve()
+ out_dir = args.out_dir or (repo_root / ".omx" / "cc2")
+ out_dir.mkdir(parents=True, exist_ok=True)
+ board = build_board(repo_root)
+ (out_dir / "board.json").write_text(json.dumps(board, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+ (out_dir / "board.md").write_text(render_markdown(board) + "\n", encoding="utf-8")
+ print(f"wrote {out_dir / 'board.json'}")
+ print(f"wrote {out_dir / 'board.md'}")
+ print(f"roadmap headings mapped: {board['coverage']['roadmap_headings_mapped']}/{board['coverage']['roadmap_headings_total']}")
+ print(f"roadmap actions mapped: {board['coverage']['roadmap_actions_mapped']}/{board['coverage']['roadmap_actions_total']}")
+ return 0
+
+if __name__ == "__main__":
+ raise SystemExit(main())
diff --git a/scripts/validate_cc2_board.py b/scripts/validate_cc2_board.py
new file mode 100755
index 00000000..b0a591cd
--- /dev/null
+++ b/scripts/validate_cc2_board.py
@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""Validate the generated Claw Code 2.0 board coverage and schema."""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+from pathlib import Path
+
+REQUIRED = {
+ "id",
+ "title",
+ "source_anchor",
+ "source_type",
+ "release_bucket",
+ "status",
+ "dependencies",
+ "verification_required",
+ "deferral_rationale",
+}
+STATUSES = {
+ "context",
+ "active",
+ "open",
+ "done_verify",
+ "stale_done",
+ "superseded",
+ "deferred_with_rationale",
+ "rejected_not_claw",
+}
+
+def roadmap_heading_lines(path: Path) -> list[int]:
+ lines = []
+ for line_no, line in enumerate(path.read_text(encoding="utf-8").splitlines(), 1):
+ if re.match(r"^#{1,6}\s+", line):
+ lines.append(line_no)
+ return lines
+
+
+def main() -> int:
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument("--repo-root", type=Path, default=Path.cwd())
+ parser.add_argument("--board", type=Path, default=None)
+ args = parser.parse_args()
+ repo_root = args.repo_root.resolve()
+ board_path = args.board or (repo_root / ".omx" / "cc2" / "board.json")
+ board = json.loads(board_path.read_text(encoding="utf-8"))
+ errors: list[str] = []
+ ids = set()
+ for index, item in enumerate(board.get("items", []), 1):
+ missing = REQUIRED - set(item)
+ if missing:
+ errors.append(f"item {index} missing required fields: {sorted(missing)}")
+ if item.get("id") in ids:
+ errors.append(f"duplicate id: {item.get('id')}")
+ ids.add(item.get("id"))
+ if item.get("status") not in STATUSES:
+ errors.append(f"{item.get('id')} invalid status {item.get('status')}")
+ if not isinstance(item.get("dependencies"), list):
+ errors.append(f"{item.get('id')} dependencies must be list")
+ expected = roadmap_heading_lines(repo_root / "ROADMAP.md")
+ mapped = [item.get("source_line") for item in board.get("items", []) if item.get("source_type") == "roadmap_heading"]
+ unmapped = sorted(set(expected) - set(mapped))
+ duplicates = sorted(line for line in set(mapped) if mapped.count(line) != 1)
+ if unmapped:
+ errors.append(f"unmapped ROADMAP headings: {unmapped}")
+ if duplicates:
+ errors.append(f"duplicate ROADMAP heading mappings: {duplicates}")
+ coverage = board.get("coverage", {})
+ if coverage.get("roadmap_headings_total") != len(expected):
+ errors.append("coverage roadmap_headings_total does not match ROADMAP.md")
+ if coverage.get("roadmap_headings_mapped") != len(mapped):
+ errors.append("coverage roadmap_headings_mapped does not match board items")
+ if errors:
+ print("FAIL cc2 board validation")
+ for error in errors:
+ print(f"- {error}")
+ return 1
+ print("PASS cc2 board validation")
+ print(f"- board: {board_path}")
+ print(f"- items: {len(board.get('items', []))}")
+ print(f"- ROADMAP headings mapped: {len(mapped)}/{len(expected)}")
+ print(f"- ROADMAP actions mapped: {coverage.get('roadmap_actions_mapped')}/{coverage.get('roadmap_actions_total')}")
+ return 0
+
+if __name__ == "__main__":
+ raise SystemExit(main())