@seanyao/roll 2026.601.1 → 2026.601.3

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## v2026.601.3
+
+### 可见性
+
+- **kimi cycle 现在也能看到 token 和成本(FIX-154)** — 以前 dashboard 对 kimi 那一行全是 `—/—`,看不到主力 agent 花了多少钱;现在 cycle 跑完读 kimi-code 的 `wire.jsonl`,把 token 数和成本写进事件流,RECENT 视图和成本总闸都看得见 `[loop]`
+
+### 稳定性
+
+- **loop 把活派给 AI 后现在真会动手,不再空转零产出(FIX-152)** — kimi 等对话式 agent 拿到 SKILL.md 会把它当成"贴过来的文档"反问"What would you like me to do?",8 秒空返没交付;技能正文前置一条 agent 无关的自主执行指令,kimi/claude/pi/codex/agy 现在都会直接动手 `[loop]`
+- **agy 在 loop / cron 自动化里不再卡 tty 等待(FIX-153)** — antigravity(agy)默认要 tty 批准操作,自动化场景拿不到 tty 就一直挂着等;现在 headless 模式自动加 `-p` 和跳过权限标记,跑得到结果 `[loop]`
+- **测试不再在桌面弹空报错终端(FIX-155)** — bats 测试跑完临时沙箱删了,但 peer auto-attach 弹的 Terminal 窗口指向那个已不存在的路径,桌面堆一堆空报错的死窗口;给 peer 弹窗补上和 loop 弹窗一样的测试守卫,测试上下文不再弹 `[loop]`
+
+## 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.3"
 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"
@@ -3799,6 +3841,8 @@ _peer_route() {
 _peer_auto_attach() {
   local session="$1"
   [ "$(uname)" = "Darwin" ] || return 0
+  [ -n "${BATS_TEST_NUMBER:-}" ] && return 0
+  [ -n "${ROLL_LOOP_NO_POPUP:-}" ] && return 0
   [ -f "$_LOOP_MUTE_FILE" ] && return 0
   local attach_cmd="${_SHARED_ROOT}/loop/attach-${session}.command"
   # Drop `exec` so the wrapping shell survives `tmux attach` exiting; pause
@@ -3928,6 +3972,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 +3982,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 +4033,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 +4055,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 +4103,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 +4242,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
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -4294,10 +4413,12 @@ _agent_argv() {
       # late 2025. agy reuses ~/.gemini/ for config and reads GEMINI.md
       # natively, so the convention sync target is unchanged — only the
       # invoked binary changes.
+      # FIX-153: non-interactive modes must use -p (headless) +
+      # --dangerously-skip-permissions so the agent does not hang waiting
+      # for a tty approval that never comes in loop/cron contexts.
       case "$mode" in
         interactive) _AGENT_ARGV=(agy -i "$prompt") ;;
-        text|peer)   _AGENT_ARGV=(agy "$prompt") ;;
-        *)           _AGENT_ARGV=(agy "$prompt") ;;
+        *)           _AGENT_ARGV=(agy -p --dangerously-skip-permissions "$prompt") ;;
       esac ;;
     qwen)
       # qwen has the same argv shape in both modes (positional prompt).
