@seanyao/roll 2026.520.1 → 2026.521.2

package/lib/roll-init.py

@@ -1,8 +1,38 @@
 #!/usr/bin/env python3
-"""roll-init — v2 terminal view for `roll init` (US-VIEW-008)."""
+"""roll-init — v2 terminal view for `roll init`.
+
+Reads a single JSON document from stdin describing real step outcomes
+captured by the bash flow in `bin/roll cmd_init`. Renders the v2 UI
+(banner + horizontal rule + numbered steps + NEXT block) preserving the
+visual style of US-VIEW-008 but reflecting what actually happened.
+
+Input schema (single JSON object on stdin):
+  {
+    "kind": "init",                     # informational; UI label uses header_label
+    "header_label": "INIT",             # banner label (e.g. "INIT" / "REINIT")
+    "subtitle": "项目初始化",            # banner subtitle
+    "project_path": "/path/to/project", # right-aligned banner text
+    "steps": [
+      {"num": 1, "label": "Detect project type", "status": "ok"},
+      {"num": 2, "label": "Create AGENTS.md", "status": "ok",
+       "files": [["+", "AGENTS.md"]]},
+      {"num": 3, "label": "...", "status": "skip", "note": "already exists"},
+      {"num": 4, "label": "...", "status": "fail", "error": "permission denied"}
+    ],
+    "footer": {"status": "ok", "label": "Project ready"},
+    "next": [["Edit .roll/backlog.md", "open the backlog and add your first US"]]
+  }
+
+`status` values: ok | skip | fail.
+`files` ops:     "+" created  "~" merged  "·" unchanged  "✗" failed.
+
+If stdin is empty or invalid JSON, exit 1 with a short message — the
+renderer is no longer runnable standalone, it always renders real data.
+"""
 from __future__ import annotations
 
 import argparse
+import json
 import os
 import sys
 
@@ -12,32 +42,6 @@ if _LIB_DIR not in sys.path:
 import roll_render
 from roll_render import c, row, COLS
 
-# ════════════════════════════════════════════════════════════════════════════
-# Demo data — 6 steps mirror cmd_init's actual phases.
-# AC text: detect → AGENTS.md → BACKLOG.md → docs/features/ → merge CLAUDE.md → link skills
-# Each entry: (label, [(op, filename)]) where op ∈ {"+", "~"}.
-# ════════════════════════════════════════════════════════════════════════════
-
-_DEMO_STEPS = [
-    ("Detect project type",          []),
-    ("Create AGENTS.md",             [("+", "AGENTS.md")]),
-    ("Create .roll/backlog.md",      [("+", ".roll/backlog.md")]),
-    ("Create .roll/features/",       [("+", ".roll/features/")]),
-    ("Merge existing CLAUDE.md",     [("~", "CLAUDE.md")]),
-    ("Link skills to AI clients",    [("+", "~/.claude/skills/roll-build"),
-                                      ("+", "~/.claude/skills/roll-fix")]),
-]
-
-_NEXT_STEPS = [
-    ("Edit .roll/backlog.md",     "open the backlog and add your first US"),
-    ("Run roll loop now",         "execute one cycle manually to test the flow"),
-    ("Enable loop scheduling",    "roll loop on  — let it run hourly"),
-]
-
-
-# ════════════════════════════════════════════════════════════════════════════
-# Render
-# ════════════════════════════════════════════════════════════════════════════
 
 def _divider(char: str = "─") -> None:
     print(c("dim", char * min(COLS, 80)))
@@ -48,53 +52,104 @@ def _op_marker(op: str) -> str:
         return c("green", "+", bold=True)
     if op == "~":
         return c("amber", "~", bold=True)
+    if op == "·":
+        return c("dim", "·")
+    if op == "✗":
+        return c("red", "✗", bold=True)
     return c("dim", op)
 
 
