@seanyao/roll 2026.519.3 → 2026.520.1

package/conventions/global/AGENTS.md

@@ -60,8 +60,9 @@
   - Before pushing any new code commit, verify the **previous** code-changing push's CI
     is green. Never stack new code commits on top of a red CI (this is the failure
     mode FIX-026 / `_loop_precheck_ci` exists to prevent for the loop — humans need
-    the same discipline). docs-only commits (matching CI `paths-ignore`) don't reset
-    the gate either way.
+    the same discipline). Every commit now triggers CI (US-POS-006 removed the
+    `paths-ignore` allow-list), so doc-only commits run CI too; treat their result
+    the same way as any other push.
   - If CI is red, the next action is **fix or revert**, not "queue something else".
 - **Commit message format**:
   - Format: `<type>: <description>` (Git Hook may auto-prepend type prefix)

package/lib/roll-peer.py

@@ -0,0 +1,242 @@
+#!/usr/bin/env python3
+"""roll-peer — v2 terminal view for `roll peer` (US-VIEW-009).
+
+Renders a cross-agent review log as a turn-based ROUND transcript:
+eyebrow + subject + proposer/reviewer overview + ROUND N sections
+(each carrying agent turns with weight chips) + final VERDICT line
++ artifact path / next-step hint.
+
+NO_COLOR=1 falls through to glyph + weight + spacing only.
+"""
+from __future__ import annotations
+
+import argparse
+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
+
+# ════════════════════════════════════════════════════════════════════════════
+# Agent palette — each agent gets a stable color so reviewer/proposer pairs
+# read at a glance across rounds. Unknown agents fall back to fg.
+# ════════════════════════════════════════════════════════════════════════════
+
+_AGENT_COLOR = {
+    "claude":   "blue",
+    "codex":    "pink",
+    "kimi":     "amber",
+    "deepseek": "green",
+    "gemini":   "purple",
+    "pi":       "yellow",
+    "opencode": "muted",
+    "trae":     "fg",
+}
+
+# Weight chip — (glyph, color, label) per turn.weight
+_WEIGHTS = {
+    "concern": ("●", "amber", "concern"),
+    "nit":     ("○", "dim",   "nit"),
+    "ack":     ("✓", "green", "ack"),
+    "block":   ("✗", "red",   "block"),
+}
+
+
+def _agent_c(name: str) -> str:
+    return _AGENT_COLOR.get(name.lower(), "fg")
+
+
+# ════════════════════════════════════════════════════════════════════════════
+# Demo data — illustrative cross-agent review: claude proposes, codex reviews
+# ════════════════════════════════════════════════════════════════════════════
+
+_DEMO_SUBJECT = {
+    "story":     "US-AUTH-014",
+    "title":     "Session refresh fallback when refresh-token API 5xx",
+    "pr":        "#412",
+    "diff_stat": "+184 −37 · 6 files",
+    "trigger":   "complexity=large",
+    "proposer":  "claude",
+    "reviewer":  "codex",
+}
+
+_DEMO_ROUNDS = [
+    {
+        "n": 1,
+        "hint": "first pass — proposer ships, reviewer probes",
+        "turns": [
+            ("claude", "concern",
+             "Refresh path swallows 503 silently — caller sees a stale session "
+             "without any signal that re-auth is needed."),
+            ("codex",  "nit",
+             "Naming: `tryRefresh` reads as best-effort, but the retry budget "
+             "actually escalates. Suggest `refreshWithBackoff`."),
+            ("codex",  "block",
+             "Backoff jitter uses Math.random — flakes integration tests. "
+             "Inject the rng so tests can pin it."),
+        ],
+    },
+    {
+        "n": 2,
+        "hint": "proposer revises, reviewer signs off",
+        "turns": [
+            ("claude", "ack",
+             "Renamed to `refreshWithBackoff`; threaded `rng` through the "
+             "config object. Added a test that pins seed 42."),
+            ("codex",  "ack",
+             "Looks right — retries fire 3× with jitter, surfaces 503 to "
+             "caller after budget exhausted. Approving."),
+        ],
+    },
+]
+
+_DEMO_VERDICT = {
+    "outcome": "approved",
+    "reason":  "2 rounds · 5 turns · all blocks resolved",
+}
+
+_DEMO_ARTIFACT = "~/.roll/.peer-state/logs/20260519_213700_claude_codex.md"
+_DEMO_NEXT = [
+    ("Continue execution",   "claude resumes work on US-AUTH-014"),
+    ("Inspect log",          "open the artifact above to replay the transcript"),
+]
+
+
+# ════════════════════════════════════════════════════════════════════════════
+# Render primitives
+# ════════════════════════════════════════════════════════════════════════════
+
+def _divider(char: str = "─") -> None:
+    print(c("dim", char * min(COLS, 80)))
+
+
+def _eyebrow(trigger: str) -> None:
+    left = ("  " + c("blue", "PEER", bold=True) +
+            c("dim", "  ·  ") +
+            c("dim", "roll peer · cross-agent review"))
+    right = c("purple", trigger, bold=True) + "  "
+    print(row(left, right))
+
+
+def _subject(subj: dict) -> None:
+    story = c("blue", subj["story"], bold=True)
+    title = c("fg",   subj["title"])
+    pr    = c("amber", subj["pr"], bold=True)
+    diff  = c("muted", subj["diff_stat"])
+    line  = "  " + story + c("muted", "  ·  ") + title
+    print(line)
+    print("  " + pr + c("muted", "   ") + diff)
+
+
+def _pair_overview(subj: dict) -> None:
+    p_name = subj["proposer"]
+    r_name = subj["reviewer"]
+    p_c = _agent_c(p_name)
+    r_c = _agent_c(r_name)
+    proposer = c("dim", "proposer ") + c(p_c, p_name, bold=True)
+    reviewer = c("dim", "reviewer ") + c(r_c, r_name, bold=True)
+    sep = c("muted", "  →  ")
+    print("  " + proposer + sep + reviewer)
+
+
+def _round_header(n: int, hint: str) -> None:
+    label = c("pink", f"ROUND {n}", bold=True)
+    print()
+    print("  " + label + c("muted", "  ·  ") + c("dim", hint))
+
+
+def _weight_chip(weight: str) -> str:
+    glyph, color, label = _WEIGHTS.get(weight, ("·", "muted", weight))
+    return c(color, glyph + " " + label, bold=(weight in ("ack", "block")))
+
+
+def _turn(agent: str, weight: str, body: str) -> None:
+    agent_c = _agent_c(agent)
+    name = c(agent_c, agent, bold=True)
+    chip = _weight_chip(weight)
+    # First line: agent  chip
+    print("    " + name + c("muted", "  ") + chip)
+    # Body wrapped with hanging indent so long sentences stay readable.
+    _print_wrapped(body, indent=6, width=min(COLS, 80))
+
+
+def _print_wrapped(s: str, *, indent: int, width: int) -> None:
+    avail = max(20, width - indent)
+    line = ""
+    pad = " " * indent
+    for word in s.split():
+        if line and len(line) + 1 + len(word) > avail:
+            print(pad + c("dim", line))
+            line = word
+        else:
+            line = (line + " " + word) if line else word
+    if line:
+        print(pad + c("dim", line))
+
+
+def _verdict(v: dict) -> None:
+    outcome = v["outcome"]
+    if outcome == "approved":
+        glyph, color, label = "✓", "green", "approved"
+    else:
+        glyph, color, label = "✗", "red", "changes requested"
+    head = c(color, f"{glyph} VERDICT", bold=True) + c("muted", "  ·  ") + c(color, label)
+    print()
+    print("  " + head)
+    print("  " + c("dim", v["reason"]))
+
+
+def _footer(artifact: str, next_steps: list) -> None:
+    print()
+    print("  " + c("dim", "artifact ") + c("muted", artifact))
+    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))
+    _divider("═")
+
+
+# ════════════════════════════════════════════════════════════════════════════
+# Top-level render
+# ════════════════════════════════════════════════════════════════════════════
+
+def render_demo() -> None:
+    _eyebrow(_DEMO_SUBJECT["trigger"])
+    _divider()
+    print()
+    _subject(_DEMO_SUBJECT)
+    print()
+    _pair_overview(_DEMO_SUBJECT)
+    for rd in _DEMO_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)
+
+
+# ════════════════════════════════════════════════════════════════════════════
+# Entry point
+# ════════════════════════════════════════════════════════════════════════════
+
+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()
+
+
+if __name__ == "__main__":
+    main()

