@seanyao/roll 2026.517.2 → 2026.517.3

package/CHANGELOG.md

@@ -1,6 +1,12 @@
 # Changelog
 
+## v2026.517.3
+- **New**: dream 现在察觉功能目录过期 — 落后时不再悄悄无人知晓 `[dream]`
+- **New**: `roll loop events` — 查看 loop 每轮的详细事件流，任务选择、评审结果、CI 状态、合并全都有迹可查 `[loop]`
+- **Improved**: loop 实时输出不再一眼看不出重点 — TCR 纪律、评审决议、CI gate 突出显示，工具日志不再喧宾夺主 `[loop]`
+
 ## v2026.517.2
+- **Fixed**: `roll loop runs` 现在能看到刚跑完的循环记录（不再无历史） `[loop]`
 - **Fixed**: `roll dream`、`roll brief`、`roll loop` 的定时任务不再被 Claude 升级后的弹窗拦住，悄悄失效
 
 ## v2026.517.1

package/bin/roll

@@ -4,7 +4,7 @@ set -euo pipefail
 # Roll — AI Agent Convention Manager
 # Single source of truth for how all AI coding agents behave.
 
-VERSION="2026.517.2"
+VERSION="2026.517.3"
 ROLL_HOME="${ROLL_HOME:-${HOME}/.roll}"
 ROLL_CONFIG="${ROLL_HOME}/config.yaml"
 ROLL_GLOBAL="${ROLL_HOME}/conventions/global"