-def render_demo(project_path: str = "~/myproject") -> None:
-    left  = "  " + c("blue", "INIT", bold=True) + c("dim", "  ·  ") + c("dim", "项目初始化")
+def _step_icon(status: str) -> str:
+    if status == "ok":
+        return c("green", "✓")
+    if status == "skip":
+        return c("amber", "↷")
+    if status == "fail":
+        return c("red", "✗", bold=True)
+    return c("dim", "·")
+
+
+def _file_color(op: str) -> str:
+    if op == "+":
+        return "green"
+    if op == "~":
+        return "amber"
+    if op == "✗":
+        return "red"
+    return "dim"
+
+
+def render(payload: dict) -> None:
+    header_label = payload.get("header_label", "INIT")
+    subtitle = payload.get("subtitle", "项目初始化")
+    project_path = payload.get("project_path", "")
+
+    left = "  " + c("blue", header_label, bold=True) + c("dim", "  ·  ") + c("dim", subtitle)
     right = c("dim", project_path) + "  "
     print(row(left, right))
     _divider()
     print()
 
-    for i, (label, files) in enumerate(_DEMO_STEPS, start=1):
-        num  = c("dim", f"  {i}.")
-        icon = c("green", "✓")
+    for step in payload.get("steps", []):
+        num = c("dim", f"  {step.get('num', 0)}.")
+        icon = _step_icon(step.get("status", "ok"))
+        label = step.get("label", "")
         print(f"{num} {icon}  {label}")
-        for op, fname in files:
+        for entry in step.get("files", []) or []:
+            op, fname = entry[0], entry[1]
             mark = _op_marker(op)
-            color = "green" if op == "+" else "amber"
+            color = _file_color(op)
             print("       " + mark + "  " + c(color, fname))
+        note = step.get("note") or step.get("error")
+        if note:
+            tone = "red" if step.get("status") == "fail" else "dim"
+            print("       " + c(tone, str(note)))
 
     print()
     _divider()
-    print("  " + c("green", "✓") + " " + c("green", "Project ready", bold=True))
-    print()
-    print("  " + c("pink", "NEXT", bold=True) + c("dim", "  ·  下一步"))
-    for i, (label, hint) in enumerate(_NEXT_STEPS, start=1):
-        num = c("dim", f"  {i}.")
-        print(f"{num} {c('fg', label, bold=True)}")
-        print("     " + c("dim", hint))
+
+    footer = payload.get("footer") or {}
+    f_status = footer.get("status", "ok")
+    f_label = footer.get("label", "Done")
+    icon_color = "green" if f_status == "ok" else "red"
+    icon = "✓" if f_status == "ok" else "✗"
+    print("  " + c(icon_color, icon) + " " + c(icon_color, f_label, bold=True))
+
+    next_items = payload.get("next") or []
+    if next_items:
+        print()
+        print("  " + c("pink", "NEXT", bold=True) + c("dim", "  ·  下一步"))
+        for i, entry in enumerate(next_items, start=1):
+            label = entry[0]
+            hint = entry[1] if len(entry) > 1 else ""
+            num = c("dim", f"  {i}.")
+            print(f"{num} {c('fg', label, bold=True)}")
+            if hint:
+                print("     " + c("dim", hint))
     _divider("═")
 
 
-# ════════════════════════════════════════════════════════════════════════════
-# Entry point
-# ════════════════════════════════════════════════════════════════════════════
+def _read_payload() -> dict:
+    raw = sys.stdin.read()
+    if not raw.strip():
+        sys.stderr.write("roll-init.py: expected JSON on stdin\n")
+        sys.exit(1)
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError as exc:
+        sys.stderr.write(f"roll-init.py: invalid JSON on stdin: {exc}\n")
+        sys.exit(1)
+
 
 def main() -> None:
     ap = argparse.ArgumentParser(add_help=False)
-    ap.add_argument("--demo",     action="store_true")
     ap.add_argument("--no-color", dest="no_color", action="store_true")
-    ap.add_argument("--en",       action="store_true")
-    ap.add_argument("--zh",       action="store_true")
     args, _ = ap.parse_known_args()
 
     if args.no_color or os.environ.get("NO_COLOR") or not sys.stdout.isatty():
         roll_render.USE_COLOR = False
 
-    render_demo(project_path=os.getcwd())
+    render(_read_payload())
 
 
 if __name__ == "__main__":

package/lib/roll-loop-status.py

@@ -17,7 +17,7 @@ Usage:
   python3 lib/roll-loop-status.py --days 7
   python3 lib/roll-loop-status.py --no-color
   python3 lib/roll-loop-status.py --en | --zh  # collapse bilingual rows
-  python3 lib/roll-loop-status.py --demo       # render with fixture data
+  ROLL_RENDER_FIXTURE=1 python3 lib/roll-loop-status.py   # render with fixture data (test only)
 
   Wire it in bin/roll under `loop status` (replace _loop_status with a call to
   this script).