@@ -7615,6 +7736,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.
@@ -7967,7 +8166,11 @@ _write_loop_runner_script() {
   # US-LOOP-026: post-cycle single-shot usage writer for non-claude agents.
   # pi -p text mode prints no usage, so we recover it from pi's session jsonl
   # exactly once per cycle (loop-fmt passthrough is display-only).
+  # FIX-154: kimi-code's `-p` mode also writes nothing to stdout but persists
+  # usage to wire.jsonl; kimi_emit covers that path. bin/roll dispatches by
+  # agent (pi/deepseek → pi_emit, kimi → kimi_emit).
   local pi_emit_script="${ROLL_PKG_DIR}/lib/agent_usage/pi_emit.py"
+  local kimi_emit_script="${ROLL_PKG_DIR}/lib/agent_usage/kimi_emit.py"
   local roll_bin="${ROLL_PKG_DIR}/bin/roll"
   # US-EVAL-002: pure-function rubric scorer (US-EVAL-001). Baked in at
   # generation time so the inner runner can compute result_eval at cycle finish.
@@ -8636,23 +8839,37 @@ else
   _phase_end agent_invoke ok
 fi
 
-# US-LOOP-026: non-claude agents (pi/deepseek/kimi) print no usage in -p text
-# mode. Recover token+cost once per cycle from the agent's session jsonl and
-# append a single authoritative usage event. Done here (not in loop-fmt's
-# per-attempt passthrough) so retries can't write N duplicate events that the
-# dashboard's same-label SUM would inflate. Runs before the timeout-abort exit
-# so partial cycles still get whatever usage the session recorded. The events
-# path is resolved exactly like _loop_event (rt_dir first, shared fallback) so
-# pi_emit appends to the same file the reader consumes.
-if [ "\$(_project_agent)" != "claude" ] && [ -f "${pi_emit_script}" ]; then
+# US-LOOP-026 + FIX-154: non-claude agents (pi/deepseek/kimi) print no usage
+# in -p text mode. Recover token+cost once per cycle from the agent's session
+# jsonl and append a single authoritative usage event. Done here (not in
+# loop-fmt's per-attempt passthrough) so retries can't write N duplicate
+# events that the dashboard's same-label SUM would inflate. Runs before the
+# timeout-abort exit so partial cycles still get whatever usage the session
+# recorded. The events path is resolved exactly like _loop_event (rt_dir
+# first, shared fallback) so the emitter appends to the same file the reader
+# consumes. Dispatch by agent so each emitter reads the right session format
+# (pi.usage_from_session vs kimi.usage_from_session).
+if [ "\$(_project_agent)" != "claude" ]; then
   _pi_rt=\$(_loop_runtime_dir "${slug}" 2>/dev/null || echo "")
   if [ -n "\$_pi_rt" ]; then
     _pi_evfile="\${_pi_rt}/events.ndjson"
   else
     _pi_evfile="\${_SHARED_ROOT:-\$HOME/.shared/roll}/loop/events-${slug}.ndjson"
   fi
-  python3 "${pi_emit_script}" --cwd "\$WT" --cycle "\${CYCLE_ID}" \\
-    --slug "${slug}" --events "\$_pi_evfile" 2>/dev/null || true
+  case "\$(_project_agent)" in
+    kimi)
+      if [ -f "${kimi_emit_script}" ]; then
+        python3 "${kimi_emit_script}" --cwd "\$WT" --cycle "\${CYCLE_ID}" \\
+          --slug "${slug}" --events "\$_pi_evfile" 2>/dev/null || true
+      fi
+      ;;
+    *)
+      if [ -f "${pi_emit_script}" ]; then
+        python3 "${pi_emit_script}" --cwd "\$WT" --cycle "\${CYCLE_ID}" \\
+          --slug "${slug}" --events "\$_pi_evfile" 2>/dev/null || true
+      fi
+      ;;
+  esac
 fi
 
 # FIX-057: timed out — skip publish; EXIT trap writes cycle_end blocked + ALERT.
@@ -9228,7 +9445,15 @@ _agent_skill_cmd() {
   for ((i = 1; i < prompt_idx; i++)); do
     out+=" ${_AGENT_ARGV[i]}"
   done
-  echo "${out} \"\$(${strip})\""
+  # FIX-152: prepend an explicit autonomous-execution directive ahead of the bare
+  # SKILL.md body. Without it, conversational `-p` agents (notably kimi-code) read
+  # the skill doc as pasted context and reply "what would you like me to do?",
+  # returning in seconds with zero output → the cycle ends idle, no delivery.
+  # pi/deepseek/claude tolerate the bare doc, but the directive is agent-agnostic
+  # and hardens every autonomous cron skill (loop/dream/brief share this chokepoint).
+  # Must stay free of " $ ` \ so it survives the later `eval` of the cycle command.
+  local _autorun='[roll 自主模式] 你正在无人值守的自动化循环中运行,这不是对话。请立即、完整地执行下面这份技能文档描述的工作流,直到完成交付或写出 ALERT 为止;严禁反问、严禁等待确认、严禁只复述或总结而不动手。技能文档如下: '
+  echo "${out} \"${_autorun}\$(${strip})\""
 }
 
 # FIX-134: build the full per-cycle agent command at RUNTIME, routing-aware.