@@ -2073,7 +2073,7 @@ _LAUNCHD_DIR="${HOME}/Library/LaunchAgents"
 # Returns a filesystem-safe slug combining the project basename and a 6-char
 # hash of the full path, ensuring uniqueness across sibling dirs with same name.
 _project_slug() {
-  local path="$1"
+  local path="${1:-$(pwd -P 2>/dev/null || pwd)}"
   # FIX-034: when inside a git worktree, git-common-dir returns the main tree's
   # absolute .git path; resolve to the main tree so worktree and main-tree runs
   # produce the same slug.
@@ -2115,6 +2115,55 @@ _loop_derive_minute() {
   echo $(( (hash_dec + offset) % 55 + 1 ))
 }
 
+# US-LOOP-001: structured event emission for cycle observability.
+# Writes a tab-separated line to stdout (for tmux/attach display) and appends
+# a JSON line to the per-project NDJSON event file under _SHARED_ROOT/loop/.
+# Args: <stage> <label> <detail> <outcome>
+_loop_event() {
+  local stage="$1" label="$2" detail="$3" outcome="$4"
+  local ts slug evfile json
+  ts=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+  slug=$(_project_slug 2>/dev/null || basename "$PWD")
+  evfile="${_SHARED_ROOT:-$HOME/.shared/roll}/loop/events-${slug}.ndjson"
+  mkdir -p "$(dirname "$evfile")"
+
+  # stdout: tab-separated for tmux display
+  printf '%s\t%s\t%s\t%s\t%s\n' "$ts" "$stage" "$label" "$detail" "$outcome"
+
+  # JSON line appended to NDJSON file; serialized with flock (Linux) or
+  # lockf (macOS/BSD) — fall back to unguarded append when neither is available.
+  json=$(printf '{"ts":"%s","stage":"%s","label":"%s","detail":"%s","outcome":"%s"}\n' \
+    "$ts" "$stage" "$label" "$detail" "$outcome")
+  if command -v flock >/dev/null 2>&1; then
+    (
+      flock -x 9
+      printf '%s\n' "$json" >> "$evfile"
+    ) 9>>"${evfile}.lock"
+  elif command -v lockf >/dev/null 2>&1; then
+    lockf -s "${evfile}.lock" sh -c "printf '%s\n' $(printf '%q' "$json") >> $(printf '%q' "$evfile")"
+  else
+    printf '%s\n' "$json" >> "$evfile"
+  fi
+
+  # File rotation: if >10MB, rotate keeping last 5
+  _loop_event_rotate "$evfile"
+}
+
+_loop_event_rotate() {
+  local f="$1"
+  local size
+  size=$(stat -f%z "$f" 2>/dev/null || stat -c%s "$f" 2>/dev/null || echo 0)
+  if [ "$size" -gt 10485760 ]; then
+    # rotate: .4→remove, .3→.4, .2→.3, .1→.2, current→.1
+    rm -f "${f}.4"
+    for i in 3 2 1; do
+      [ -f "${f}.$i" ] && mv "${f}.$i" "${f}.$((i+1))"
+    done
+    mv "$f" "${f}.1"
+    touch "$f"
+  fi
+}
+
 _launchd_label() {
   local service="$1" project_path="$2"
   printf 'com.roll.%s.%s' "$service" "$(_project_slug "$project_path")"
@@ -2237,6 +2286,7 @@ set +e
 # On any failure (no remote, no main, etc.) fall back to running in the
 # project's main tree (degraded — no isolation, like pre-037 behavior).
 CYCLE_ID="\$(date -u +%Y%m%d-%H%M%S)-\$\$"
+CYCLE_START=\$(date -u +%s)
 WT="\$(_worktree_path "${slug}" "cycle-\${CYCLE_ID}")"
 BRANCH="loop/cycle-\${CYCLE_ID}"
 _USE_WORKTREE=0
@@ -2278,6 +2328,7 @@ if _worktree_fetch_origin main \\
   _USE_WORKTREE=1
   _worktree_submodule_init "\$WT" 2>/dev/null || true
   echo "[loop] cycle \${CYCLE_ID}: worktree \$WT on \$BRANCH"
+  _loop_event cycle_start "\${CYCLE_ID}" "" "" || true
 else
   # P3 fix: skip the cycle entirely when worktree isolation fails.
   # --dangerously-skip-permissions is only safe paired with worktree isolation;
@@ -2302,6 +2353,25 @@ for _attempt in 1 2 3; do
   fi
 done
 
+# FIX-044: capture cycle data from worktree before cleanup removes it
+_cycle_tcr=0
+_cycle_status="idle"
+_cycle_built="[]"
+if [ "\$_USE_WORKTREE" = "1" ]; then
+  if [ "\$_exit" -ne 0 ]; then
+    _cycle_status="failed"
+  else
+    _cycle_commits_pre=\$(cd "\$WT" && git rev-list --count origin/main..HEAD 2>/dev/null || echo 0)
+    if [ "\$_cycle_commits_pre" -gt 0 ]; then
+      _cycle_status="built"
+      _cycle_tcr=\$(cd "\$WT" && git log --oneline origin/main..HEAD -- 2>/dev/null | grep -c ' tcr:' || echo 0)
+      if command -v jq >/dev/null 2>&1; then
+        _cycle_built=\$(cd "\$WT" && git diff origin/main -- BACKLOG.md 2>/dev/null | grep '✅ Done' | grep -oE '\[[A-Z]+-[0-9]+\]' | sed 's/^.//;s/.\$//' | jq -R -s 'split("\n") | map(select(length>0))' 2>/dev/null || echo "[]")
+      fi
+    fi
+  fi
+fi
+
 # US-AUTO-038: diff snapshot vs current and delete any claude/* branches this
 # session pushed to origin. Runs regardless of claude's exit code (cleanup is
 # orthogonal to success/failure) and is silent on non-GitHub / unreachable.
@@ -2320,6 +2390,7 @@ if [ "\$_USE_WORKTREE" = "1" ]; then
     _cycle_commits=\$(cd "\$WT" && git rev-list --count origin/main..HEAD 2>/dev/null || echo 0)
     if [ "\$_cycle_commits" -eq 0 ]; then
       _worktree_cleanup "\$WT" "\$BRANCH"
+      _loop_event idle "\${CYCLE_ID}" "" "" || true
       echo "[loop] cycle \${CYCLE_ID}: idle (no new commits); worktree cleaned"
     else
       if ( cd "\$WT" && _loop_is_doc_only_change ); then
@@ -2330,6 +2401,7 @@ if [ "\$_USE_WORKTREE" = "1" ]; then
       _publish_status=\$?
       if [ "\$_publish_status" -eq 0 ]; then
         _worktree_cleanup "\$WT" "\$BRANCH"
+        _loop_event cycle_end "\${CYCLE_ID}" "" "done" || true
         echo "[loop] cycle \${CYCLE_ID}: published; worktree cleaned"
       elif [ "\$_publish_status" -eq 2 ]; then
         if ( cd "${project_path}" && _worktree_merge_back "\$BRANCH" ); then
@@ -2374,6 +2446,32 @@ fi
 
 # US-AUTO-040: fallback GC — delete remote loop/cycle-* branches already merged to main.
 _loop_cleanup_stale_cycle_branches "${project_path}" || true
+
+# FIX-044 / Step 5: Write loop cycle run summary to runs.jsonl
+# Deterministic — runs in shell regardless of whether agent executes SKILL.md Step 5.
+# Idempotent: skips if a record for this run_id already exists (agent may also write).
+_runs_dst="${HOME}/.shared/roll/loop/runs.jsonl"
+mkdir -p "\$(dirname "\$_runs_dst")"
+_cycle_end=\$(date -u +%s)
+_cycle_dur=\$(( _cycle_end - CYCLE_START ))
+_ts=\$(date -u +%Y-%m-%dT%H:%M:%SZ)
+_run_id="loop-\${CYCLE_ID%-*}"
+if command -v jq >/dev/null 2>&1 && ! grep -qF "\"run_id\":\"\$_run_id\"" "\$_runs_dst" 2>/dev/null; then
+  jq -nc \\
+    --arg ts "\$_ts" \\
+    --arg project "${slug}" \\
+    --arg run_id "\$_run_id" \\
+    --arg status "\$_cycle_status" \\
+    --argjson built "\$_cycle_built" \\
+    --argjson skipped '[]' \\
+    --argjson alerts '[]' \\
+    --argjson tcr_count "\$_cycle_tcr" \\
+    --argjson duration_sec "\$_cycle_dur" \\
+    '{ts:\$ts, project:\$project, run_id:\$run_id, status:\$status,
+      built:\$built, skipped:\$skipped, alerts:\$alerts,
+      tcr_count:\$tcr_count, duration_sec:\$duration_sec}' \\
+    >> "\$_runs_dst" 2>/dev/null || true
+fi
 INNER
   chmod +x "$inner_path"
 
@@ -2626,6 +2724,7 @@ cmd_loop() {
     status)  _loop_status ;;
     monitor) _loop_monitor "${1:-3}" ;;
     runs)    _loop_runs "$@" ;;