@@ -206,9 +206,19 @@ def aggregate(events: List[Dict[str, Any]], cron: List[Dict[str, Any]]) -> List[
         elif stage == "usage":
             # US-LOOP-004: loop-fmt emits this with full token / cost data.
             # Detail is a dict (not the legacy string form).
+            # US-VIEW-010: token counts are per-turn deltas — sum across events
+            # so list-price cost computed from totals matches actual API usage.
+            # Non-additive fields (model, cost_reported_usd, duration_ms) take
+            # the last value seen.
             d = e.get("detail") or {}
             if isinstance(d, dict):
-                cy["usage_event"] = d
+                prev = cy.get("usage_event") or {}
+                merged = dict(prev)
+                merged.update(d)
+                for k in ("input_tokens", "output_tokens",
+                          "cache_creation_tokens", "cache_read_tokens"):
+                    merged[k] = int(prev.get(k) or 0) + int(d.get(k) or 0)
+                cy["usage_event"] = merged
         elif stage in ("test", "build") and e.get("outcome") == "fail":
             cy["fail_detail"] = detail or stage
 
@@ -315,8 +325,7 @@ def backfill_usage_from_claude_sessions(cycles: List[Dict[str, Any]], slug: str)
     for cy in cycles:
         # Path 1: usage event written by loop-fmt at result time.
         ue = cy.get("usage_event")
-        if isinstance(ue, dict) and (ue.get("input_tokens") or ue.get("output_tokens")
-                                     or ue.get("cost_reported_usd")):
+        if isinstance(ue, dict) and (ue.get("input_tokens") or ue.get("output_tokens")):
             cy["tokens"] = mp.total_tokens(
                 input_tokens=ue.get("input_tokens", 0),
                 output_tokens=ue.get("output_tokens", 0),
@@ -324,20 +333,18 @@ def backfill_usage_from_claude_sessions(cycles: List[Dict[str, Any]], slug: str)
                 cache_read_tokens=ue.get("cache_read_tokens", 0),
             )
             cy["model"] = ue.get("model")
-            # FIX-060: cost_reported_usd is the authoritative cumulative session
-            # cost written by loop-fmt; use it directly instead of recomputing
-            # from the last individual API-call token counts (which would only
-            # reflect one small call and badly undercount the true cycle cost).
-            if ue.get("cost_reported_usd"):
-                cy["cost_list"] = float(ue["cost_reported_usd"])
-            else:
-                cy["cost_list"] = mp.compute_list_cost(
-                    ue.get("model"),
-                    input_tokens=ue.get("input_tokens", 0),
-                    output_tokens=ue.get("output_tokens", 0),
-                    cache_creation_tokens=ue.get("cache_creation_tokens", 0),
-                    cache_read_tokens=ue.get("cache_read_tokens", 0),
-                )
+            # US-VIEW-010: aggregate now sums per-turn usage tokens, so the
+            # totals in `ue` reflect the whole cycle. Always compute cost at
+            # list price for cross-account comparability — supersedes FIX-060
+            # which preferred cost_reported_usd as a workaround for
+            # last-event-only token counts (that root cause is now gone).
+            cy["cost_list"] = mp.compute_list_cost(
+                ue.get("model"),
+                input_tokens=ue.get("input_tokens", 0),
+                output_tokens=ue.get("output_tokens", 0),
+                cache_creation_tokens=ue.get("cache_creation_tokens", 0),
+                cache_read_tokens=ue.get("cache_read_tokens", 0),
+            )
             if ue.get("duration_ms") and not cy.get("duration_s"):
                 cy["duration_s"] = int(ue["duration_ms"] / 1000)
             continue
@@ -699,7 +706,7 @@ def render(events, cron, state, backlog, *, days=3, lang="both", now=None,
           c("muted", "       ") +
           c("dim", "watch   ") + c("blue", "roll loop --watch") +
           c("muted", "       ") +
-          c("dim", "more   ") + c("blue", "roll loop --days 7"))
+          c("dim", "more   ") + c("blue", "roll loop status --days 7"))
 
 def _read_plist_loop_minute() -> int:
     """FIX-063: read actual loop Minute from launchd plist (truth source).
@@ -733,9 +740,9 @@ def _next_cron_hint(state: Dict[str, str], zh: bool = False) -> str:
     return nxt.strftime("%H:%M") + f" · in {mins}m {secs:02d}s"
 
 # ════════════════════════════════════════════════════════════════════════════
-# Demo fixture — lets you preview the output without real data
+# Fixture data (test-only; opt in via ROLL_RENDER_FIXTURE=1)
 # ════════════════════════════════════════════════════════════════════════════
-def _demo_data():
+def _fixture_data():
     now = datetime.now(timezone.utc)
     events, cron = [], []
     cycle_id = 0
@@ -788,7 +795,6 @@ def main(argv=None):
     p.add_argument("--no-color", action="store_true", help="strip ANSI (also honors NO_COLOR=1)")
     p.add_argument("--en", action="store_true", help="EN rows only")
     p.add_argument("--zh", action="store_true", help="ZH rows only")
-    p.add_argument("--demo", action="store_true", help="render with fixture data")
     args = p.parse_args(argv)
 
     roll_render.USE_COLOR = (not args.no_color
@@ -797,10 +803,12 @@ def main(argv=None):
 
     lang = "en" if args.en else ("zh" if args.zh else "both")
 
-    if args.demo:
-        events, cron, state, backlog = _demo_data()
+    use_fixture = bool(os.environ.get("ROLL_RENDER_FIXTURE"))
+    if use_fixture:
+        events, cron, state, backlog = _fixture_data()
         runs = {}
         git_merges = {}
+        slug = None
     else:
         slug = project_slug()
         events     = load_events(slug, args.days)
@@ -812,7 +820,7 @@ def main(argv=None):
 
     render(events, cron, state, backlog, days=args.days, lang=lang,
            runs=runs, git_merges=git_merges,
-           claude_slug=None if args.demo else slug)
+           claude_slug=slug)
 
 if __name__ == "__main__":
     try:

package/lib/roll-peer.py

@@ -50,10 +50,11 @@ def _agent_c(name: str) -> str:
 
 
 # ════════════════════════════════════════════════════════════════════════════
-# Demo data — illustrative cross-agent review: claude proposes, codex reviews
+# Fixture data (test-only; opt in via ROLL_RENDER_FIXTURE=1)
+# Illustrative cross-agent review: claude proposes, codex reviews
 # ════════════════════════════════════════════════════════════════════════════
 
-_DEMO_SUBJECT = {
+_FIXTURE_SUBJECT = {
     "story":     "US-AUTH-014",
     "title":     "Session refresh fallback when refresh-token API 5xx",
     "pr":        "#412",
@@ -63,7 +64,7 @@ _DEMO_SUBJECT = {
     "reviewer":  "codex",
 }
 
-_DEMO_ROUNDS = [
+_FIXTURE_ROUNDS = [
     {
         "n": 1,
         "hint": "first pass — proposer ships, reviewer probes",
@@ -93,13 +94,13 @@ _DEMO_ROUNDS = [
     },
 ]
 
-_DEMO_VERDICT = {
+_FIXTURE_VERDICT = {
     "outcome": "approved",
     "reason":  "2 rounds · 5 turns · all blocks resolved",
 }
 
-_DEMO_ARTIFACT = "~/.roll/.peer-state/logs/20260519_213700_claude_codex.md"
-_DEMO_NEXT = [
+_FIXTURE_ARTIFACT = "~/.roll/.peer-state/logs/20260519_213700_claude_codex.md"
+_FIXTURE_NEXT = [
     ("Continue execution",   "claude resumes work on US-AUTH-014"),
     ("Inspect log",          "open the artifact above to replay the transcript"),
 ]
@@ -205,19 +206,19 @@ def _footer(artifact: str, next_steps: list) -> None:
 # Top-level render
 # ════════════════════════════════════════════════════════════════════════════
 
-def render_demo() -> None:
-    _eyebrow(_DEMO_SUBJECT["trigger"])
+def render_fixture() -> None:
+    _eyebrow(_FIXTURE_SUBJECT["trigger"])
     _divider()
     print()
-    _subject(_DEMO_SUBJECT)
+    _subject(_FIXTURE_SUBJECT)
     print()
-    _pair_overview(_DEMO_SUBJECT)
-    for rd in _DEMO_ROUNDS:
+    _pair_overview(_FIXTURE_SUBJECT)
+    for rd in _FIXTURE_ROUNDS:
         _round_header(rd["n"], rd["hint"])
         for agent, weight, body in rd["turns"]:
             _turn(agent, weight, body)
-    _verdict(_DEMO_VERDICT)
-    _footer(_DEMO_ARTIFACT, _DEMO_NEXT)
+    _verdict(_FIXTURE_VERDICT)
+    _footer(_FIXTURE_ARTIFACT, _FIXTURE_NEXT)
 
 
 # ════════════════════════════════════════════════════════════════════════════
@@ -226,7 +227,6 @@ def render_demo() -> None:
 
 def main() -> None:
     ap = argparse.ArgumentParser(add_help=False)
-    ap.add_argument("--demo",     action="store_true")
     ap.add_argument("--no-color", dest="no_color", action="store_true")
     ap.add_argument("--en",       action="store_true")
     ap.add_argument("--zh",       action="store_true")
@@ -235,7 +235,17 @@ def main() -> None:
     if args.no_color or os.environ.get("NO_COLOR") or not sys.stdout.isatty():
         roll_render.USE_COLOR = False
 
-    render_demo()
+    # FIX-076: this standalone entrypoint only knows how to render the fixture
+    # transcript (for UI tests). Real peer review is orchestrated by bin/roll
+    # and never invokes this main(). Require an explicit opt-in so a stray
+    # `python3 lib/roll-peer.py` invocation can't masquerade as live output.
+    if not os.environ.get("ROLL_RENDER_FIXTURE"):
+        print("Error: lib/roll-peer.py only renders fixture data; "
+              "set ROLL_RENDER_FIXTURE=1 to use it (test-only).",
+              file=sys.stderr)
+        sys.exit(2)
+
+    render_fixture()
 
 
 if __name__ == "__main__":

package/lib/roll-setup.py

@@ -1,61 +1,101 @@
 #!/usr/bin/env python3
-"""roll-setup — v2 terminal view for `roll setup`."""
+"""roll-setup — v2 terminal view for `roll setup`.
+
+Reads a single JSON document from stdin describing the real outcomes of
+`bin/roll cmd_setup`'s step sequence (detect platform / install skills /
+sync conventions / etc). Renders the v2 UI preserving the visual style
+of US-VIEW-007 while reflecting actual results.
+
+Input schema matches `lib/roll-init.py` (see that file for details).
+"""
 from __future__ import annotations
 
+import argparse
+import json
 import os
 import sys
 
 _LIB_DIR = os.path.dirname(os.path.realpath(__file__))
 if _LIB_DIR not in sys.path:
     sys.path.insert(0, _LIB_DIR)
+import roll_render
 from roll_render import c, row, COLS
 
-# ════════════════════════════════════════════════════════════════════════════
-# Demo data
-# ════════════════════════════════════════════════════════════════════════════
-
-_DEMO_STEPS = [
-    "Detect platform & shell",
-    "Fetch latest roll version",
-    "Install skills to ~/.claude",
-    "Symlink bin/roll to PATH",
-    "Check for config drift",
-    "Apply convention templates",
-]
-
-# ════════════════════════════════════════════════════════════════════════════
-# Rendering
-# ════════════════════════════════════════════════════════════════════════════
 
 def _divider(char: str = "─") -> None:
     print(c("dim", char * min(COLS, 80)))
 
 
-def render_demo() -> None:
-    left  = "  " + c("blue", "SETUP", bold=True) + c("dim", "  ·  ") + c("dim", "初始化")
-    right = c("dim", "--demo")
-    print(row(left, "  " + right))
+def _step_icon(status: str) -> str:
+    if status == "ok":
+        return c("green", "✓")
+    if status == "skip":
+        return c("amber", "↷")
+    if status == "forced":
+        return c("blue", "~")
+    if status == "fail":
+        return c("red", "✗", bold=True)
+    return c("dim", "·")
+
+
+def render(payload: dict) -> None:
+    header_label = payload.get("header_label", "SETUP")
+    subtitle = payload.get("subtitle", "初始化")
+    right_text = payload.get("project_path") or payload.get("right", "")
+
+    left = "  " + c("blue", header_label, bold=True) + c("dim", "  ·  ") + c("dim", subtitle)
+    right = c("dim", right_text) + "  " if right_text else ""
+    print(row(left, right))
     _divider()
     print()
 
-    for i, label in enumerate(_DEMO_STEPS, start=1):
-        num  = c("dim", f"  {i}.")
-        icon = c("green", "✓")
+    for step in payload.get("steps", []):
+        num = c("dim", f"  {step.get('num', 0)}.")
+        icon = _step_icon(step.get("status", "ok"))
+        label = step.get("label", "")
         print(f"{num} {icon}  {label}")
+        note = step.get("note") or step.get("error")
+        if note:
+            tone = "red" if step.get("status") == "fail" else "dim"
+            print("       " + c(tone, str(note)))
 
     print()
     _divider()
-    msg = c("green", "Setup complete")
-    print(f"  {msg}  —  run {c('fg', 'roll init', bold=True)} inside a project to begin")
+
+    footer = payload.get("footer") or {}
+    f_status = footer.get("status", "ok")
+    f_label = footer.get("label", "Setup complete")
+    icon_color = "green" if f_status == "ok" else "red"
+    msg = c(icon_color, f_label)
+    next_hint = footer.get("hint")
+    if next_hint:
+        print(f"  {msg}  —  {next_hint}")
+    else:
+        print(f"  {msg}")
     _divider("═")
 
 
-# ════════════════════════════════════════════════════════════════════════════
-# Entry point
-# ════════════════════════════════════════════════════════════════════════════
+def _read_payload() -> dict:
+    raw = sys.stdin.read()
+    if not raw.strip():
+        sys.stderr.write("roll-setup.py: expected JSON on stdin\n")
+        sys.exit(1)
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError as exc:
+        sys.stderr.write(f"roll-setup.py: invalid JSON on stdin: {exc}\n")
+        sys.exit(1)
+
 
 def main() -> None:
-    render_demo()
+    ap = argparse.ArgumentParser(add_help=False)
+    ap.add_argument("--no-color", dest="no_color", action="store_true")
+    args, _ = ap.parse_known_args()
+
+    if args.no_color or os.environ.get("NO_COLOR") or not sys.stdout.isatty():
+        roll_render.USE_COLOR = False
+
+    render(_read_payload())
 
 
 if __name__ == "__main__":

package/lib/roll-status.py

@@ -8,7 +8,7 @@ project templates, and this-project metrics.
 Usage:
   python3 lib/roll-status.py              # live data
   python3 lib/roll-status.py --no-color
-  python3 lib/roll-status.py --demo       # render with fixture data
+  ROLL_RENDER_FIXTURE=1 python3 lib/roll-status.py   # render with fixture data (test only)
 """
 
 from __future__ import annotations