@@ -9783,8 +10008,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 +11423,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 +11500,7 @@ _loop_pr_inbox() {
 
     i=$((i + 1))
   done
+  _loop_write_tick "pr" "acted" "inbox_done"
   return 0
 }
 
@@ -11778,13 +12009,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 +12041,7 @@ _ci_scan() {
 
   _ci_detect_flaky
   _ci_detect_degradation
+  _loop_write_tick "ci" "acted" "scan_done"
   return 0
 }
 
@@ -11977,12 +12209,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 +12240,7 @@ _alert_dispatch() {
   IFS="$_oifs"
 
   _alert_rotate "$file"
+  _loop_write_tick "alert" "acted" "dispatch_done"
   return 0
 }
 
@@ -14399,9 +14632,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/agent_usage/kimi.py

@@ -1,29 +1,33 @@
 """
 kimi (Moonshot Kimi CLI) agent usage extractor.
 
-Like openai and gemini (and unlike pi, which persists usage to session
-files), the Kimi CLI prints a token-usage summary to stdout at the end of a
-session.  So this plugin implements the standard ``extract()`` registry
-contract: scrape the passthrough stdout lines for the usage / model lines.
+Two paths are supported, mirroring pi.py:
 
-Recognised lines (case-insensitive, robust to thousands separators)::
+1. ``extract()`` — the registry stdout-scrape contract, kept for legacy
+   callers (and as a fallback when session files are absent).
+2. ``usage_from_session()`` — authoritative recovery from kimi-code's
+   persisted session files at ``~/.kimi-code/sessions/wd_*/session_*/agents/main/wire.jsonl``.
+   Each wire file is NDJSON with one or more ``{"type":"usage.record","model":...,"usage":{...}}``
+   lines whose token fields are summed per cycle.
 
-    Model: kimi-k2
-    Tokens: input=15300 output=3120
+FIX-154 added the session path so loop cycles run by kimi-code (the
+default agent today) no longer show ``—/—`` for tokens and cost in the
+RECENT dashboard.
 
-The Kimi CLI's "usage" / session-summary block is also accepted::
+The stdout-scrape contract still recognises (case-insensitive)::
 
+    Model: kimi-k2
+    Tokens: input=15300 output=3120
     Input tokens:  15,300
     Output tokens:  3,120
     Total tokens:  18,420
-    model: kimi-k2
 
 When an explicit USD cost line isn't present, cost is computed from
-``lib/model_prices.py`` (list price) so the dashboard never shows ``—``
-for a recognised kimi cycle.  Returns None if no usage line is found,
-so the caller falls back to the null payload (US-LOOP-010 compatible).
+``lib/model_prices.py`` (list price).
 """
 
+import glob
+import json
 import os
 import re
 import sys
@@ -125,3 +129,150 @@ def extract(stdin_lines: list[str]) -> Optional[dict]:
         "cost_list_usd": cost,
         "duration_ms": None,
     }
