@seanyao/roll 2026.510.10 → 2026.511.2

package/CHANGELOG.md

@@ -1,7 +1,20 @@
 # Changelog
 
+## v2026.511.2
+- **Added**: roll loop monitor 三服务状态 — 监控台新增 loop/dream/brief 三个 launchd 服务的运行状态、调度时间和实时 log tail，一屏掌握全局执行情况
+- **Fixed**: dashboard 多处展示问题 — 修复 pending_count 算术错误、brief 内联显示 release readiness、移除底部冗余命令列表
+- **Fixed**: loop 异常退出后 state 未重置 — 防止 queue 卡住导致后续任务无法执行
+- **Fixed**: CI 稳定性 — 修复 _notify_update 裸返回和时间断言，消除环境差异引起的随机失败
+- **Improved**: roll-brief 输出格式 — 序号命名、省略空 section、元信息格式精简，减少无效噪音
+
+## v2026.511.1
+- **Changed**: roll loop 调度器切换到 launchd（macOS）— `roll setup` 自动安装 loop/dream/brief 三个 launchd 服务（默认关闭），`roll loop on/off/status` 统一走 launchctl 管理，幂等安装，Linux 保留 crontab 回退路径
+- **Added**: roll-loop TCR 硬校验 — 故事完成后自动统计 `tcr:` 微提交数量，为 0 时将故事状态回退为 📋 Todo 并写 ALERT，防止 agent 跳过 TCR 节奏
+- **Fixed**: CI 测试环境兼容 — 移除依赖本地 state.yaml 的 hello_world.bats，修复 GitHub Actions 持续失败
+
 ## v2026.510.10
 - **Fixed**: release.sh changelog 同步时序修复 — 修正条件逻辑和执行顺序，确保每次发版时 changelog 正确更新
+- **Added**: roll-loop 22:00 自动执行验证 — 新增 hello_world.bats 作为 loop 定时执行的端到端存档，可回放确认调度器正常工作
 
 ## v2026.510.9
 - **Fixed**: CHANGELOG 改版本号分组 — 每个 release 独立 section，GitHub Release 增量内容提取正确

package/README.md

@@ -9,6 +9,8 @@
 
 > Roll out features with AI agents — _Move fast, no sprints._
 