@@ -149,9 +149,9 @@ def _launchd_state(service: str, slug: str) -> str:
         return "installed-off"
 
 # ════════════════════════════════════════════════════════════════════════════
-# Demo fixture
+# Fixture data (test-only; opt in via ROLL_RENDER_FIXTURE=1)
 # ════════════════════════════════════════════════════════════════════════════
-def _demo_data() -> Dict[str, Any]:
+def _fixture_data() -> Dict[str, Any]:
     return dict(
         conventions=[
             ("AGENTS.md", True), ("CLAUDE.md", True), ("GEMINI.md", False),
@@ -347,7 +347,6 @@ def _live_data() -> Dict[str, Any]:
 # ════════════════════════════════════════════════════════════════════════════
 def main() -> None:
     ap = argparse.ArgumentParser(add_help=False)
-    ap.add_argument("--demo",     action="store_true")
     ap.add_argument("--no-color", dest="no_color", action="store_true")
     ap.add_argument("--en",       action="store_true")
     ap.add_argument("--zh",       action="store_true")
@@ -356,7 +355,7 @@ def main() -> None:
     if args.no_color or os.environ.get("NO_COLOR") or not sys.stdout.isatty():
         roll_render.USE_COLOR = False
 
-    d = _demo_data() if args.demo else _live_data()
+    d = _fixture_data() if os.environ.get("ROLL_RENDER_FIXTURE") else _live_data()
 
     _render_health(d)
     _render_global_conventions(d["conventions"])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seanyao/roll",
-  "version": "2026.520.1",
+  "version": "2026.521.2",
   "description": "Roll — Roll out features with AI agents",
   "scripts": {
     "test": "bash tests/run.sh"