+
+
+# ── Session-file extraction (authoritative, FIX-154) ───────────────────────
+
+# kimi-code persists every CLI session under
+# ``~/.kimi-code/sessions/wd_<cwd-basename>_<8-hex>/session_<uuid>/agents/main/wire.jsonl``
+# where ``<cwd-basename>`` is the basename of the cycle's worktree
+# (e.g. ``roll-ecf079-cycle-20260601-170905-54957``).
+# Each wire file is NDJSON; one or more lines have::
+#
+#     {"type": "usage.record", "model": "kimi-code/kimi-for-coding",
+#      "usage": {"inputOther": <int>, "output": <int>,
+#                "inputCacheRead": <int>, "inputCacheCreation": <int>},
+#      "usageScope": "turn", "time": <ms>}
+#
+# We sum across all matching wire files (retries reuse the same worktree).
+
+
+def _kimi_sessions_base_dir(base_dir: Optional[str]) -> str:
+    """Resolve kimi-code's sessions root: arg → env → default."""
+    return (
+        base_dir
+        or os.environ.get("ROLL_KIMI_SESSIONS_DIR")
+        or os.path.expanduser("~/.kimi-code/sessions")
+    )
+
+
+def _sum_wire_file(path: str) -> Optional[dict]:
+    """Sum ``usage.record`` lines in a single kimi wire.jsonl.
+
+    Returns a usage dict or None when no usage records are found.
+    Field mapping kimi → roll::
+
+        inputOther         → input_tokens
+        output             → output_tokens
+        inputCacheRead     → cache_read_tokens
+        inputCacheCreation → cache_creation_tokens
+    """
+    tin = tout = tcr = tcw = 0
+    model = None
+    seen = False
+    try:
+        with open(path) as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    o = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                if o.get("type") != "usage.record":
+                    continue
+                u = o.get("usage") or {}
+                seen = True
+                if o.get("model"):
+                    model = o["model"]
+                tin += int(u.get("inputOther") or 0)
+                tout += int(u.get("output") or 0)
+                tcr += int(u.get("inputCacheRead") or 0)
+                tcw += int(u.get("inputCacheCreation") or 0)
+    except OSError:
+        return None
+    if not seen:
+        return None
+    return {
+        "model": model or _DEFAULT_MODEL,
+        "input_tokens": tin,
+        "output_tokens": tout,
+        "cache_creation_tokens": tcw,
+        "cache_read_tokens": tcr,
+        "duration_ms": None,
+    }
+
+
+def usage_from_session(
+    cwd: Optional[str] = None,
+    cycle_id: Optional[str] = None,
+    slug: Optional[str] = None,
+    base_dir: Optional[str] = None,
+) -> Optional[dict]:
+    """Recover a kimi cycle's usage by reading its persisted wire file(s).
+
+    Matching: scan ``<base>/wd_*/session_*/agents/main/wire.jsonl`` and
+    select files whose ``wd_*`` directory name contains the worktree
+    basename (authoritative when ``cwd`` is given) or the ``cycle_id``
+    substring (fallback).
+
+    Retries can produce multiple wire files for the same cycle; their
+    usage is SUMMED so token totals reflect retry work too.
+
+    Returns the merged usage dict (tokens + model), or None when nothing
+    matches / zero tokens — caller writes nothing in that case, preserving
+    "n/a, not fake zero".
+    """
+    base = _kimi_sessions_base_dir(base_dir)
+    files = sorted(glob.glob(
+        os.path.join(base, "wd_*", "session_*", "agents", "main", "wire.jsonl")
+    ))
+    if not files:
+        return None
+
+    cwd_basename = os.path.basename(cwd.rstrip("/")) if cwd else None
+    matched = []
+    for path in files:
+        # Session dir name: wd_<cwd-basename>_<8-hex>
+        # Path: <base>/wd_<cwd-basename>_<hash>/session_<uuid>/agents/main/wire.jsonl
+        wd_seg = path[len(base):].lstrip(os.sep).split(os.sep, 1)[0]
+        if cwd_basename and ("wd_%s_" % cwd_basename) in (wd_seg + "_"):
+            matched.append(path)
+            continue
+        if cycle_id and ("cycle-%s" % cycle_id) in wd_seg:
+            matched.append(path)
+
+    if not matched:
+        return None
+
+    agg = {
+        "model": None,
+        "input_tokens": 0,
+        "output_tokens": 0,
+        "cache_creation_tokens": 0,
+        "cache_read_tokens": 0,
+        "duration_ms": None,
+    }
+    got = False
+    for path in matched:
+        s = _sum_wire_file(path)
+        if s is None:
+            continue
+        got = True
+        agg["model"] = agg["model"] or s["model"]
+        agg["input_tokens"] += s["input_tokens"]
+        agg["output_tokens"] += s["output_tokens"]
+        agg["cache_creation_tokens"] += s["cache_creation_tokens"]
+        agg["cache_read_tokens"] += s["cache_read_tokens"]
+
+    if not got:
+        return None
+    has_tokens = (
+        agg["input_tokens"] or agg["output_tokens"]
+        or agg["cache_creation_tokens"] or agg["cache_read_tokens"]
+    )
+    if not has_tokens:
+        return None
+    agg["model"] = agg["model"] or _DEFAULT_MODEL
+    return agg

