@seanyao/roll 2026.601.1 → 2026.601.2

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## v2026.601.2
+
+### 新功能
+
+- **curl 安装器骨架:不靠 npm 也能装 roll(US-INSTALL-001)** — 自包含安装脚本探测 OS(仅放行 macOS / Linux)、preflight 检查 `bash≥3.2`/`python3`/`curl`/`tar` 缺啥报啥、把运行时装到 `~/.local/share/roll/` 并 symlink 进 PATH,重复运行即原地升级。本版先从本地源目录复制(真正的 `curl ... | bash` 远端取数留后续故事)`[loop]`
+
+### 可见性
+
+- **peer 评审可靠落盘、能查了(FIX-150a)** — 此前 peer 痕迹碎成三处且大多丢失;统一落盘到项目本地规范路径,新增查询命令翻看历次 peer 记录(发起方 / 对象 / 轮次 / 各方结论 / 耗时),不再依赖 agent 自觉写盘 `[loop]`
+- **三个专用 loop(CI / PR / Alert)空闲时也留心跳(FIX-151)** — 健康空闲时不再零日志让人以为没在跑;每轮补一条轻量存活心跳,status 显示各 loop 上次运行距今多久 `[loop]`
+
 ## v2026.601.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.601.1"
+VERSION="2026.601.2"
 ROLL_HOME="${ROLL_HOME:-${HOME}/.roll}"
 ROLL_CONFIG="${ROLL_HOME}/config.yaml"
 ROLL_GLOBAL="${ROLL_HOME}/conventions/global"
@@ -3713,6 +3713,48 @@ _peer_ensure_state_dir() {
   mkdir -p "${_PEER_STATE_DIR}/logs"
 }
 
+# FIX-150a: project-local peer data directory (analogous to loop runtime dir).
+_peer_project_dir() {
+  local proj
+  proj=$(pwd -P 2>/dev/null || pwd)
+  # FIX-056: normalize path to canonical case on macOS case-insensitive filesystem.
+  if [[ "$(uname -s 2>/dev/null)" == "Darwin" ]]; then
+    local _canon
+    _canon=$(realpath "$proj" 2>/dev/null) && proj="$_canon"
+  fi
+  # When inside a git worktree, resolve to main tree (same pattern as _project_slug).
+  local _common
+  _common=$(git -C "$proj" rev-parse --git-common-dir 2>/dev/null)
+  if [[ -n "$_common" && "$_common" == *"/.git" ]]; then
+    proj="${_common%/.git}"
+  fi
+  echo "${proj}/.roll/peer"
+}
+
+_peer_ensure_project_dir() {
+  local dir
+  dir=$(_peer_project_dir)
+  mkdir -p "$dir/logs"
+}
+
+# FIX-150a: write a structured JSONL record to the project-local peer runs file.
+_peer_write_record() {
+  local from_tool="$1"
+  local to_tool="$2"
+  local round="$3"
+  local verdict="$4"
+  local tag="$5"
+  local duration_sec="$6"
+  local dir
+  dir=$(_peer_project_dir)
+  mkdir -p "$dir"
+  local ts
+  ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+  printf '{"ts":"%s","from":"%s","to":"%s","round":%s,"verdict":"%s","tag":"%s","duration_sec":%s}\n' \
+    "$ts" "$from_tool" "$to_tool" "$round" "$verdict" "$tag" "$duration_sec" \
+    >> "$dir/runs.jsonl"
+}
+
 _peer_state_file() {
   local pair="$1"
   local key="$2"
@@ -3928,6 +3970,8 @@ cmd_peer() {
       --yes|--yolo) yolo=true; shift ;;
       status) subcmd="status"; shift ;;
       reset) subcmd="reset"; shift; break ;;
+      log) subcmd="log"; shift ;;
+      runs) subcmd="runs"; shift ;;
       help|--help|-h) subcmd="help"; shift ;;
       *) err "$(msg peer.unknown_option_1)"; exit 1 ;;
     esac
@@ -3936,6 +3980,8 @@ cmd_peer() {
   case "$subcmd" in
     status) cmd_peer_status; return ;;
     reset) cmd_peer_reset "$@"; return ;;