package/lib/roll_render.py

@@ -88,6 +88,21 @@ def fmt_dur(s: int) -> str:
         return f"{s // 60}m"
     return f"{s // 3600}h {(s % 3600) // 60}m"
 
+def fmt_model(model) -> str:
+    """Short label for the cycle row's model column.
+
+    `claude-opus-4-7-20251001` → `opus-4-7`
+    None / empty                → `—`
+    Non-claude vendor            → `?`
+    """
+    if not model:
+        return "—"
+    if not model.startswith("claude-"):
+        return "?"
+    s = model[len("claude-"):]
+    s = re.sub(r"-\d{6,8}$", "", s)
+    return s if s else "?"
+
 def fmt_tokens(n: int) -> str:
     """Format a token count with K / M / B unit scaling, 1 decimal place.
     Uppercase suffix disambiguates from duration's lowercase m / h on the
@@ -298,11 +313,17 @@ def cycle_row(cy: Dict[str, Any], backlog: Dict[str, str]) -> None:
     time_c  = "red" if outcome == "fail" else "fg"
     sid_c   = "red" if outcome == "fail" else "blue"
 
+    model_label = fmt_model(cy.get("model"))
+    # Auto-hide model column on narrow screens — keeps the dashboard readable
+    # when terminal is < 100 cols (cost / story IDs are higher-priority).
+    show_model = COLS >= 100
+    model_seg = c("muted", pad(model_label, 11)) + " " if show_model else ""
     inner = (
         "  " + c(glyph_c, glyph, bold=True) + "  " +
         c(time_c, pad(time_str, 5), bold=(outcome == "fail")) + "   " +
         c("muted", pad(dur, 4, "r")) + "  " +
         c("muted", pad(tok, 6, "r")) + "  " +
+        model_seg +
         c("muted", pad(cost, 7, "r")) + "   " +
         c(sid_c, ids_str, bold=True)
     )

package/package.json

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

package/skills/roll-loop/SKILL.md

@@ -201,12 +201,21 @@ Together these mean: only one loop runs at a time per project (LOCK), and within
 
 ### Step 3 — Route and Execute
 
-For each item, **before invoking the executor skill**, mark the story 🔨 In Progress in .roll/backlog.md so brief and peer agents can see it's being worked on:
+For each item, **before invoking the executor skill**, mark the story 🔨 In Progress in the **main repo's** .roll/backlog.md so brief and peer agents can see it being worked on. The cycle worktree is gitignored at .roll/, so editing the worktree's own copy + committing carries no change back to main — write directly via the helper instead:
 
-1. Edit .roll/backlog.md: change the row's Status column from `📋 Todo` to `🔨 In Progress`.
-2. Commit: `git commit -am "chore: mark US-XXX in progress"` (use the actual story id).
+```bash
+bash -c 'source "$(command -v roll)"; _loop_mark_in_progress US-XXX'
+# Updates ${ROLL_MAIN_PROJECT}/.roll/backlog.md in place: flips the row
+# containing US-XXX from "📋 Todo" to "🔨 In Progress". Idempotent.
+```
+
+If the executor fails (TCR aborts, CI red, etc.), revert the marker so the next cycle can re-pick the story:
+
+```bash
+bash -c 'source "$(command -v roll)"; _loop_mark_todo US-XXX'
+```
 
-This commit is what makes the work visible — without it, tcr micro-commits during execution are invisible to `roll-brief`.
+Status flips happen in main directly — no per-cycle commit needed. `roll-brief` reads main's backlog, so the 🔨 marker is visible the moment the helper returns.
 
 选定故事后，调用 `_loop_event` 发出 pick_todo 事件，让 dashboard / monitor / attach 都能把"这个 cycle 选了哪个 story"正确归类：
 
@@ -255,8 +264,7 @@ After each item completes:
    it derives `owner/repo` from the git remote and uses `gh -R <slug>`, which
    is required to work through `~/.ssh/config` host rewrites that break gh's
    auto-detection.
-   - CI passes → call `_loop_clear_heal_state <story_id>` (idempotent) and
-     continue normally
+   - CI passes → clear any `heal_count:` entry in `~/.shared/roll/loop/state-<slug>.yaml` (idempotent — drop the line if present, no-op otherwise) and continue normally
    - CI fails / times out / `gh` call fails → enter **CI self-heal** (US-AUTO-041)
    - `gh` binary not installed (`command -v gh` fails) → skip gracefully
      (return 0). Any other `gh` error is **not** "gh unavailable" — it is a
@@ -264,9 +272,9 @@ After each item completes:
 
    **CI self-heal (US-AUTO-041)** — bounded auto-fix before ALERT.
 
-   Call `_loop_self_heal_ci <story_id>` to check if another attempt is permitted.
+   Read `heal_count:` from `~/.shared/roll/loop/state-<slug>.yaml`; treat a missing line as `0`. If the count is below `ROLL_LOOP_HEAL_MAX` (default 2) and `ROLL_LOOP_NO_HEAL` is not set, increment it and take Path A. Otherwise take Path B.
 
-   **Path A — attempt allowed (exit 0, counter incremented in `state.yaml`):**
+   **Path A — attempt allowed (counter incremented in `state.yaml`):**
 
    1. Capture failure summary:
       ```