package/lib/agent_usage/kimi_emit.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+"""
+kimi_emit — write ONE authoritative usage event for a finished kimi cycle.
+
+Mirror of ``pi_emit.py``: invoked once by bin/roll after the agent phase
+when ROLL_LOOP_AGENT == "kimi". Recovers the cycle's real usage from
+kimi-code's persisted ``wire.jsonl`` files via ``kimi.usage_from_session``
+and appends a single ``stage=="usage"`` event to the loop events file.
+
+Exactly one event per cycle — the dashboard SUMS token fields across
+same-label usage events, so a per-retry write path would inflate ×N.
+
+Cost is frozen at the active price snapshot via
+``model_prices.compute_list_cost`` in the model's native currency.
+
+When ``usage_from_session`` finds nothing (no matching session, zero
+tokens) we write nothing — preserving "show n/a, not a fake zero".
+"""
+
+import argparse
+import importlib.util
+import json
+import os
+import sys
+from datetime import datetime, timezone
+
+_THIS_DIR = os.path.dirname(os.path.abspath(__file__))
+_LIB_DIR = os.path.dirname(_THIS_DIR)
+
+
+def _load_model_prices():
+    spec = importlib.util.spec_from_file_location(
+        "model_prices", os.path.join(_LIB_DIR, "model_prices.py")
+    )
+    mp = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mp)
+    return mp
+
+
+def _load_kimi():
+    spec = importlib.util.spec_from_file_location(
+        "agent_usage_kimi", os.path.join(_THIS_DIR, "kimi.py")
+    )
+    kimi = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(kimi)
+    return kimi
+
+
+def build_event(cwd=None, cycle_id=None, slug=None, base_dir=None):
+    """Return the (line dict) usage event for a kimi cycle, or None to skip."""
+    kimi = _load_kimi()
+    u = kimi.usage_from_session(
+        cwd=cwd, cycle_id=cycle_id, slug=slug, base_dir=base_dir
+    )
+    if u is None:
+        return None
+
+    mp = _load_model_prices()
+    model = u.get("model") or "kimi-k2.5"
+    totals = {
+        "input_tokens": int(u.get("input_tokens") or 0),
+        "output_tokens": int(u.get("output_tokens") or 0),
+        "cache_creation_tokens": int(u.get("cache_creation_tokens") or 0),
+        "cache_read_tokens": int(u.get("cache_read_tokens") or 0),
+    }
+    cost_list = mp.compute_list_cost(model, **totals)
+    currency = mp.currency_for(model)
+
+    payload = {
+        "model": model,
+        "input_tokens": totals["input_tokens"],
+        "output_tokens": totals["output_tokens"],
+        "cache_creation_tokens": totals["cache_creation_tokens"],
+        "cache_read_tokens": totals["cache_read_tokens"],
+        "duration_ms": u.get("duration_ms"),
+        "cost_list_usd": cost_list,
+        "cost_currency": currency,
+        "prices_version": getattr(mp, "VERSION", None),
+    }
+    return {
+        "ts": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "stage": "usage",
+        "label": cycle_id,
+        "detail": payload,
+        "outcome": "ok",
+    }
+
+
+def _default_events_path(slug, shared):
+    base = shared or os.environ.get("LOOP_SHARED_ROOT") \
+        or os.path.expanduser("~/.shared/roll")
+    return os.path.join(base, "loop", "events-%s.ndjson" % slug)
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(description="emit one kimi usage event")
+    ap.add_argument("--cwd", help="cycle worktree path (authoritative match)")
+    ap.add_argument("--cycle", help="cycle id (label + dir-name fallback)")
+    ap.add_argument("--slug", help="project slug (events filename)")
+    ap.add_argument("--shared", help="shared root (for default events path)")
+    ap.add_argument("--events", help="explicit events file path (preferred)")
+    ap.add_argument("--base-dir", help="kimi sessions root override (tests)")
+    args = ap.parse_args(argv)
+
+    event = build_event(
+        cwd=args.cwd, cycle_id=args.cycle, slug=args.slug, base_dir=args.base_dir
+    )
+    if event is None:
+        return 0  # nothing recoverable — write nothing (n/a, not fake zero)
+
+    evfile = args.events or _default_events_path(args.slug, args.shared)
+    try:
+        os.makedirs(os.path.dirname(evfile), exist_ok=True)
+        with open(evfile, "a") as f:
+            f.write(json.dumps(event) + "\n")
+    except OSError as e:
+        print("[kimi_emit] failed to write %s: %s" % (evfile, e), file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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.3",
   "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.