+    log) cmd_peer_log; return ;;
+    runs) cmd_peer_runs "$@"; return ;;
     help) cmd_peer_help; return ;;
   esac
 
@@ -3985,6 +4031,9 @@ cmd_peer() {
     fi
   fi
 
+  local start_epoch
+  start_epoch=$(date +%s)
+
   local context=""
   if [[ -n "$context_file" && -f "$context_file" ]]; then
     context="$(cat "$context_file")"
@@ -4004,9 +4053,10 @@ cmd_peer() {
     fi
   fi
 
-  _peer_ensure_state_dir
+  # FIX-150a: write logs to project-local path; keep global state dir for adaptive routing.
+  _peer_ensure_project_dir
   local log_file
-  log_file="${_PEER_STATE_DIR}/logs/$(date +%Y%m%d_%H%M%S)_${from_tool}_${to_tool}.md"
+  log_file="$(_peer_project_dir)/logs/$(date +%Y%m%d_%H%M%S)_${from_tool}_${to_tool}.md"
   {
     echo "# Peer Review Log"
     echo ""
@@ -4051,6 +4101,11 @@ cmd_peer() {
 
   _peer_update_state "$pair" "$resolution"
 
+  # FIX-150a: write structured record for observability.
+  local duration_sec=0
+  duration_sec=$(( $(date +%s) - start_epoch ))
+  _peer_write_record "$from_tool" "$to_tool" "$round" "$resolution" "$tag" "$duration_sec"
+
   echo ""
   echo -e "$(msg peer.peer_review_result_peer_review ${BOLD} ${NC})"
   echo "  Pair: $pair"
@@ -4185,10 +4240,72 @@ cmd_peer_help() {
   echo ""
   echo "Subcommands:"
   echo "$(msg peer_help.status_show_peer_review_state)"
+  echo "$(msg peer_help.log_show_latest_peer_transcript)"
+  echo "$(msg peer_help.runs_show_recent_peer_review_runs)"
   echo "$(msg peer_help.reset_pair_all_reset_peer_state)"
   echo "$(msg peer_help.help_show_this_help)"
 }
 
+# FIX-150a: `roll peer runs [N]` — show recent peer review runs (project-local).
+cmd_peer_runs() {
+  local n=10
+  while [[ $# -gt 0 ]]; do
+    case "$1" in
+      [0-9]*) n="$1"; shift ;;
+      *) shift ;;
+    esac
+  done
+
+  local dir
+  dir=$(_peer_project_dir)
+  local runs_file="$dir/runs.jsonl"
+
+  if ! command -v jq >/dev/null 2>&1; then
+    err "$(msg peer.jq_required_for_roll_peer_runs)"
+    return 1
+  fi
+
+  if [[ ! -f "$runs_file" ]] || [[ ! -s "$runs_file" ]]; then
+    echo "$(msg peer.no_peer_runs_yet)"
+    return 0
+  fi
+
+  local reversed
+  reversed=$(awk '{a[NR]=$0} END{for(i=NR; i>=1; i--) print a[i]}' "$runs_file")
+  local recent
+  recent=$(printf '%s\n' "$reversed" | head -n "$n")
+
+  echo -e "${BOLD}Peer Review Runs${NC}"
+  echo ""
+  printf "%-19s  %-8s  %-10s  %-5s  %-10s  %s\n" "Time" "From" "To" "Rnd" "Verdict" "Tag"
+  printf "%s\n" "───────────────────  ────────  ──────────  ─────  ──────────  ──────────"
+
+  while IFS= read -r line; do
+    [[ -z "$line" ]] && continue
+    local ts from to round verdict tag
+    ts=$(printf '%s' "$line" | jq -r '.ts // "—"')
+    from=$(printf '%s' "$line" | jq -r '.from // "—"')
+    to=$(printf '%s' "$line" | jq -r '.to // "—"')
+    round=$(printf '%s' "$line" | jq -r '.round // "—"')
+    verdict=$(printf '%s' "$line" | jq -r '.verdict // "—"')
+    tag=$(printf '%s' "$line" | jq -r '.tag // "—"')
+    printf "%-19s  %-8s  %-10s  %-5s  %-10s  %s\n" "$ts" "$from" "$to" "$round" "$verdict" "$tag"
+  done <<<"$recent"
+}
+
+# FIX-150a: `roll peer log` — show the latest peer review transcript.
+cmd_peer_log() {
+  local dir
+  dir=$(_peer_project_dir)
+  local latest
+  latest=$(ls "$dir/logs"/*.md 2>/dev/null | sort | tail -1 || true)
+  if [[ -z "$latest" || ! -f "$latest" ]]; then
+    echo "$(msg peer.no_peer_logs_found)"
+    return 0
+  fi
+  cat "$latest"
+}
+
 # ═══════════════════════════════════════════════════════════════════════════════
 # AGENT — per-project agent configuration
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -7615,6 +7732,84 @@ _loop_event_rotate() {
   fi
 }
 
+# FIX-151: write a lightweight tick heartbeat for dedicated loops (pr/ci/alert).
+# Appends one JSONL line per tick; rotates by line count to control bloat.
+_loop_write_tick() {
+  local loop_type="${1:-}" outcome="${2:-idle}" note="${3:-}"
+  [ -n "$loop_type" ] || return 0
+  local slug tick_file
+  slug=$(_project_slug 2>/dev/null || basename "$PWD")
+  local _rt_dir
+  _rt_dir=$(_loop_runtime_dir "$slug" 2>/dev/null || echo "")
+  if [ -n "$_rt_dir" ]; then
+    tick_file="${_rt_dir}/${loop_type}-tick.jsonl"
+  else
+    tick_file="${_SHARED_ROOT:-$HOME/.shared/roll}/loop/${loop_type}-tick-${slug}.jsonl"
+  fi
+  mkdir -p "$(dirname "$tick_file")" 2>/dev/null || true
+  local ts
+  ts=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+  printf '{"ts":"%s","loop":"%s","outcome":"%s","note":"%s"}\n' \
+    "$ts" "$loop_type" "$outcome" "$note" >> "$tick_file"
+
+  # Rotate: alert loop (1 min) → 1000 lines (~16h); ci/pr (5 min) → 500 lines (~42h)
+  local max_lines=500
+  [ "$loop_type" = "alert" ] && max_lines=1000
+  local line_count
+  line_count=$(wc -l < "$tick_file" 2>/dev/null | tr -d ' \t' || echo 0)
+  case "$line_count" in ''|*[!0-9]*) line_count=0 ;; esac
+  if [ "$line_count" -gt "$max_lines" ]; then
+    tail -n "$max_lines" "$tick_file" > "${tick_file}.tmp" && mv "${tick_file}.tmp" "$tick_file"
+  fi
+}
+
+# FIX-151: read the last tick line from a dedicated loop's tick file.
+# Optional second arg selects a JSON field (ts, loop, outcome, note).
+_loop_read_last_tick() {
+  local loop_type="${1:-}" field="${2:-}"
+  [ -n "$loop_type" ] || return 0
+  local slug tick_file
+  slug=$(_project_slug 2>/dev/null || basename "$PWD")
+  local _rt_dir
+  _rt_dir=$(_loop_runtime_dir "$slug" 2>/dev/null || echo "")
+  if [ -n "$_rt_dir" ]; then
+    tick_file="${_rt_dir}/${loop_type}-tick.jsonl"
+  else
+    tick_file="${_SHARED_ROOT:-$HOME/.shared/roll}/loop/${loop_type}-tick-${slug}.jsonl"
+  fi
+  [ -f "$tick_file" ] || return 0
+  local last
+  last=$(tail -1 "$tick_file" 2>/dev/null || echo "")
+  [ -n "$last" ] || return 0
+  if [ -n "$field" ]; then
+    echo "$last" | awk -F'"' '{for(i=2;i<NF;i+=2) if($i=="'"$field"'") {print $(i+2); exit}}' 2>/dev/null || echo ""
+  else
+    printf '%s\n' "$last"
+  fi
+}
+
+# FIX-151: compute human-readable age of the last tick for a dedicated loop.
+# Prints something like "5s", "3m", "2h" or empty string if no tick.
+_loop_tick_age() {
+  local loop_type="${1:-}"
+  [ -n "$loop_type" ] || return 0
+  local ts
+  ts=$(_loop_read_last_tick "$loop_type" "ts")
+  [ -n "$ts" ] || return 0
+  local tick_epoch now_epoch age
+  tick_epoch=$(date -d "$ts" +%s 2>/dev/null || date -jf "%Y-%m-%dT%H:%M:%SZ" "$ts" +%s 2>/dev/null || echo 0)
+  [ "$tick_epoch" -gt 0 ] || return 0
+  now_epoch=$(date +%s)
+  age=$(( now_epoch - tick_epoch ))
+  if [ "$age" -lt 60 ]; then
+    echo "${age}s"
+  elif [ "$age" -lt 3600 ]; then
+    echo "$(( age / 60 ))m"
+  else
+    echo "$(( age / 3600 ))h"
+  fi
+}
+
 # US-OBS-014: after a loop cycle reaches a terminal cycle_end (done or idle),
 # fire a best-effort, background status-snapshot push to roll-meta so the
 # remote-watch prompt always sees ≤35min-fresh data — no user-side cron needed.
@@ -9783,8 +9978,13 @@ _legacy_loop_status() {
         fi
         echo -e "    ${YELLOW}loop     ⏸ paused${NC}${_dur}   run: roll loop resume"
       else
+        local _tick_age=""
+        case "$svc" in pr|ci|alert)
+          _tick_age=$(_loop_tick_age "$svc")
+          [ -n "$_tick_age" ] && _tick_age="  tick ${_tick_age}"
+        esac
         case "$state" in
-          enabled)       echo -e "    ${GREEN}${svc}     ● enabled${NC}" ;;
+          enabled)       echo -e "    ${GREEN}${svc}     ● enabled${NC}${_tick_age}" ;;
           stale|installed-off) echo -e "    ${YELLOW}${svc}     ⚠ STALE — plist present but not loaded${NC}   run: roll loop on" ;;
           not-installed) echo -e "    ${RED}${svc}     ○ not installed${NC}   run: roll setup" ;;
         esac
@@ -11193,16 +11393,16 @@ _loop_pr_merge_self_eager() {
 #   Walks open PRs and routes each by classification.
 #   Lenient on gh unavailability — returns 0 so the loop continues to BACKLOG.
 _loop_pr_inbox() {
-  local slug; _gh_resolve slug || return 0
+  local slug; _gh_resolve slug || { _loop_write_tick "pr" "idle" "gh_unavailable"; return 0; }
   local prs_json
   prs_json=$(gh -R "$slug" pr list --state open \
     --json number,headRefName,author,title \
-    2>/dev/null) || return 0
-  [ -n "$prs_json" ] || return 0
-  [ "$prs_json" = "[]" ] && return 0
+    2>/dev/null) || { _loop_write_tick "pr" "idle" "gh_error"; return 0; }
+  [ -n "$prs_json" ] || { _loop_write_tick "pr" "idle" "empty_response"; return 0; }
+  [ "$prs_json" = "[]" ] && { _loop_write_tick "pr" "idle" "no_open_prs"; return 0; }
 
   local count; count=$(echo "$prs_json" | jq 'length' 2>/dev/null || echo 0)
-  [ "${count:-0}" -gt 0 ] || return 0
+  [ "${count:-0}" -gt 0 ] || { _loop_write_tick "pr" "idle" "zero_prs"; return 0; }
 
   local i=0
   while [ "$i" -lt "$count" ]; do
@@ -11270,6 +11470,7 @@ _loop_pr_inbox() {
 
     i=$((i + 1))
   done
+  _loop_write_tick "pr" "acted" "inbox_done"
   return 0
 }
 
@@ -11778,13 +11979,13 @@ _ci_detect_degradation() {
 #   accumulated history. Lenient on gh unavailability (missing / failed list →
 #   return 0) so the service never errors out a tick.
 _ci_scan() {
-  local slug; _gh_resolve slug 2>/dev/null || return 0
+  local slug; _gh_resolve slug 2>/dev/null || { _loop_write_tick "ci" "idle" "gh_unavailable"; return 0; }
 
   local runs_json
   runs_json=$(gh -R "$slug" run list --branch main \
     --json databaseId,workflowName,name,conclusion,status,createdAt,updatedAt \
-    2>/dev/null) || return 0
-  [ -n "$runs_json" ] || return 0
+    2>/dev/null) || { _loop_write_tick "ci" "idle" "gh_error"; return 0; }
+  [ -n "$runs_json" ] || { _loop_write_tick "ci" "idle" "empty_response"; return 0; }
 
   # An empty list ("[]") still falls through to the detectors below: they run
   # over accumulated history, not just this tick's runs.
@@ -11810,6 +12011,7 @@ _ci_scan() {
 
   _ci_detect_flaky
   _ci_detect_degradation
+  _loop_write_tick "ci" "acted" "scan_done"
   return 0
 }
 
@@ -11977,12 +12179,12 @@ _alert_rotate() {
 #   A missing/empty alert file is a no-op (no rotate, no log). Loop-safe.
 _alert_dispatch() {
   local file="${1:-$_LOOP_ALERT}"
-  [ -n "$file" ] && [ -f "$file" ] || return 0
+  [ -n "$file" ] && [ -f "$file" ] || { _loop_write_tick "alert" "idle" "no_file"; return 0; }
   # Empty file → nothing to consume, leave it in place.
-  [ -s "$file" ] || return 0
+  [ -s "$file" ] || { _loop_write_tick "alert" "idle" "empty_file"; return 0; }
 
   local parsed; parsed=$(_alert_parse_file "$file")
-  [ -n "$parsed" ] || { _alert_rotate "$file"; return 0; }
+  [ -n "$parsed" ] || { _alert_rotate "$file"; _loop_write_tick "alert" "idle" "no_parsed"; return 0; }
 
   local line ts level category message notify
   local _oifs="$IFS"
@@ -12008,6 +12210,7 @@ _alert_dispatch() {
   IFS="$_oifs"
 
   _alert_rotate "$file"
+  _loop_write_tick "alert" "acted" "dispatch_done"
   return 0
 }
 
@@ -14399,9 +14602,11 @@ _dash_refactor_pending() {
 
 # ② Peer layer: last result + days ago from peer log, empty if no log.
 _dash_last_peer() {
-  local peer_log_dir="${HOME}/.shared/roll/peer"
+  # FIX-150a: read from project-local peer logs (was ~/.shared/roll/peer/*.log).
+  local peer_log_dir
+  peer_log_dir=$(_peer_project_dir)/logs
   local latest
-  latest=$(ls "$peer_log_dir"/*.log 2>/dev/null | sort | tail -1 || true)
+  latest=$(ls "$peer_log_dir"/*.md 2>/dev/null | sort | tail -1 || true)
   [[ -z "$latest" || ! -f "$latest" ]] && return 0
   local result
   result=$(grep -oE '(AGREE|REFINE|OBJECT|ESCALATE)' "$latest" 2>/dev/null | tail -1 || true)

package/lib/i18n/peer.sh

@@ -32,3 +32,10 @@ _i18n_set en peer.en_peer_review "[EN:启动 peer review: %s → %s (第 %s 轮,
 _i18n_set zh peer.en_peer_review "启动 peer review: %s → %s (第 %s 轮, tag: %s)"
 _i18n_set en peer.en_enter_n "[EN:按 Enter 执行或输入 n 取消。%s 秒后自动执行......]"
 _i18n_set zh peer.en_enter_n "按 Enter 执行或输入 n 取消。%s 秒后自动执行..."
+
+_i18n_set en peer.no_peer_runs_yet "No peer review runs yet."
+_i18n_set zh peer.no_peer_runs_yet "还没有 peer review 记录。"
+_i18n_set en peer.no_peer_logs_found "No peer logs found."
+_i18n_set zh peer.no_peer_logs_found "还没有 peer 日志。"
+_i18n_set en peer.jq_required_for_roll_peer_runs "jq is required for 'roll peer runs'."
+_i18n_set zh peer.jq_required_for_roll_peer_runs "'roll peer runs' 需要安装 jq。"

package/lib/i18n/peer_help.sh

@@ -15,6 +15,10 @@ _i18n_set en peer_help.yes_yolo_skip_opt_out_prompt "  --yes, --yolo       Skip
 _i18n_set zh peer_help.yes_yolo_skip_opt_out_prompt "跳过确认提示"
 _i18n_set en peer_help.status_show_peer_review_state "  status              Show peer review state"
 _i18n_set zh peer_help.status_show_peer_review_state "显示状态"
+_i18n_set en peer_help.log_show_latest_peer_transcript "  log                 Show latest peer review transcript"
+_i18n_set zh peer_help.log_show_latest_peer_transcript "查看最新 peer 日志"
+_i18n_set en peer_help.runs_show_recent_peer_review_runs "  runs [N]            Show recent peer review runs"
+_i18n_set zh peer_help.runs_show_recent_peer_review_runs "查看最近 peer review 记录"
 _i18n_set en peer_help.reset_pair_all_reset_peer_state "  reset <pair|--all>  Reset peer state"
 _i18n_set zh peer_help.reset_pair_all_reset_peer_state "重置状态"
 _i18n_set en peer_help.help_show_this_help "  help                Show this help"

package/lib/roll-loop-status.py

@@ -162,7 +162,11 @@ def _resolve_project_path(slug: str) -> Optional[Path]:
 
 
 def _loop_runtime_dir_py(slug: str) -> Optional[Path]:
-    """Mirror bin/roll's _loop_runtime_dir: return <project>/.roll/loop."""
+    """Mirror bin/roll's _loop_runtime_dir: return <project>/.roll/loop.
+    Honors ROLL_PROJECT_RUNTIME_DIR env override (test sandbox)."""
+    env_rt = os.environ.get("ROLL_PROJECT_RUNTIME_DIR", "").strip()
+    if env_rt:
+        return Path(env_rt)
     proj = _resolve_project_path(slug)
     if proj is None:
         return None
@@ -1189,6 +1193,11 @@ def render(events, cron, state, backlog, *, days=3, lang="both", now=None,
         _sl = _daily_schedule_line(_svc, now=now)
         if _sl:
             print("  " + c("dim", _sl))
+    # FIX-151: dedicated loop (pr/ci/alert) last-tick age
+    for _loop in ("pr", "ci", "alert"):
+        _tl = _tick_age_line(_loop, now=now)
+        if _tl:
+            print("  " + c("dim", _tl))
     print()
 
     print(c("faint", "─" * COLS))
@@ -1436,6 +1445,42 @@ def _daily_schedule_line(svc: str, now: Optional[datetime] = None) -> Optional[s
     return f"{svc}: daily (legacy interval)"
 
 
+def _tick_age_line(loop_type: str, now: Optional[datetime] = None) -> Optional[str]:
+    """FIX-151: read the last tick for a dedicated loop (pr/ci/alert) and return
+    a human-readable age line, or None if no tick file exists."""
+    slug = project_slug()
+    rt_dir = _loop_runtime_dir_py(slug)
+    if rt_dir is not None:
+        tick_file = rt_dir / f"{loop_type}-tick.jsonl"
+    else:
+        tick_file = shared_root() / "loop" / f"{loop_type}-tick-{slug}.jsonl"
+    if not tick_file.exists():
+        return None
+    try:
+        last_line = tick_file.read_text().strip().splitlines()[-1]
+    except (IndexError, OSError):
+        return None
+    # Extract ts field from JSONL
+    m = re.search(r'"ts":"([^"]+)"', last_line)
+    if not m:
+        return None
+    ts_str = m.group(1)
+    try:
+        # Parse ISO 8601 UTC timestamp
+        tick_dt = datetime.strptime(ts_str, "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=timezone.utc)
+    except ValueError:
+        return None
+    base = now or datetime.now(timezone.utc)
+    age_sec = int((base - tick_dt).total_seconds())
+    if age_sec < 60:
+        age_str = f"{age_sec}s"
+    elif age_sec < 3600:
+        age_str = f"{age_sec // 60}m"
+    else:
+        age_str = f"{age_sec // 3600}h"
+    return f"{loop_type}: tick {age_str} ago"
+
+
 def _detect_install_state() -> str:
     """FIX-095 / FIX-098: classify the launchd install state of the loop service.
 

package/lib/roll-peer.py

@@ -99,7 +99,7 @@ _FIXTURE_VERDICT = {
     "reason":  "2 rounds · 5 turns · all blocks resolved",
 }
 
-_FIXTURE_ARTIFACT = "~/.roll/.peer-state/logs/20260519_213700_claude_codex.md"
+_FIXTURE_ARTIFACT = ".roll/peer/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"),

package/package.json

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

package/skills/roll-peer/SKILL.md

@@ -180,7 +180,7 @@ Running
 
 ### Per Peer Pair (e.g., kimi→claude)
 
-Stored in `~/.shared/roll/peer/state.yaml`:
+Stored in `~/.roll/.peer-state/` (flat key files per pair):
 
 ```yaml
 kimi→claude:
@@ -269,7 +269,7 @@ When peer review is manually triggered by a human (via `/peer`, "叫上 peer", e
 - Relay the peer's response **verbatim** before adding your own analysis.
 - After the peer's reply, the reviewer's own analysis block must explicitly state whether the peer's root cause and fix direction match the reviewer's own (independent) conclusion — that comparison is what determines the next round's action.
 - If a peer call fails or times out, report it immediately inline and either retry or ESCALATE.
-- Negotiation log is still written to `~/.shared/roll/peer/logs/` as usual.
+- Negotiation log is written to `<project>/.roll/peer/logs/` as usual.
 
 **Why inline, not tmux:** When a human manually triggers peer review inside an agent's interactive session, the conversation IS the visible interface. tmux auto-attach is only relevant for CLI-launched background sessions (`bin/roll peer`), not for skill invocations.
 
@@ -300,8 +300,9 @@ When Attacker and Defender reach a stalemate (both tests pass but interpretation
 
 ## Output Artifacts
 
-- **Negotiation log**: `~/.shared/roll/peer/logs/<timestamp>_<from>_<to>.md`
-- **State file**: `~/.shared/roll/peer/state.yaml`
+- **Negotiation log**: `<project>/.roll/peer/logs/<timestamp>_<from>_<to>.md`
+- **Structured record**: `<project>/.roll/peer/runs.jsonl`
+- **State file**: `~/.roll/.peer-state/`
 - **Decision record**: If AGREE, append summary to `docs/decisions/` or `.roll/backlog.md` (optional)
 
 ## Configuration
@@ -327,7 +328,7 @@ peer:
 
 ## Limitations
 
-1. **Reverse link reliability**: Direct CLI calls are preferred. Reliability varies by tool — see Peer Invocation Reference table. If a peer fails consistently, the adaptive streak tracker marks it `abandoned` and falls back to the next candidate. File mailbox (`~/.shared/roll/peer/mailbox/`) is the last-resort fallback.
+1. **Reverse link reliability**: Direct CLI calls are preferred. Reliability varies by tool — see Peer Invocation Reference table. If a peer fails consistently, the adaptive streak tracker marks it `abandoned` and falls back to the next candidate. File mailbox (`<project>/.roll/peer/mailbox/`) is the last-resort fallback.
    - `deepseek serve --http` is the most reliable option when available — prefer it over direct `deepseek` CLI invocation.
    - `codex exec` has known TTY/Ink issues in non-interactive environments; treat as low-priority fallback.
 2. **Cost**: Every peer review consumes tokens on both sides. Only trigger for tasks where the cost of a wrong decision exceeds the cost of peer review. DeepSeek is the most cost-effective peer for general use.