+**[中文版 README](README_CN.md)**
+
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 [![npm version](https://img.shields.io/npm/v/@seanyao/roll.svg)](https://www.npmjs.com/package/@seanyao/roll)
 [![CI](https://github.com/seanyao/roll/actions/workflows/ci.yml/badge.svg)](https://github.com/seanyao/roll/actions/workflows/ci.yml)
@@ -17,20 +19,21 @@
 
 ## What is Roll?
 
-Roll solves a specific problem: when developers on the same team use different AI clients (Claude Code, Cursor, Gemini CLI, Codex), each agent operates under different engineering constraints. One developer's Claude runs tests another's Cursor never even considers.
+Roll solves a specific problem: when developers on the same team use different AI clients (Claude Code, Cursor, Gemini CLI, Kimi, Codex, DeepSeek, Pi, OpenCode, Trae), each agent operates under different engineering constraints. One developer's Claude runs tests another's Cursor never even considers.
 
-Roll fixes this through two mechanisms:
+Roll fixes this through three mechanisms:
 
-1. **Convention CLI** — a single source of engineering conventions distributed to every AI client on the machine (`~/.claude/`, `~/.cursor/`, `~/.gemini/`, etc.)
-2. **Skill System** — proven engineering practices (TDD, TCR, SRE, INVEST) encoded as instructions that any AI agent can follow
+1. **Convention CLI** — a single source of engineering conventions distributed to every AI client on the machine (`~/.claude/`, `~/.cursor/`, `~/.gemini/`, `~/.kimi/`, `~/.codex/`, `~/.deepseek/`, etc.)
+2. **Skill System** — 20 proven engineering practices (TDD, TCR, SRE, INVEST, DDD) encoded as instructions that any AI agent can follow
+3. **Autonomous Evolution** — an optional layer that lets the agent work unattended: `roll-loop` executes BACKLOG items hourly, `roll-.dream` scans code health nightly, and `roll-brief` briefs the human each morning. The human retains sole authority over releases.
 
-The result: any agent, any client, same constraints.
+The result: any agent, any client, same constraints — and optionally, continuous autonomous delivery.
 
 ---
 
 ## Start Here
 
-Before commands and skills, read the Engineering Methodology — it explains the three-loop architecture (Research → Build → Observe), why each skill exists, and how they connect into a complete delivery system.
+Before commands and skills, read the Engineering Methodology — it explains the three-loop architecture (Research → Build → Observe), the autonomous evolution layer, why each skill exists, and how they connect into a complete delivery system.
 
 **[English](docs/methodology-en.md)** · **[中文](docs/methodology.md)**
 
@@ -57,17 +60,25 @@ roll update
 
 ## Convention Management
 
-Unified behavioral conventions for Claude Code / Gemini CLI / Cursor / Codex — all from one source.
+Unified behavioral conventions for Claude Code / Gemini CLI / Cursor / Kimi / Codex / DeepSeek / Pi / OpenCode / Trae — all from one source.
 
 ### Commands
 
+Commands fall into two categories: **bash commands** run pure shell logic; **agent commands** (marked with 🤖) launch a full AI agent session to execute a SKILL.md.
+
 | Command | Description |
 |---------|-------------|
-| `roll setup` | First-time install on this machine, or re-sync after editing `~/.roll/config.yaml` (use `--force` to overwrite local cache) |
-| `roll update` | One-step upgrade: `npm install -g @seanyao/roll@latest` + re-sync via `roll setup` |
+| `roll setup [-f]` | First-time install on this machine, or re-sync (use `--force` to overwrite local cache) |
+| `roll update` | One-step upgrade: `npm install -g @seanyao/roll@latest` + re-sync via setup |
 | `roll init` | New project: create `AGENTS.md` + `BACKLOG.md` + `docs/features/` |
-
 | `roll status` | Show sync state, skill links, and detected AI tools |
+| `roll backlog` | Show all pending tasks from BACKLOG.md |
+| `roll agent [use <name>\|list]` | Per-project agent selection — affects all 🤖 commands |
+| `roll loop <on\|off\|now\|status\|monitor\|resume\|reset>` | 🤖 Manage the autonomous BACKLOG executor (three-service: loop/dream/brief) |
+| `roll brief` | 🤖 Show latest owner brief (regenerate if stale >24h) |
+| `roll peer` | 🤖 Cross-agent code review and negotiation |
+| `roll release` | 🤖 Sync changelog + version bump + tag + npm publish + GitHub Release |
+| `roll` _(no args, in project dir)_ | Dashboard: loop status, pending count, latest brief summary |
 
 ### Typical Flow
 
@@ -83,7 +94,13 @@ roll init
 # 3. Upgrade to a new release
 roll update
 
+# 4. Enable autonomous evolution (optional)
+roll loop on                  # three services: loop (hourly) + dream (nightly) + brief (daily)
+roll loop monitor             # real-time top-like dashboard
+roll brief                    # read the latest digest
 
+# 5. Switch agent per project
+roll agent use kimi           # all 🤖 commands now use kimi for this project
 ```
 
 ### How Convention Layering Works
@@ -134,32 +151,93 @@ Research → Design → Build → Check → Fix → (loop)
 | Execute a planned Story | `$roll-build US-001` |
 | Free-form feature request | `$roll-build "add search to admin"` |
 | Bug fix | `$roll-fix FIX-001` |
-| Fast backlog capture (bug / idea) | `$roll-jot "description"` |
+| Fast backlog capture (bug / idea) | `$roll-idea "description"` |
 | High-risk logic (payments, auth, state machines) | `$roll-spar "feature"` |
 | Deep research (product / company / tech) | `$roll-research "subject"` |
+| Cross-agent code review | `$roll-peer` |
 | Patrol production for regressions | `$roll-sentinel patrol` |
 | Debug a broken page | `$roll-debug <URL>` |
 | Record a dev moment / diary entry | `$roll-notes "just fixed that nasty bug"` |
+| Let the agent work overnight | `roll loop on` |
 
 ### Full Skill List
 
-| Skill | Phase | Description |
-|-------|-------|-------------|
-| `$roll-build` | DESIGN+BUILD | Universal entry: Story ID, fix ID, or free-text fly mode |
-| `$roll-design` | DESIGN | Multi-turn discuss → [peer review] → DDD model → solution design → [peer review] → write Stories to BACKLOG |
-| `$roll-fix` | FIX | Bug fix / hotfix from BACKLOG |
-| `$roll-jot` | Support | Fast capture a bug or idea into BACKLOG.md |
-| `$roll-spar` | BUILD | Adversarial TDD — Attacker writes tests, Defender writes code |
-| `$roll-sentinel` | CHECK | Scheduled production patrol |
-| `$roll-debug` | CHECK | Deep page diagnostics + root cause analysis |
-| `$roll-research` | RESEARCH | HV Analysis framework, outputs PDF report |
-| `$roll-release` | RELEASE | One-command publish: auto version (YYYY.MMDD.N) → tag → npm publish |
-| `$roll-.review` | Support | Pre-commit self code review |
-| `$roll-.qa` | Support | Test pyramid and coverage standards reference |
-| `$roll-.changelog` | Support | Auto-generate CHANGELOG from BACKLOG |
-| `$roll-.echo` | Support | Passive intent clarification |
-| `$roll-.clarify` | Support | Passive scope clarification for vague build requests |
-| `$roll-notes` | Support | Project diary — append dev moments to `notes/YYYY-MM-DD.md` |
+**Loop A — Research & Design**
+
+| Skill | Description |
+|-------|-------------|
+| `$roll-research` | HV Analysis (Horizontal-Vertical) deep research framework, outputs PDF report |
+| `$roll-design` | Multi-turn discuss → [peer review] → DDD model → solution design → [peer review] → write Stories to BACKLOG |
+
+**Loop B — Implementation & Iteration**
+
+| Skill | Description |
+|-------|-------------|
+| `$roll-build` | Universal entry: Story ID, fix ID, or free-text fly mode. TCR-driven micro-commits |
+| `$roll-spar` | Adversarial TDD — Attacker writes tests, Defender writes code |
+| `$roll-fix` | Bug fix / hotfix from BACKLOG |
+| `$roll-release` | One-command publish: auto version (YYYY.MMDD.N) → tag → npm publish → GitHub Release |
+| `$roll-peer` | Cross-agent code review — Claude / Kimi / DeepSeek / Codex bilateral negotiation |
+
+**Loop C — Observability & Maintenance**
+
+| Skill | Description |
+|-------|-------------|
+| `$roll-sentinel` | Randomized production patrol with adaptive hot-spot weighting |
+| `$roll-debug` | Deep page diagnostics + root cause analysis (Black Box probe) |
+
+**Autonomous Evolution (optional, via `roll loop on`)**
+
+| Skill | Description |
+|-------|-------------|
+| `$roll-loop` | Hourly BACKLOG executor — routes US/FIX/REFACTOR to the right skill, enforces TCR |
+| `$roll-.dream` | Nightly code health scan — dead code, architectural drift → REFACTOR entries |
+| `$roll-brief` | Owner-facing digest — what's done, what's pending, release readiness verdict |
+
+**Passive Support**
+
+| Skill | Description |
+|-------|-------------|
+| `$roll-.review` | Pre-commit multi-dimensional self code review |
+| `$roll-.qa` | Test pyramid and coverage standards reference |
+| `$roll-.changelog` | Auto-generate CHANGELOG from BACKLOG |
+| `$roll-.echo` | Passive intent clarification |
+| `$roll-.clarify` | Passive scope clarification for vague build requests |
+| `$roll-idea` | Fast capture a bug or idea into BACKLOG.md |
+| `$roll-notes` | Project diary — append dev moments to `notes/YYYY-MM-DD.md` |
+| `$roll-doctor` | One-command dev toolchain health check |
+
+---
+
+## Autonomous Evolution
+
+Off by default. Enable with `roll loop on` to let the agent work unattended on your project.
+
+```
+┌─────────────────────────────────────────────────────────┐
+│  Base layer (always active)                             │
+│  $roll-design → $roll-build → $roll-fix → $roll-spar   │
+│  Human drives every action                              │
+├─────────────────────────────────────────────────────────┤
+│  Autonomous layer (opt-in: roll loop on)                │
+│  roll-loop   — hourly BACKLOG executor                  │
+│  roll-.dream — nightly code health scan                 │
+│  roll-brief  — daily morning digest + release readiness │
+│  Human reviews briefs; retains sole release authority   │
+└─────────────────────────────────────────────────────────┘
+```
+
+Three services are scheduled via macOS launchd (Linux: crontab) and managed as a unit:
+
+- **roll-loop** runs hourly, picks up `📋 Todo` items from BACKLOG, routes them (`US-XXX → $roll-build`, `FIX-XXX → $roll-fix`, `REFACTOR-XXX → $roll-build`), and enforces TCR discipline — if a story completes with zero `tcr:` micro-commits, it reverts to Todo with an ALERT.
+- **roll-.dream** runs nightly, scanning for dead code, architectural drift, and refactoring opportunities. Outputs `REFACTOR-XXX` entries to BACKLOG.
+- **roll-brief** runs each morning (or on-demand via `roll brief`), producing an owner-facing digest with a release-readiness verdict.
+
+The autonomous layer **never** invokes `roll-release`. Production deployment is always a human decision.
+
+Use `roll loop monitor` for a real-time `top`-like view of all three services: launchd status, current execution state, pending queue, alerts, and live log tail.
+
+Per-project agent configuration: `roll agent use <name>` writes `.roll.yaml` so each project can use a different AI client (claude / kimi / deepseek / pi / codex / opencode). Lookup order: `.roll.yaml` → `~/.roll/config.yaml` → `claude` (default).
 
 ---
 

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.510.10"
+VERSION="2026.511.2"
 ROLL_HOME="${ROLL_HOME:-${HOME}/.roll}"
 ROLL_CONFIG="${ROLL_HOME}/config.yaml"
 ROLL_GLOBAL="${ROLL_HOME}/conventions/global"
@@ -544,6 +544,12 @@ cmd_setup() {
   _peer_ensure_state_dir
   ok "Peer state directory ready.  Peer 状态目录已就绪。"
 
+  if [[ "$(uname)" == "Darwin" ]]; then
+    echo ""
+    info "Installing launchd plists...  正在安装 LaunchAgents..."
+    _install_launchd_plists "$(pwd -P)"
+  fi
+
   echo ""
   ok "Setup complete.  初始化完成。"
 
@@ -1729,8 +1735,128 @@ cmd_agent() {
 # ═══════════════════════════════════════════════════════════════════════════════
 
 _LOOP_TAG="# roll-loop"
+_SHARED_ROOT="${HOME}/.shared/roll"
 _LOOP_STATE="${HOME}/.shared/roll/loop/state.yaml"
 _LOOP_ALERT="${HOME}/.shared/roll/loop/ALERT.md"
+_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 base; base=$(basename "$path")
+  local hash
+  if command -v md5 &>/dev/null; then
+    hash=$(printf '%s' "$path" | md5 | cut -c1-6)
+  else
+    hash=$(printf '%s' "$path" | md5sum | cut -c1-6)
+  fi
+  base=$(printf '%s' "$base" | tr -cs '[:alnum:]' '-' | sed 's/-*$//')
+  printf '%s' "${base}-${hash}"
+}
+
+_launchd_label() {
+  local service="$1" project_path="$2"
+  printf 'com.roll.%s.%s' "$service" "$(_project_slug "$project_path")"
+}
+
+_launchd_plist_path() {
+  local service="$1" project_path="$2"
+  printf '%s/%s.plist' "$_LAUNCHD_DIR" "$(_launchd_label "$service" "$project_path")"
+}
+
+_write_launchd_plist() {
+  local plist_path="$1" label="$2" project_path="$3"
+  local minute="$4" hour="$5" runner_script="$6"
+
+  local hour_xml=""
+  [[ -n "$hour" ]] && hour_xml="    <key>Hour</key>
+    <integer>${hour}</integer>
+"
+
+  local content
+  content="<?xml version=\"1.0\" encoding=\"UTF-8\"?>
+<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">
+<plist version=\"1.0\">
+<dict>
+  <key>Label</key>
+  <string>${label}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>/bin/bash</string>
+    <string>-l</string>
+    <string>${runner_script}</string>
+  </array>
+  <key>StartCalendarInterval</key>
+  <dict>
+    <key>Minute</key>
+    <integer>${minute}</integer>
+${hour_xml}  </dict>
+  <key>WorkingDirectory</key>
+  <string>${project_path}</string>
+</dict>
+</plist>"
+
+  if [[ -f "$plist_path" ]] && [[ "$(cat "$plist_path")" == "$content" ]]; then
+    return 0
+  fi
+  printf '%s\n' "$content" > "$plist_path"
+}
+
+_write_runner_script() {
+  local script_path="$1" project_path="$2" cmd="$3" log_path="$4"
+  mkdir -p "$(dirname "$script_path")"
+  printf '#!/bin/bash -l\ncd "%s" && %s >> "%s" 2>&1\n' "$project_path" "$cmd" "$log_path" > "$script_path"
+  chmod +x "$script_path"
+}
+
+_launchd_is_loaded() {
+  launchctl list "$1" &>/dev/null 2>&1
+}
+
+# Install launchd plist files (disabled by default) and runner scripts for
+# a given project path. Idempotent — skips unchanged files. Does NOT load.
+_install_launchd_plists() {
+  local project_path="$1"
+  local sd="${ROLL_HOME}/skills"
+  local shared="${_SHARED_ROOT}"
+
+  mkdir -p "$_LAUNCHD_DIR"
+  mkdir -p "${shared}/loop" "${shared}/dream" "${shared}/brief"
+
+  local services=("loop" "dream" "brief")
+  local skill_names=("roll-loop" "roll-.dream" "roll-brief")
+  local minutes=("0" "0" "0")
+  local hours=("" "3" "9")
+
+  local updated=0
+  for i in "${!services[@]}"; do
+    local svc="${services[$i]}"
+    local skill="${skill_names[$i]}"
+    local minute="${minutes[$i]}"
+    local hour="${hours[$i]}"
+    local label; label=$(_launchd_label "$svc" "$project_path")
+    local plist; plist=$(_launchd_plist_path "$svc" "$project_path")
+    local runner="${shared}/${svc}/run.sh"
+    local log="${shared}/${svc}/cron.log"
+    local cmd; cmd=$(_agent_skill_cmd "${sd}/${skill}/SKILL.md" 2>/dev/null || echo "roll loop now")
+
+    _write_runner_script "$runner" "$project_path" "cd \"${project_path}\" && ${cmd}" "$log"
+
+    local before=""
+    [[ -f "$plist" ]] && before=$(cat "$plist")
+    _write_launchd_plist "$plist" "$label" "$project_path" "$minute" "$hour" "$runner"
+    local after; after=$(cat "$plist")
+    [[ "$before" != "$after" ]] && updated=$((updated + 1))
+  done
+
+  if [[ $updated -gt 0 ]]; then
+    ok "Launchd plists installed (${updated} updated)  LaunchAgents 已安装"
+    echo "  Run: roll loop on  to activate  运行 roll loop on 激活"
+  else
+    ok "Launchd plists up to date  LaunchAgents 无需更新"
+  fi
+}
 
 _agent_skill_cmd() {
   local skill_path="$1"
@@ -1738,7 +1864,7 @@ _agent_skill_cmd() {
   # Strip YAML frontmatter inline for cron commands
   local strip="awk 'NR==1 && /^---$/{skip=1;next} skip && /^---$/{skip=0;next} !skip{print}' '${skill_path}'"
   case "$agent" in
-    claude)   echo "claude -p \"\$(${strip})\"" ;;
+    claude)   local _bin; _bin=$(command -v claude 2>/dev/null || echo "claude"); echo "${_bin} -p \"\$(${strip})\"" ;;
     kimi)     echo "kimi --quiet -p \"\$(${strip})\"" ;;
     deepseek) echo "deepseek \"\$(${strip})\"" ;;
     pi)       echo "pi -p \"\$(${strip})\"" ;;
@@ -1751,31 +1877,57 @@ _agent_skill_cmd() {
 cmd_loop() {
   local subcmd="${1:-status}"; shift || true
   case "$subcmd" in
-    on)     _loop_on ;;
-    off)    _loop_off ;;
-    now)    _loop_now ;;
-    status) _loop_status ;;
-    resume) _loop_resume ;;
-    reset)  _loop_reset ;;
-    *) err "Usage: roll loop <on|off|now|status|resume|reset>"; exit 1 ;;
+    on)      _loop_on ;;
+    off)     _loop_off ;;
+    now)     _loop_now ;;
+    status)  _loop_status ;;
+    monitor) _loop_monitor "${1:-3}" ;;
+    resume)  _loop_resume ;;
+    reset)   _loop_reset ;;
+    *) err "Usage: roll loop <on|off|now|status|monitor|resume|reset>"; exit 1 ;;
   esac
 }
 
 _loop_on() {
   local project_path; project_path=$(pwd -P)
   local agent; agent=$(_project_agent)
-  local sd="${ROLL_HOME}/skills"
 
+  if [[ "$(uname)" == "Darwin" ]]; then
+    _install_launchd_plists "$project_path" >/dev/null
+
+    local all_loaded=true
+    for svc in loop dream brief; do
+      local label; label=$(_launchd_label "$svc" "$project_path")
+      if ! _launchd_is_loaded "$label"; then
+        all_loaded=false
+        launchctl load "$(_launchd_plist_path "$svc" "$project_path")" 2>/dev/null || true
+      fi
+    done
+
+    if $all_loaded; then
+      warn "Loop already enabled for this project  当前项目 loop 已启用"; return 0
+    fi
+
+    ok "Loop enabled  已启用"
+    echo "  • roll-loop   every hour :00    每小时整点"
+    echo "  • roll-.dream nightly at 03:00  每晚 03:00"
+    echo "  • roll-brief  daily at 09:00    每天 09:00"
+    echo "  • Agent: ${agent}  (change: roll agent use <name>)"
+    return 0
+  fi
+
+  # Linux: crontab
+  local sd="${ROLL_HOME}/skills"
   if crontab -l 2>/dev/null | grep -q "${_LOOP_TAG}:${project_path}"; then
     warn "Loop already enabled for this project  当前项目 loop 已启用"; return 0
   fi
 
-  mkdir -p ~/.shared/roll/{loop,dream,brief}
+  mkdir -p "${_SHARED_ROOT}/loop" "${_SHARED_ROOT}/dream" "${_SHARED_ROOT}/brief"
 
   local loop_cmd dream_cmd brief_cmd
-  loop_cmd="cd \"${project_path}\" && $(_agent_skill_cmd "${sd}/roll-loop/SKILL.md") >> ~/.shared/roll/loop/cron.log 2>&1"
-  dream_cmd="cd \"${project_path}\" && $(_agent_skill_cmd "${sd}/roll-.dream/SKILL.md") >> ~/.shared/roll/dream/cron.log 2>&1"
-  brief_cmd="cd \"${project_path}\" && $(_agent_skill_cmd "${sd}/roll-brief/SKILL.md") >> ~/.shared/roll/brief/cron.log 2>&1"
+  loop_cmd="cd \"${project_path}\" && $(_agent_skill_cmd "${sd}/roll-loop/SKILL.md") >> ${_SHARED_ROOT}/loop/cron.log 2>&1"
+  dream_cmd="cd \"${project_path}\" && $(_agent_skill_cmd "${sd}/roll-.dream/SKILL.md") >> ${_SHARED_ROOT}/dream/cron.log 2>&1"
+  brief_cmd="cd \"${project_path}\" && $(_agent_skill_cmd "${sd}/roll-brief/SKILL.md") >> ${_SHARED_ROOT}/brief/cron.log 2>&1"
 
   (
     crontab -l 2>/dev/null
@@ -1786,13 +1938,31 @@ _loop_on() {
 
   ok "Loop enabled  已启用"
   echo "  • roll-loop   every hour :00    每小时整点"
-  echo "  • roll-.dream nightly at 01:00  每晚 01:00"
-  echo "  • roll-brief  daily at 08:00    每天 08:00"
+  echo "  • roll-.dream nightly at 03:00  每晚 03:00"
+  echo "  • roll-brief  daily at 09:00    每天 09:00"
   echo "  • Agent: ${agent}  (change: roll agent use <name>)"
 }
 
 _loop_off() {
   local project_path; project_path=$(pwd -P)
+
+  if [[ "$(uname)" == "Darwin" ]]; then
+    local any_loaded=false
+    for svc in loop dream brief; do
+      local label; label=$(_launchd_label "$svc" "$project_path")
+      if _launchd_is_loaded "$label"; then
+        any_loaded=true
+        launchctl unload "$(_launchd_plist_path "$svc" "$project_path")" 2>/dev/null || true
+      fi
+    done
+    if ! $any_loaded; then
+      warn "Loop not enabled for this project  当前项目 loop 未启用"; return 0
+    fi
+    ok "Loop disabled  已停用"
+    return 0
+  fi
+
+  # Linux: crontab
   if ! crontab -l 2>/dev/null | grep -q "${_LOOP_TAG}:${project_path}"; then
     warn "Loop not enabled for this project  当前项目 loop 未启用"; return 0
   fi
@@ -1805,14 +1975,26 @@ _loop_now() {
     warn "Loop already running  loop 正在运行中"; return 0
   fi
   info "Triggering loop cycle...  正在触发一个周期..."
-  _agent_run_skill "roll-loop"
+  local log_file="${_SHARED_ROOT}/loop/launchd.log"
+  mkdir -p "$(dirname "$log_file")"
+  _agent_run_skill "roll-loop" 2>&1 | tee -a "$log_file" || true
+  # Reset stale running state if skill exited without cleanup (e.g. API error, SIGKILL)
+  if [[ -f "$_LOOP_STATE" ]] && grep -q "^status: running" "$_LOOP_STATE" 2>/dev/null; then
+    printf "status: idle\n" > "$_LOOP_STATE"
+  fi
 }
 
 _loop_status() {
   local project_path; project_path=$(pwd -P)
   local agent; agent=$(_project_agent)
   echo ""
-  if crontab -l 2>/dev/null | grep -q "${_LOOP_TAG}:${project_path}"; then
+  local loop_enabled=false
+  if [[ "$(uname)" == "Darwin" ]]; then
+    _launchd_is_loaded "$(_launchd_label "loop" "$project_path")" && loop_enabled=true
+  else
+    crontab -l 2>/dev/null | grep -q "${_LOOP_TAG}:${project_path}" && loop_enabled=true
+  fi
+  if $loop_enabled; then
     echo -e "  Scheduler  ${GREEN}● enabled${NC}   Agent: ${CYAN}${agent}${NC}"
   else
     echo -e "  Scheduler  ${YELLOW}○ disabled${NC}   run: roll loop on"
@@ -1842,6 +2024,176 @@ _loop_reset() {
   fi
 }
 
+# Count `tcr:` prefixed commits in the current git repo since started_at timestamp.
+_loop_tcr_count() {
+  local started_at="$1"
+  git log --oneline --since="${started_at}" 2>/dev/null \
+    | awk '/^[a-f0-9]+ tcr:/{n++} END{print n+0}'
+}
+
+# Verify TCR rhythm after a story completes. Returns 0 if ok, 1 if no TCR commits.
+# On failure: reverts story in BACKLOG.md to 📋 Todo and writes ALERT.
+_loop_enforce_tcr() {
+  local story_id="$1"
+  local started_at="${2:-}"
+
+  [[ -z "$started_at" ]] && return 0
+
+  local count; count=$(_loop_tcr_count "$started_at")
+
+  if [[ "$count" -eq 0 ]]; then
+    # Revert story status
+    if [[ -f "BACKLOG.md" ]]; then
+      local tmp; tmp=$(mktemp)
+      sed "/\[${story_id}\]/s/ | ✅ Done |/ | 📋 Todo |/" BACKLOG.md > "$tmp" \
+        && mv "$tmp" BACKLOG.md
+    fi
+
+    # Write ALERT
+    mkdir -p "$(dirname "$_LOOP_ALERT")"
+    cat > "$_LOOP_ALERT" << EOF
+# ALERT — TCR check failed
+
+**Time**: $(date '+%Y-%m-%d %H:%M')
+**Story**: ${story_id}
+**Reason**: zero tcr: commits since story start (${started_at})
+
+**Action required** (choose one):
+- Add TCR commits and re-run: \`roll loop now\`
+- Take over manually: \`\$roll-build ${story_id}\`
+- Reset and retry: \`roll loop reset\` then \`roll loop now\`
+EOF
+    return 1
+  fi
+
+  return 0
+}
+
+_loop_monitor() {
+  local interval="${1:-3}"
+  local project_path; project_path=$(pwd -P)
+  local project_name; project_name=$(basename "$project_path")
+
+  # Determine terminal clear capability
+  local clear_cmd="clear"
+  command -v clear &>/dev/null || clear_cmd="echo ''"
+
+  while true; do
+    $clear_cmd
+    local agent; agent=$(_project_agent)
+    local now; now=$(date '+%Y-%m-%d %H:%M:%S')
+
+    echo -e "\n  ${BOLD}${CYAN}roll loop monitor${NC}  ${YELLOW}${project_name}${NC}  ${now}  (Ctrl-C to exit)\n"
+
+    # Services status (three services on macOS, single on Linux)
+    echo -e "  ${BOLD}Services  服务状态${NC}   Agent: ${CYAN}${agent}${NC}"
+    if [[ "$(uname)" == "Darwin" ]]; then
+      local svc_info svc schedule
+      for svc_info in "loop:hourly" "dream:03:00" "brief:09:00"; do
+        svc="${svc_info%%:*}"
+        schedule="${svc_info#*:}"
+        if _launchd_is_loaded "$(_launchd_label "$svc" "$project_path")"; then
+          printf "    ${GREEN}%-8s ● enabled${NC}   (%s)\n" "$svc" "$schedule"
+        else
+          printf "    ${YELLOW}%-8s ○ disabled${NC}  (%s)\n" "$svc" "$schedule"
+        fi
+      done
+    else
+      if crontab -l 2>/dev/null | grep -q "${_LOOP_TAG}:${project_path}"; then
+        echo -e "    ${GREEN}loop     ● enabled${NC}"
+      else
+        echo -e "    ${YELLOW}loop     ○ disabled${NC}   run: roll loop on"
+      fi
+    fi
+
+    # Current state
+    if [[ -f "$_LOOP_STATE" ]]; then
+      local status current_item started_at run_id
+      status=$(grep '^status:' "$_LOOP_STATE" | awk '{print $2}')
+      current_item=$(grep '^current_item:' "$_LOOP_STATE" | awk '{print $2}')
+      started_at=$(grep '^started_at:' "$_LOOP_STATE" | cut -d' ' -f2- | tr -d '"')
+      run_id=$(grep '^run_id:' "$_LOOP_STATE" | awk '{print $2}')
+      echo ""
+      case "$status" in
+        running) echo -e "  State      ${GREEN}▶ running${NC}   ${CYAN}${current_item}${NC}   started: ${started_at}   run: ${run_id}" ;;
+        paused)  echo -e "  State      ${RED}‖ paused${NC}    on: ${current_item}" ;;
+        idle)    echo -e "  State      ${YELLOW}○ idle${NC}" ;;
+        *)       echo -e "  State      ${status}" ;;
+      esac
+    else
+      echo ""
+      echo -e "  State      ${YELLOW}○ no state file${NC}"
+    fi
+
+    # Alert
+    if [[ -f "$_LOOP_ALERT" ]]; then
+      echo ""
+      echo -e "  ${RED}⚠ ALERT:${NC}"
+      sed 's/^/    /' "$_LOOP_ALERT"
+    fi
+
+    # Queue: pending items
+    echo ""
+    echo -e "  ${BOLD}Queue  待处理队列${NC}"
+    local backlog="BACKLOG.md"
+    if [[ -f "$backlog" ]]; then
+      local queue_count=0
+      local fix_pending us_pending refactor_pending
+      fix_pending=$(grep -E '^\| FIX-' "$backlog" | grep -F '| 📋 Todo |' || true)
+      us_pending=$(grep -E '^\| \[US-' "$backlog" | grep -F '| 📋 Todo |' || true)
+      refactor_pending=$(grep -E '^\| REFACTOR-' "$backlog" | grep -F '| 📋 Todo |' || true)
+
+      # FIX first (priority)
+      while IFS= read -r line; do
+        [[ -z "$line" ]] && continue
+        local id desc
+        id=$(echo "$line" | awk -F'|' '{print $2}' | tr -d ' ')
+        desc=$(echo "$line" | awk -F'|' '{print $3}' | sed 's/^ *//;s/ *$//' | cut -c1-60)
+        printf "    ${RED}%-14s${NC}  %s\n" "$id" "$desc"
+        (( queue_count++ )) || true
+      done <<< "$fix_pending"
+
+      # US stories
+      while IFS= read -r line; do
+        [[ -z "$line" ]] && continue
+        local id desc
+        id=$(echo "$line" | sed 's/.*\[\(US-[^]]*\)\].*/\1/')
+        desc=$(echo "$line" | awk -F'|' '{print $3}' | sed 's/^ *//;s/ *$//' | cut -c1-60)
+        printf "    ${CYAN}%-14s${NC}  %s\n" "$id" "$desc"
+        (( queue_count++ )) || true
+      done <<< "$us_pending"
+
+      # Refactors
+      while IFS= read -r line; do
+        [[ -z "$line" ]] && continue
+        local id desc
+        id=$(echo "$line" | awk -F'|' '{print $2}' | tr -d ' ')
+        desc=$(echo "$line" | awk -F'|' '{print $3}' | sed 's/^ *//;s/ *$//' | cut -c1-60)
+        printf "    ${YELLOW}%-14s${NC}  %s\n" "$id" "$desc"
+        (( queue_count++ )) || true
+      done <<< "$refactor_pending"
+
+      [[ $queue_count -eq 0 ]] && echo -e "    ${GREEN}✓ empty${NC}"
+    else
+      echo "    BACKLOG.md not found"
+    fi
+
+    # Log tail (launchd.log)
+    local log_file="${_SHARED_ROOT}/loop/launchd.log"
+    echo ""
+    echo -e "  ─────────────────────────────────────────────────────"
+    echo -e "  ${BOLD}Log Tail  实时日志${NC}  (~/.shared/roll/loop/launchd.log, last 10 lines)"
+    if [[ -f "$log_file" && -s "$log_file" ]]; then
+      tail -10 "$log_file" | sed 's/^/    /'
+    else
+      echo -e "    ${YELLOW}(no log yet)${NC}"
+    fi
+
+    echo ""
+    sleep "$interval"
+  done
+}
+
 # ═══════════════════════════════════════════════════════════════════════════════
 # BRIEF — owner-facing project digest
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -1872,6 +2224,75 @@ cmd_release() {
   _agent_run_skill "roll-release"
 }
 
+# ═══════════════════════════════════════════════════════════════════════════════
+# BACKLOG — show pending tasks
+# ═══════════════════════════════════════════════════════════════════════════════
+
+cmd_backlog() {
+  local backlog="BACKLOG.md"
+  if [[ ! -f "$backlog" ]]; then
+    err "BACKLOG.md not found — run 'roll init' first  未找到 BACKLOG.md，请先运行 roll init"
+    return 1
+  fi
+
+  local us_items fix_items refactor_items total=0
+
+  us_items=$(grep -E '^\| \[US-' "$backlog" | grep -F '| 📋 Todo |' || true)
+  fix_items=$(grep -E '^\| FIX-' "$backlog" | grep -F '| 📋 Todo |' || true)
+  refactor_items=$(grep -E '^\| REFACTOR-' "$backlog" | grep -F '| 📋 Todo |' || true)
+
+  local us_count fix_count refactor_count
+  us_count=$(echo "$us_items" | grep -c . || true)
+  fix_count=$(echo "$fix_items" | grep -c . || true)
+  refactor_count=$(echo "$refactor_items" | grep -c . || true)
+  [[ -z "$us_items" ]] && us_count=0
+  [[ -z "$fix_items" ]] && fix_count=0
+  [[ -z "$refactor_items" ]] && refactor_count=0
+  total=$(( us_count + fix_count + refactor_count ))
+
+  echo ""
+  echo -e "  ${BOLD}Pending Backlog  待处理任务${NC}  (${total} items)"
+  echo ""
+
+  if [[ $fix_count -gt 0 ]]; then
+    echo -e "  ${RED}Bug Fixes  缺陷修复  (${fix_count})${NC}"
+    while IFS= read -r line; do
+      local id desc
+      id=$(echo "$line" | awk -F'|' '{print $2}' | tr -d ' ')
+      desc=$(echo "$line" | awk -F'|' '{print $3}' | sed 's/^ *//;s/ *$//')
+      printf "    %-12s  %s\n" "$id" "$desc"
+    done <<< "$fix_items"
+    echo ""
+  fi
+
+  if [[ $us_count -gt 0 ]]; then
+    echo -e "  ${CYAN}User Stories  用户故事  (${us_count})${NC}"
+    while IFS= read -r line; do
+      local id desc
+      id=$(echo "$line" | sed 's/.*\[\(US-[^]]*\)\].*/\1/')
+      desc=$(echo "$line" | awk -F'|' '{print $3}' | sed 's/^ *//;s/ *$//')
+      printf "    %-14s  %s\n" "$id" "$desc"
+    done <<< "$us_items"
+    echo ""
+  fi
+
+  if [[ $refactor_count -gt 0 ]]; then
+    echo -e "  ${YELLOW}Refactors  重构  (${refactor_count})${NC}"
+    while IFS= read -r line; do
+      local id desc
+      id=$(echo "$line" | awk -F'|' '{print $2}' | tr -d ' ')
+      desc=$(echo "$line" | awk -F'|' '{print $3}' | sed 's/^ *//;s/ *$//')
+      printf "    %-16s  %s\n" "$id" "$desc"
+    done <<< "$refactor_items"
+    echo ""
+  fi
+
+  if [[ $total -eq 0 ]]; then
+    echo -e "  ${GREEN}✓ Nothing pending — backlog is clear  暂无待处理任务${NC}"
+    echo ""
+  fi
+}
+
 # ─────────────────────────────────────────────────────────────────────────────
 
 _dashboard() {
@@ -1881,31 +2302,55 @@ _dashboard() {
 
   echo -e "\n  ${BOLD}${CYAN}${project_name}${NC}  ${YELLOW}v${VERSION}${NC}\n"
 
-  if crontab -l 2>/dev/null | grep -q "${_LOOP_TAG}:${project_path}"; then
+  local _dash_loop_enabled=false
+  if [[ "$(uname)" == "Darwin" ]]; then
+    _launchd_is_loaded "$(_launchd_label "loop" "$project_path")" && _dash_loop_enabled=true
+  else
+    crontab -l 2>/dev/null | grep -q "${_LOOP_TAG}:${project_path}" && _dash_loop_enabled=true
+  fi
+  if $_dash_loop_enabled; then
     echo -e "  Loop  ${GREEN}● on${NC}   Agent: ${CYAN}${agent}${NC}"
+    if [[ "$(uname)" == "Darwin" ]]; then
+      for svc_info in "loop:hourly" "dream:03:00" "brief:09:00"; do
+        local svc="${svc_info%%:*}" schedule="${svc_info#*:}"
+        if _launchd_is_loaded "$(_launchd_label "$svc" "$project_path")"; then
+          printf "    ${GREEN}%-8s ● enabled${NC}  (%s)\n" "$svc" "$schedule"
+        else
+          printf "    ${YELLOW}%-8s ○ disabled${NC} (%s)\n" "$svc" "$schedule"
+        fi
+      done
+    fi
   else
     echo -e "  Loop  ${YELLOW}○ off${NC}   run: roll loop on"
   fi
   [[ -f "$_LOOP_ALERT" ]] && echo -e "  ${RED}⚠ ALERT — run: roll loop status${NC}"
 
+  # Backlog summary
+  if [[ -f "BACKLOG.md" ]]; then
+    local pending_count
+    pending_count=$(grep -cF '| 📋 Todo |' "BACKLOG.md" 2>/dev/null) || pending_count=0
+    if (( pending_count > 0 )); then
+      echo -e "  Backlog  ${YELLOW}${pending_count} pending${NC}   run: roll backlog"
+    else
+      echo -e "  Backlog  ${GREEN}✓ clear${NC}"
+    fi
+  fi
+
   local briefs_dir="docs/briefs"
   local latest; latest=$(ls "${briefs_dir}"/*.md 2>/dev/null | sort | tail -1 || true)
   if [[ -n "$latest" ]]; then
     local mod_time now age
     mod_time=$(stat -c %Y "$latest" 2>/dev/null || stat -f %m "$latest" 2>/dev/null || echo 0)
     now=$(date +%s); age=$(( (now - mod_time) / 3600 ))
-    echo -e "\n  Brief  ${CYAN}$(basename "$latest")${NC}  (${age}h ago)"
-    grep -A1 "## Release Readiness" "$latest" 2>/dev/null | tail -1 | sed 's/^/  /'
-    echo ""
-    echo "  run: roll brief   for full brief"
+    local readiness; readiness=$(awk '/^## Release Readiness/{found=1;next} found && /[^[:space:]]/{gsub(/\*\*/,""); print; exit}' "$latest" 2>/dev/null || true)
+    local done_count; done_count=$(grep -c '| Story\|| Fix\|| Refactor' "$latest" 2>/dev/null) || done_count=0
+    echo -e "\n  Brief  (${age}h ago)  ${readiness:+${CYAN}${readiness}${NC}}"
+    [[ "$done_count" -gt 0 ]] && echo -e "  This cycle: ${done_count} items completed"
   else
     echo -e "\n  No brief yet — run: roll brief"
   fi
 
   echo ""
-  echo "  loop <on|off|now|status|resume|reset>  ·  brief  ·  agent use <name>  ·  release"
-  echo "  setup  ·  update  ·  init  ·  status  ·  peer  ·  help"
-  echo ""
 }
 
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -1930,8 +2375,9 @@ usage() {
   echo "  init                   [Project] Create AGENTS.md + BACKLOG.md + docs/     初始化项目工作流文件"
   echo "  status                 [Diagnostic] Show current state                    显示当前状态"
   echo "  peer                   [Peer Review] Cross-agent negotiation               跨 Agent 协商对审"
-  echo "  loop <on|off|now|status|resume|reset>  [Autonomous] Manage scheduled BACKLOG executor  管理自主执行循环"
+  echo "  loop <on|off|now|status|monitor|resume|reset>  [Autonomous] Manage scheduled BACKLOG executor  管理自主执行循环"
   echo "  brief                  [Digest] Show latest owner brief (regenerate if stale)  展示最新简报"
+  echo "  backlog                [View] Show all pending tasks from BACKLOG.md           显示待处理任务清单"
   echo "  agent [use <name>|list]   [Config] Per-project agent selection            切换项目 agent"
   echo "  release                [Publish] Sync changelog + version bump + npm publish  同步日志并发版"
   echo ""
@@ -1941,6 +2387,7 @@ usage() {
   echo "  roll init                     # New or re-merge project (run in project)   新建或重新合并（项目目录）"
   echo "  roll loop on                  # Enable autonomous loop (cron)              启用自主执行循环"
   echo "  roll brief                    # Show latest brief                          查看最新简报"
+  echo "  roll backlog                  # Show pending BACKLOG items                 查看待处理任务"
   echo "  roll agent use kimi           # Switch this project to kimi               切换当前项目到 kimi"
 
 }
@@ -1957,6 +2404,7 @@ main() {
     peer)          cmd_peer "$@" ;;
     loop)          cmd_loop "$@" ;;
     brief)         cmd_brief "$@" ;;
+    backlog)       cmd_backlog "$@" ;;
     agent)         cmd_agent "$@" ;;
     release)       cmd_release "$@" ;;
     version|--version|-v) echo "roll v${VERSION}" ;;
@@ -2012,7 +2460,7 @@ _check_update_async() {
 
 _notify_update() {
   local cache="${ROLL_HOME}/.update-check"
-  [[ -f "$cache" ]] || return
+  [[ -f "$cache" ]] || return 0
   local latest; latest=$(awk '{print $2}' "$cache" 2>/dev/null || true)
   [[ -z "$latest" || "$latest" == "$VERSION" ]] && return
   local newer; newer=$(printf '%s\n%s\n' "$VERSION" "$latest" | sort -V | tail -1)

package/conventions/global/AGENTS.md

@@ -31,7 +31,7 @@
 
 ## 4. Workflow
 - **Scope Gate**: Only implement what is explicitly listed in the AC. Nothing more.
-  - Requests made in conversation are NOT AC — capture with `roll-jot` first.
+  - Requests made in conversation are NOT AC — capture with `roll-idea` first.
   - Any new Story/Fix requires design doc + user confirmation before TCR starts.
   - Do not commit without user approval unless explicitly told to auto-commit.
 - **TCR**: Test -> Green = Commit / Red = Revert. No WIP commits.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seanyao/roll",
-  "version": "2026.510.10",
+  "version": "2026.511.2",
   "description": "Roll — Roll out features with AI agents",
   "scripts": {
     "test": "find tests/unit tests/integration -name '*.bats' | sort | xargs ./tests/helpers/bats-core/bin/bats"

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

@@ -22,7 +22,7 @@ Auto-invoked by `roll-build` (Fly mode) when the user input is:
 ## When Not to Use
 
 - Intent is already clear and actionable
-- User gives a specific command with a skill trigger (e.g. `$roll-jot ...`)
+- User gives a specific command with a skill trigger (e.g. `$roll-idea ...`)
 - User is answering a clarification question you just asked
 - The task is simple enough that misinterpretation risk is negligible
 - User messy thoughts need restatement rather than questioning (use `$roll-.echo`)

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

@@ -233,10 +233,10 @@ CI failure
 
 ```bash
 # For fixable bugs — create FIX entry
-$roll-jot fix "CI: {step} fails — {root cause summary}"
+$roll-idea fix "CI: {step} fails — {root cause summary}"
 
 # For flaky/environmental issues — create IDEA entry
-$roll-jot idea "CI: investigate flaky {test name}"
+$roll-idea idea "CI: investigate flaky {test name}"
 ```
 
 ### Step 4: Execute Fix

package/skills/roll-brief/SKILL.md

@@ -95,52 +95,72 @@ A simple heuristic — not a gate, just a signal for the human:
 
 ### Step 4 — Write Brief
 
-Output to `docs/briefs/YYYY-MM-DD-HH.md`:
+文件命名：`docs/briefs/YYYY-MM-DD-{NN}.md`，NN 为当日序号（01 起，零填充两位）。
+计算方式：`ls docs/briefs/YYYY-MM-DD-*.md 2>/dev/null | wc -l`，+1 即为本次序号。
+
+全部用中文输出。**省略空 section**（无内容时连标题一起不输出）：
 
 ```markdown
-# Brief {YYYY-MM-DD HH:mm}
+# 简报 {YYYY-MM-DD HH:mm}
+
+> 触发：{触发原因} | 覆盖：{起止时间范围}
 
-## What's Done
-| ID | Description | Type |
+## 已完成（{N} 项）
+| 编号 | 描述 | 类型 |
 |----|-------------|------|
-| US-XXX | {title} | Story |
-| FIX-XXX | {title} | Fix |
-| REFACTOR-XXX | {title} | Refactor |
+| US-XXX | {标题} | 用户故事 |
+| FIX-XXX | {标题} | 缺陷修复 |
+| REFACTOR-XXX | {标题} | 重构 |
 
-## In Progress
-| ID | Description |
+<!-- 仅当有 🔨 条目时输出 -->
+## 进行中
+| 编号 | 描述 |
 |----|-------------|
-| US-XXX | {title} — started {date} |
+| US-XXX | {标题} — 开始于 {date} |
 
-## Queue ({N} items)
-| ID | Description | Priority |
+<!-- 仅当有 📋 条目时输出 -->
+## 待处理队列（{N} 项）
+| 编号 | 描述 | 优先级 |
 |----|-------------|----------|
-| US-XXX | {title} | high |
+| US-XXX | {标题} | 高 |
+
+<!-- 仅当 roll-.dream 有新发现时输出 -->
+## 悟见
+{来自 docs/dream/ 的摘要}
+
+<!-- 仅当有 ESCALATE 告警时输出 -->
+## 需人工介入
+{告警内容}
 
-## Overnight Dream Findings
-{summary from docs/dream/ since last brief, or "No new findings."}
+## 发版就绪
+{✅ 可发版 / ⚠️ 暂缓 — 原因}
 
-## Escalations Requiring Human Input
-{any alerts, or "None — agent operating normally."}
+**下一版本：** `v{YYYY}.{MMDD}.{序号}`
 
-## Release Readiness
-{✅ Release candidate / ⚠️ Hold — reason}
+- {本轮新增 1}
+- {本轮新增 2}
 
 ---
-*Next scheduled brief: {datetime}*
+*状态：进行中 {N} · 待处理 {N} · 告警 {N} | 下次简报：{datetime}*
+```
+
+**首份简报或传入 `--full-history`**：在"已完成"表格后追加历史汇总区块：
+
+```markdown
+### 历史汇总
+**Epic: {Name}** — {done}/{total} ✅
 ```
 
 ### Step 5 — Notify
 
-After writing the file, print the brief path so it's visible in the terminal
-or CI log:
+写完文件后在终端或 CI 日志中打印简报路径：
 
 ```
-📋 Brief written: docs/briefs/2026-05-10-08.md
-   Release readiness: ✅ Release candidate
+📋 简报已生成：docs/briefs/2026-05-10-01.md
+   发布就绪：✅ 可发版
 ```
 
-If there are escalations, print them prominently so they're impossible to miss.
+有升级事项时须显著打印，不得遗漏。
 
 ## Scheduler Configuration
 

package/skills/roll-build/SKILL.md

@@ -18,7 +18,7 @@ One entry point. Any input. Full delivery.
 Input received
   ├── matches "US-[A-Z]+-[0-9]+"  → Story mode: read BACKLOG → TCR workflow
   ├── matches "FIX-[A-Z]+-[0-9]+" → redirect to $roll-fix
-  ├── matches "IDEA-[0-9]+"       → redirect to $roll-jot (lookup and expand)
+  ├── matches "IDEA-[0-9]+"       → redirect to $roll-idea (lookup and expand)
   └── anything else               → Fly mode: clarify → design → execute
 ```
 
@@ -654,7 +654,7 @@ When complex state management is error-prone → consider full reset + re-initia
 roll-build   → ship anything (new idea, US-ID, free-text request)
 roll-fix     → fix a specific known bug (FIX-XXX / BUG-XXX)
 roll-design  → plan and design before building (no code output)
-roll-jot     → fast capture a bug or idea into BACKLOG.md
+roll-idea    → fast capture a bug or idea into BACKLOG.md
 roll-.clarify → passive scope clarification for vague build requests
 ```
 

package/skills/roll-design/SKILL.md

@@ -29,7 +29,7 @@ Discuss approaches, design architecture, plan requirements, and write to `BACKLO
 
 ## When Not to Use
 
-- One-liner capture of ideas or bugs (use `$roll-jot`)
+- One-liner capture of ideas or bugs (use `$roll-idea`)
 - Executing an already-split US-XXX (use `$roll-build`)
 - Fixing a well-defined FIX-XXX (use `$roll-fix`)
 

package/skills/{roll-jot → roll-idea}/SKILL.md

@@ -1,22 +1,22 @@
 ---
-name: roll-jot
+name: roll-idea
 license: MIT
 allowed-tools: "Read, Edit"
 description: "Fast backlog capture. Analyzes a short description, classifies it as bug or idea, and appends it to BACKLOG.md with an auto-incremented ID."
 ---
 
-# roll-jot
+# roll-idea
 
 > One-liner in, backlog entry out. No questions asked.
 
 ## Trigger
 
-User explicitly invokes `roll-jot` with a free-text description.
+User explicitly invokes `roll-idea` with a free-text description.
 
 ```
-$roll-jot 评价页面的星星也要纳入到 draft 的 scope 里
-$roll-jot 手机端星星指标一行一个从上往下排
-$roll-jot 给 HOD 加一个批量导出 PDF 的功能
+$roll-idea 评价页面的星星也要纳入到 draft 的 scope 里
+$roll-idea 手机端星星指标一行一个从上往下排
+$roll-idea 给 HOD 加一个批量导出 PDF 的功能
 ```
 
 ## When Not to Use

package/skills/roll-loop/SKILL.md

@@ -92,9 +92,13 @@ run_id: loop-20260510-0200
 
 After each item completes:
 
-1. Update state file: `status: idle`
-2. Check if a Feature is now fully complete (all its Stories ✅)
-3. If yes and `brief_on_feature_complete: true` → invoke `Skill("roll-brief")`
+1. **TCR 硬校验** — call `_loop_enforce_tcr <story_id> <started_at>`:
+   - Count `tcr:` prefix commits since `started_at` via `git log --oneline --since=<started_at>`
+   - Count == 0 → revert story status in BACKLOG.md from ✅ Done → 📋 Todo; write ALERT to `~/.shared/roll/loop/ALERT.md` with story ID, time, reason "zero tcr: commits since story start", and suggested actions (`roll loop now` / `$roll-build <id>` / `roll loop reset`)
+   - Count > 0 → continue normally
+2. Update state file: `status: idle`
+3. Check if a Feature is now fully complete (all its Stories ✅)
+4. If yes and `brief_on_feature_complete: true` → invoke `Skill("roll-brief")`
 
 ### Step 5 — Write Run Summary
 

package/skills/roll-notes/SKILL.md

@@ -23,7 +23,7 @@ $roll-notes 今天的 code review 给了很好的反馈
 
 ## When Not to Use
 
-- Capturing a bug or feature idea into BACKLOG (use `$roll-jot`)
+- Capturing a bug or feature idea into BACKLOG (use `$roll-idea`)
 - Generating user-facing release notes (use `$roll-.changelog`)
 - Writing design documents or AC (use `$roll-design`)