+    events)  _loop_event_log "${1:-20}" ;;
     attach)  _loop_attach ;;
     mute)    _loop_mute ;;
     unmute)  _loop_unmute ;;
@@ -2633,7 +2732,7 @@ cmd_loop() {
     resume)  _loop_resume ;;
     reset)   _loop_reset ;;
     notify)  _notify "${1:-roll}" "${2:-}" ;;
-    *) err "Usage: roll loop <on|off|now|test|status|monitor|runs|attach|mute|unmute|pause|resume|reset|notify>"; exit 1 ;;
+    *) err "Usage: roll loop <on|off|now|test|status|monitor|runs|events|attach|mute|unmute|pause|resume|reset|notify>"; exit 1 ;;
   esac
 }
 
@@ -3317,8 +3416,12 @@ _loop_diagnose_open_prs() {
 # When gh unavailable: returns 0 (graceful skip).
 _loop_enforce_ci() {
   local story_id="$1"
-
-  _ci_wait 300 && return 0
+  local _ci_result
+  if _ci_wait 300; then
+    _loop_event ci "$story_id" "" "ok" 2>/dev/null || true
+    return 0
+  fi
+  _loop_event ci "$story_id" "" "red" 2>/dev/null || true
 
   mkdir -p "$(dirname "$_LOOP_ALERT")"
   cat > "$_LOOP_ALERT" << EOF
@@ -4145,6 +4248,7 @@ _loop_publish_pr() {
   fi
   gh -R "$slug" pr merge "$branch" --auto --squash --delete-branch >/dev/null 2>&1 \
     || _worktree_alert "_loop_publish_pr: gh pr merge --auto failed for ${branch} (PR ${pr_url} left open)"
+  _loop_event pr "$branch" "$pr_url" "ok" 2>/dev/null || true
   echo "$pr_url"
   return 0
 }
@@ -4336,11 +4440,57 @@ _loop_monitor() {
       echo -e "    ${YELLOW}(no log yet)${NC}"
     fi
 
+    # Event stream (US-LOOP-001): last 10 events from NDJSON event file
+    local slug; slug=$(_project_slug "$project_path")
+    local evfile="${_SHARED_ROOT}/loop/events-${slug}.ndjson"
+    echo ""
+    echo -e "  ─────────────────────────────────────────────────────"
+    echo -e "  ${BOLD}Cycle Events  事件流${NC}  (last 10)"
+    if [[ -f "$evfile" && -s "$evfile" ]]; then
+      tail -n 10 "$evfile" | python3 -c "
+import sys, json
+for line in sys.stdin:
+    try:
+        e = json.loads(line)
+        stage = e.get('stage','')
+        label = e.get('label','')
+        detail = e.get('detail','')
+        outcome = e.get('outcome','')
+        ts = e.get('ts','')
+        print(f'    {ts}  {stage:<14}  {label:<22}  {detail}  {outcome}')
+    except: pass
+" 2>/dev/null || tail -n 10 "$evfile" | sed 's/^/    /'
+    else
+      echo -e "    ${YELLOW}(no events yet — events are emitted after the first cycle)${NC}"
+    fi
+
     echo ""
     sleep "$interval"
   done
 }
 
+# _loop_event_log: show last N events from the project's NDJSON event file.
+# Used by: roll loop events [N]
+_loop_event_log() {
+  local n="${1:-20}"
+  local project_path; project_path=$(pwd -P)
+  local slug; slug=$(_project_slug "$project_path")
+  local evfile="${_SHARED_ROOT}/loop/events-${slug}.ndjson"
+  if [ ! -f "$evfile" ]; then
+    echo "[monitor] No event log found for project: $slug"
+    return 1
+  fi
+  # Show last N events, formatted
+  tail -n "$n" "$evfile" | python3 -c "
+import sys, json
+for line in sys.stdin:
+    try:
+        e = json.loads(line)
+        print(f\"  {e.get('ts','')}  {e.get('stage',''):12s}  {e.get('label',''):20s}  {e.get('detail','')}  {e.get('outcome','')}\")
+    except: pass
+"
+}
+
 # ═══════════════════════════════════════════════════════════════════════════════
 # BRIEF — owner-facing project digest
 # ═══════════════════════════════════════════════════════════════════════════════

package/lib/loop-fmt.py

@@ -1,180 +1,254 @@
 #!/usr/bin/env python3
 """
-loop-fmt.py — stream-json → human-readable formatter for roll loop tmux output.
+loop-fmt.py — 3-tier stream-json → tmux formatter for roll loop.
 
-Reads stream-json lines from stdin, emits colored, human-readable events.
-Skips noise (system/init, hook_started, rate_limit_event) and abbreviates
-tool results so the window stays readable.
-
-Color codes: no external deps, plain ANSI.
+Tier 3 (suppressed): init, thinking, Read/Glob/Grep, non-error results, plain Bash
+Tier 2 (muted):      Edit/Write → ✏ path
+Tier 1 (signal):     tcr commit, story skill, peer verdict, ci gate, pr merge, errors
 """
-
 import sys
 import json
 import re
-import textwrap
-
-# ANSI colors
-CYAN    = "\033[36m"
-GREEN   = "\033[32m"
-YELLOW  = "\033[33m"
-RED     = "\033[31m"
-GRAY    = "\033[90m"
-BOLD    = "\033[1m"
-RESET   = "\033[0m"
-DIM     = "\033[2m"
-
-SKIP_SUBTYPES = {"hook_started", "hook_response", "hook_stop_hook_execution",
-                 "hook_stop_hook_active_hooks_ran"}
-
-def trunc(s, n=120):
+from datetime import datetime, timezone
+
+DARK_GRAY = "\033[90m"
+CYAN      = "\033[36m"
+WHITE     = "\033[97m"
+GREEN     = "\033[32m"
+RED       = "\033[31m"
+RESET     = "\033[0m"
+
+SUPPRESS_TOOLS = {"Read", "Glob", "Grep", "ReadMcpResourceTool", "ListMcpResourcesTool",
+                  "WebFetch", "WebSearch", "TaskCreate", "TaskGet", "TaskList",
+                  "TaskUpdate", "TaskOutput", "TaskStop"}
+
+def now_hms():
+    return datetime.now(timezone.utc).strftime("%H:%M:%S")
+
+def trunc(s, n=60):
     s = str(s).replace("\n", " ").strip()
     return s[:n] + "…" if len(s) > n else s
 
-def fmt_tool_input(name, inp):
-    if not isinstance(inp, dict):
-        return trunc(str(inp), 80)
-    if name == "Bash":
-        cmd = inp.get("command", "")
-        # show first non-empty line
-        lines = [l.strip() for l in cmd.splitlines() if l.strip()]
-        return trunc(lines[0] if lines else cmd, 100)
-    if name in ("Read", "Write", "Edit"):
-        path = inp.get("file_path", inp.get("path", ""))
-        extra = ""
-        if name == "Edit":
-            old = inp.get("old_string", "")
-            extra = f"  ({trunc(old, 40)})"
-        return f"{path}{extra}"
-    if name in ("Glob", "Grep"):
-        return trunc(inp.get("pattern", inp.get("query", str(inp))), 80)
-    if name == "Skill":
-        return inp.get("skill", "") + (" " + inp.get("args", "") if inp.get("args") else "")
-    if name == "Agent":
-        return trunc(inp.get("description", str(inp)), 80)
-    return trunc(json.dumps(inp, ensure_ascii=False), 80)
-
-def fmt_tool_result(content):
-    if isinstance(content, list):
-        parts = []
-        for c in content:
-            if isinstance(c, dict):
-                t = c.get("type", "")
-                if t == "text":
-                    parts.append(c.get("text", ""))
-                elif t == "image":
-                    parts.append("[image]")
-            else:
-                parts.append(str(c))
-        text = " ".join(parts)
-    else:
-        text = str(content) if content is not None else ""
-    # strip ansi for length check
-    clean = re.sub(r'\033\[[0-9;]*m', '', text)
-    lines = [l for l in clean.splitlines() if l.strip()]
-    if not lines:
-        return "(empty)"
-    # show first 3 lines, trim long lines
-    out = []
-    for l in lines[:3]:
-        out.append("  " + trunc(l, 100))
-    if len(lines) > 3:
-        out.append(f"  {DIM}… ({len(lines)-3} more lines){RESET}")
-    return "\n".join(out)
-
-def process_line(line):
-    line = line.rstrip()
-    if not line:
-        return
-    try:
-        ev = json.loads(line)
-    except json.JSONDecodeError:
-        # plain text passthrough
-        print(line)
-        return
-
-    etype = ev.get("type", "")
-
-    # ── system events ──────────────────────────────────────────────
-    if etype == "system":
-        subtype = ev.get("subtype", "")
-        if subtype in SKIP_SUBTYPES:
+def step(category, label, detail="", ok=True):
+    cat_color = CYAN
+    label_color = GREEN if ok and category in ("ci", "pr") else (RED if not ok else WHITE)
+    arrow = f"{DARK_GRAY}→{RESET}"
+    cat   = f"  {cat_color}{category:<6}{RESET}"
+    lbl   = f"  {label_color}{label:<14}{RESET}"
+    det   = f"  {DARK_GRAY}{detail}{RESET}" if detail else ""
+    return f"{arrow}{cat}{lbl}{det}"
+
+def stamp(text, muted=False):
+    ts = f"{DARK_GRAY}{now_hms()}{RESET}"
+    body = f"{DARK_GRAY}{text}{RESET}" if muted else text
+    return f"{ts}  {body}"
+
+class LoopFmt:
+    def __init__(self):
+        self.last_bash_cmd = ""
+        self.tcr_count = 0
+        self.last_test_count = None
+        self.cycle_num = None
+        self.pending_commit = False
+        self.pending_pr = False
+        self.pending_ci = False
+
+    def _extract_cycle_num(self, text):
+        m = re.search(r'cycle[#\s]+(\d+)', text, re.IGNORECASE)
+        return m.group(1) if m else "?"
+
+    def process(self, line):
+        line = line.rstrip()
+        if not line:
             return
-        if subtype == "init":
-            model = ev.get("model", "")
-            tools = ev.get("tools", [])
-            tool_list = ", ".join(tools[:6])
-            if len(tools) > 6:
-                tool_list += f" +{len(tools)-6}"
-            print(f"{DIM}[init] model={model}  tools={tool_list}{RESET}")
+
+        # Plain text passthrough
+        try:
+            ev = json.loads(line)
+        except json.JSONDecodeError:
+            self._handle_plain(line)
             return
-        # unknown system — show raw briefly
-        print(f"{DIM}[sys/{subtype}]{RESET}")
-        return
 
-    # ── rate limit ────────────────────────────────────────────────
-    if etype == "rate_limit_event":
-        return
+        etype = ev.get("type", "")
+        if etype == "system":
+            return  # Tier 3: suppress all system events
+        if etype == "assistant":
+            self._handle_assistant(ev)
+        elif etype == "user":
+            self._handle_user(ev)
+        elif etype == "result":
+            self._handle_result(ev)
+        # All other types: suppress
+
+    def _handle_plain(self, line):
+        # [loop] cycle N: ... → Tier 1 stamp
+        m = re.search(r'\[loop\]\s+cycle\s+(\d+)[:\s]', line)
+        if m:
+            self.cycle_num = m.group(1)
+            self.tcr_count = 0
+            print(stamp(f"cycle #{self.cycle_num} — picking story"))
+            return
+        # Other plain text: suppress
 
-    # ── assistant ────────────────────────────────────────────────
-    if etype == "assistant":
+    def _handle_assistant(self, ev):
         msg = ev.get("message", {})
         for blk in msg.get("content", []):
             btype = blk.get("type", "")
-            if btype == "tool_use":
-                name = blk.get("name", "?")
-                inp  = blk.get("input", {})
-                summary = fmt_tool_input(name, inp)
-                print(f"{CYAN}→ {BOLD}{name}{RESET}{CYAN}: {summary}{RESET}")
+            if btype == "thinking":
+                return  # Tier 3
             elif btype == "text":
-                text = blk.get("text", "").strip()
-                if text:
-                    # wrap long text
-                    for l in textwrap.wrap(text, 120):
-                        print(f"{GREEN}{l}{RESET}")
-            elif btype == "thinking":
-                thought = blk.get("thinking", "").strip()
-                if thought:
-                    first = trunc(thought, 80)
-                    print(f"{DIM}[thinking] {first}{RESET}")
-        return
-
-    # ── user (tool results) ───────────────────────────────────────
-    if etype == "user":
+                self._handle_text(blk.get("text", ""))
+            elif btype == "tool_use":
+                self._handle_tool_use(blk)
+
+    def _handle_text(self, text):
+        text = text.strip()
+        if not text:
+            return
+        # Peer verdict detection
+        for verdict in ("AGREE", "REFINE", "OBJECT", "ESCALATE"):
+            if verdict in text:
+                m = re.search(r'round\s+(\d+)[/\\](\d+)', text, re.IGNORECASE)
+                round_str = f"round {m.group(1)}/{m.group(2)}" if m else "round ?"
+                # agent names — look for common patterns
+                agents = "claude → peer"
+                m2 = re.search(r'(\w+)\s*→\s*(\w+)', text)
+                if m2:
+                    agents = f"{m2.group(1)} → {m2.group(2)}"
+                print(step("peer", agents, f"{round_str} · {verdict}"))
+                return
+        # All other text: Tier 3, suppress
+
+    def _handle_tool_use(self, blk):
+        name = blk.get("name", "")
+        inp  = blk.get("input", {})
+
+        if name in SUPPRESS_TOOLS:
+            return  # Tier 3
+
+        if name in ("Edit", "Write"):
+            path = inp.get("file_path") or inp.get("path", "")
+            print(f"  {DARK_GRAY}✏ {path}{RESET}")
+            return  # Tier 2
+
+        if name == "Bash":
+            cmd = inp.get("command", "")
+            first_line = next((l.strip() for l in cmd.splitlines() if l.strip()), cmd)
+            self.last_bash_cmd = first_line
+            if re.search(r'git commit.*tcr:', cmd):
+                self.pending_commit = True
+            elif re.search(r'gh pr (create|merge)', cmd):
+                self.pending_pr = True
+            elif re.search(r'(roll ci|npm run ci|ci:local)', cmd):
+                self.pending_ci = True
+            return  # Wait for result
+
+        if name == "Skill":
+            skill = inp.get("skill", "")
+            args  = inp.get("args", "").strip()
+            if skill in ("roll-build", "roll-fix"):
+                us_id = args.split()[0] if args else "?"
+                print()
+                print(stamp(f"cycle #{self.cycle_num or '?'} — picking story"))
+                print(step("story", us_id, trunc(args, 60)))
+            return
+
+        # All other tools (Agent, ToolSearch, etc.): suppress
+
+    def _handle_user(self, ev):
         msg = ev.get("message", {})
         for blk in msg.get("content", []):
-            if blk.get("type") == "tool_result":
-                is_err = blk.get("is_error", False)
-                content = blk.get("content", "")
-                result_text = fmt_tool_result(content)
-                prefix = f"{RED}  ✗{RESET}" if is_err else f"{GRAY}  ↩{RESET}"
-                print(f"{prefix} {result_text}")
-        return
-
-    # ── result (final) ───────────────────────────────────────────
-    if etype == "result":
+            if blk.get("type") != "tool_result":
+                continue
+            is_err  = blk.get("is_error", False)
+            content = blk.get("content", "")
+            text    = self._extract_text(content)
+
+            # Scan for test count (bats ok N pattern)
+            m = re.search(r'\bok\s+(\d+)', text)
+            if m:
+                self.last_test_count = int(m.group(1))
+
+            if is_err:
+                tool_name = "tool"
+                lines = [l for l in text.splitlines() if l.strip()][:3]
+                detail = " | ".join(lines)
+                print(step("error", tool_name, trunc(detail, 80), ok=False))
+                self.pending_commit = self.pending_pr = self.pending_ci = False
+                return
+
+            if self.pending_commit:
+                self.pending_commit = False
+                # Extract hash and message from git commit output: [branch hash] msg
+                m = re.search(r'\[[\w/\-]+ ([0-9a-f]{7,})\]\s*tcr:\s*(.+)', text)
+                if m:
+                    commit_hash = m.group(1)[:7]
+                    commit_msg  = m.group(2).strip()
+                    self.tcr_count += 1
+                    test_part = f" · {self.last_test_count} tests" if self.last_test_count else ""
+                    print(step("tcr", commit_hash, f"{commit_msg}{test_part}"))
+                return
+
+            if self.pending_pr:
+                self.pending_pr = False
+                m = re.search(r'#(\d+)', text)
+                if m:
+                    pr_num = f"#{m.group(1)}"
+                    branch = re.search(r'loop/[\w\-]+', self.last_bash_cmd)
+                    branch_str = branch.group(0) if branch else ""
+                    detail = f"auto-merged · {branch_str}" if branch_str else "auto-merged"
+                    print(step("pr", pr_num, detail, ok=True))
+                return
+
+            if self.pending_ci:
+                self.pending_ci = False
+                has_green = re.search(r'(green|pass|success|all tests)', text, re.IGNORECASE)
+                has_red   = re.search(r'(red|fail|error)', text, re.IGNORECASE)
+                m_dur  = re.search(r'(\d+(?:\.\d+)?)\s*s\b', text)
+                m_test = re.search(r'(\d+)\s+tests?', text)
+                dur_str  = f"{m_dur.group(1)}s" if m_dur else ""
+                test_str = f"{m_test.group(1)} tests" if m_test else (f"{self.last_test_count} tests" if self.last_test_count else "")
+                detail   = " · ".join(filter(None, [dur_str, test_str]))
+                if has_green and not has_red:
+                    print(step("ci", "green", detail, ok=True))
+                else:
+                    print(step("ci", "red", detail, ok=False))
+                return
+
+            # Non-matching result: suppress (Tier 3)
+
+    def _extract_text(self, content):
+        if isinstance(content, str):
+            return content
+        if isinstance(content, list):
+            parts = []
+            for c in content:
+                if isinstance(c, dict) and c.get("type") == "text":
+                    parts.append(c.get("text", ""))
+            return "\n".join(parts)
+        return str(content) if content else ""
+
+    def _handle_result(self, ev):
         dur_ms   = ev.get("duration_ms", 0)
         cost_usd = ev.get("total_cost_usd", 0)
-        turns    = ev.get("num_turns", "?")
         dur_s    = dur_ms / 1000
-        cost_str = f"${cost_usd:.4f}" if cost_usd else ""
+        cost_str = f"${cost_usd:.2f}" if cost_usd else ""
+        tcr_str  = f"{self.tcr_count} tcr" if self.tcr_count else ""
+        parts    = [p for p in [tcr_str, f"{dur_s:.0f}s", cost_str] if p]
+        detail   = " · ".join(parts)
         subtype  = ev.get("subtype", "")
         if subtype == "error_max_turns":
-            print(f"{RED}✗ max turns reached  {dur_s:.1f}s{RESET}")
+            print(step("error", "max-turns", f"{dur_s:.0f}s", ok=False))
         else:
-            cost_part = f"  {YELLOW}{cost_str}{RESET}" if cost_str else ""
-            print(f"\n{GREEN}{BOLD}✓ done{RESET}  {dur_s:.1f}s  {GRAY}{turns} turns{RESET}{cost_part}")
-        return
-
-    # ── fallback ────────────────────────────────────────────────
-    print(f"{DIM}{trunc(line, 160)}{RESET}")
+            cycle_str = f"cycle #{self.cycle_num}" if self.cycle_num else "cycle done"
+            print(stamp(f"{cycle_str} — done · {detail}" if detail else f"{cycle_str} — done", muted=True))
 
 
 def main():
+    fmt = LoopFmt()
     for line in sys.stdin:
-        process_line(line)
+        fmt.process(line)
         sys.stdout.flush()
 
-
 if __name__ == "__main__":
     main()

package/package.json

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

package/skills/roll-.dream/SKILL.md

@@ -127,6 +127,18 @@ find docs/ -maxdepth 1 -name '*.md' 2>/dev/null
 
 Flag any `.md` file directly in `docs/` root (allowed subdirs: `guide/`, `domain/`, `features/`, `practices/`, `briefs/`, `dream/`).
 
+**Check D — features.md Feature Coverage (US-DOC-009):**
+
+Dependency gate: skip when `docs/features.md` does not exist.
+
+Parse BACKLOG.md for all `### Feature: <name>` groups that contain ≥1 ✅ Done story. Parse `docs/features.md` for Feature names. If any Feature group with Done stories is absent from `docs/features.md`, the catalog is stale — flag as REFACTOR:
+
+```markdown
+| REFACTOR-XXX | features.md 功能目录落后于 BACKLOG，N 个已完成功能区未收录，用户无法通过产品目录发现这些功能 — flagged by dream YYYY-MM-DD | 📋 Todo |
+```
+
+The catalog is auto-updated by `scripts/release.sh` at release time (Section 8 of roll-.changelog). Between releases, this check surfaces the coverage gap so it isn't silently skipped.
+
 **REFACTOR entry format for doc findings:**
 
 ```markdown
@@ -137,7 +149,8 @@ Flag any `.md` file directly in `docs/` root (allowed subdirs: `guide/`, `domain
 
 ```markdown
 ## 文档覆盖度
-{发现内容 或 "文档结构符合规范，无缺口。"}
+- features.md 功能区覆盖：{N}/{M} 个已完成功能区已收录（缺失：{列表 或 "无"}）
+{其他发现内容 或 "文档结构符合规范，无缺口。"}
 ```
 
 ### Scan 6 — 文档新鲜度 (Doc Freshness)

package/skills/roll-build/SKILL.md

@@ -302,6 +302,13 @@ When any signal appears, **do not stop — flag it**:
 
 Then continue implementing the current Story normally.
 
+**Event emission** — after all TCR micro-steps for a Story complete, emit a `build` event so the cycle event stream reflects the work done:
+
+```bash
+# _tcr_count = number of "tcr:" prefix commits made during this Story
+_loop_event build "$US_ID" "${_tcr_count} commits" "" 2>/dev/null || true
+```
+
 ### Phase 5.5: E2E Deposit
 
 After TCR micro-steps pass, deposit an E2E test for this Story's core user flow.

package/skills/roll-loop/SKILL.md

@@ -195,6 +195,13 @@ For each item, **before invoking the executor skill**, mark the story 🔨 In Pr
 
 This commit is what makes the work visible — without it, tcr micro-commits during execution are invisible to `roll-brief`.
 
+选定故事后，调用 `_loop_event` 发出 story 事件，让 monitor 和 attach 能渲染当前进度：
+
+```bash
+# 选定故事后立即 emit（在调用 executor skill 之前）
+_loop_event story "$US_ID" "$story_title" ""
+```
+
 Then invoke the executor:
 
 ```
@@ -276,6 +283,11 @@ After each item completes:
 
 ### Step 5 — Write Run Summary
 
+> **FIX-044**: The inner runner script (`_write_loop_runner_script` in `bin/roll`)
+> now appends this record deterministically at cycle end. The shell write is the
+> authoritative record; the agent should still emit a run summary in the cycle's
+> final report for `cron.log` visibility.
+
 After all items in this cycle:
 
 ```yaml

package/skills/roll-peer/SKILL.md

@@ -65,6 +65,14 @@ Allowed states only. No invented words.
 - **OBJECT**: The proposal is wrong. Provide an alternative. Proceed to next round.
 - **ESCALATE**: Round 3 reached without AGREE, or a round fails due to API/token error. Hand off to the human user.
 
+After each round decision, emit a `peer` event to the cycle event stream:
+
+```bash
+# $round = current round number, $total = max rounds, $verdict = AGREE/REFINE/OBJECT/ESCALATE
+# $agents = e.g. "claude→deepseek"
+_loop_event peer "${round}/${total}" "$verdict" "$agents" 2>/dev/null || true
+```
+
 If information is insufficient:
 ```
 REFINE: Need to confirm X/Y/Z with the user first.