@seanyao/roll 2026.512.7 → 2026.513.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.512.7"
+VERSION="2026.513.1"
 ROLL_HOME="${ROLL_HOME:-${HOME}/.roll}"
 ROLL_CONFIG="${ROLL_HOME}/config.yaml"
 ROLL_GLOBAL="${ROLL_HOME}/conventions/global"
@@ -1437,7 +1437,7 @@ _peer_auto_attach() {
   fi
   local launched=0
   if [[ "$terminal_pref" = "ghostty" || "$terminal_pref" = "Ghostty" ]]; then
-    open -na Ghostty.app --args -e "tmux attach -t $session" >/dev/null 2>&1 && launched=1 || true
+    open -na Ghostty.app --args -e tmux attach -t "$session" >/dev/null 2>&1 && launched=1 || true
   fi
   if [[ $launched -eq 0 ]] && { [[ "$terminal_pref" = "iTerm2" || "$terminal_pref" = "iTerm" ]] || [[ -d "/Applications/iTerm.app" ]]; }; then
     osascript \
@@ -1447,7 +1447,7 @@ _peer_auto_attach() {
       && launched=1 || true
   fi
   if [[ $launched -eq 0 ]] && [[ -d "/Applications/Ghostty.app" ]]; then
-    open -na Ghostty.app --args -e "tmux attach -t $session" >/dev/null 2>&1 && launched=1 || true
+    open -na Ghostty.app --args -e tmux attach -t "$session" >/dev/null 2>&1 && launched=1 || true
   fi
   if [[ $launched -eq 0 ]] && command -v osascript >/dev/null 2>&1; then
     osascript \
@@ -1666,6 +1666,8 @@ cmd_peer() {
     peer_session="roll-peer-${from_tool}-${to_tool}"
     if ! tmux has-session -t "$peer_session" 2>/dev/null; then
       tmux new-session -d -s "$peer_session" -x 200 -y 50
+    fi
+    if [ -z "$(tmux list-clients -t "$peer_session" 2>/dev/null)" ]; then
       _peer_auto_attach "$peer_session"
     fi
   fi
@@ -1707,7 +1709,7 @@ cmd_peer() {
 
   printf '%s\n' "$response" >> "$log_file"
 
-  local resolution
+  local resolution=""
   resolution="$(_peer_parse_resolution "$response")"
 
   if [[ -z "$resolution" ]]; then
@@ -1732,7 +1734,7 @@ cmd_peer() {
       if [[ "$round" -ge 3 ]]; then
         warn "Max rounds reached. Escalating to user.  达到最大轮数，升级给用户。"
       else
-        info "Peer requests $resolution. Continue to round $((round + 1)).  Peer 请求 $resolution，继续第 $((round + 1)) 轮。"
+        info "Peer requests ${resolution}. Continue to round $((round + 1)).  Peer 请求 ${resolution}，继续第 $((round + 1)) 轮。"
       fi
       ;;
     ESCALATE|UNKNOWN)
@@ -2046,17 +2048,67 @@ _write_loop_runner_script() {
   # Use stream-json + formatter: --verbose alone does nothing in -p mode;
   # stream-json enables realtime streaming; loop-fmt.py humanizes the events.
   local fmt_script="${ROLL_PKG_DIR}/lib/loop-fmt.py"
+  local roll_bin="${ROLL_PKG_DIR}/bin/roll"
   local cmd_verbose="${cmd/claude -p/claude -p --verbose --output-format stream-json}"
+  # US-AUTO-037: strip leading `cd "<path>" && ` (callers like
+  # _install_launchd_plists prepend it). The runner now manages cwd itself
+  # — pointing at the worktree when isolation succeeds, project_path otherwise.
+  local claude_cmd; claude_cmd="${cmd_verbose#cd \"*\" && }"
+  local slug; slug=$(_project_slug "$project_path")
   cat > "$inner_path" << INNER
 #!/bin/bash -l
 set -o pipefail
 export PATH="/opt/homebrew/bin:\$PATH"
+# FIX-031: inner-level LOCK (PID + start-ts) — outer runner.sh LOCK can be
+# bypassed (recovery / retry / direct invocation); this guards the actual
+# claude invocation so a second session can't run under the same project.
+INNER_LOCK="\$(dirname "\$0")/.INNER-LOCK-\$(basename "\$0" -inner.sh | sed 's/^run-//')"
+if [ -f "\$INNER_LOCK" ]; then
+  _prev_pid=""; _prev_ts=""
+  IFS=: read -r _prev_pid _prev_ts < "\$INNER_LOCK" 2>/dev/null || true
+  _now=\$(date -u +%s)
+  if [ -n "\$_prev_pid" ] && [ -n "\$_prev_ts" ] \\
+     && kill -0 "\$_prev_pid" 2>/dev/null \\
+     && [ "\$((_now - _prev_ts))" -lt 14400 ]; then
+    echo "[\$(date '+%Y-%m-%dT%H:%M:%S%z')] inner loop already running (PID \$_prev_pid), skipping"
+    exit 0
+  fi
+  rm -f "\$INNER_LOCK"
+fi
+printf '%s:%s\n' "\$\$" "\$(date -u +%s)" > "\$INNER_LOCK"
+trap 'rm -f "\$INNER_LOCK"' EXIT
+
+# US-AUTO-037: pull in worktree helpers (US-AUTO-036). Sourcing bin/roll is
+# safe — its main() only runs when invoked directly (BASH_SOURCE == \$0).
+# bin/roll's top-level \`set -euo pipefail\` infects us, so disable -e (the
+# retry loop relies on tolerating non-zero exits) while keeping pipefail.
+source "${roll_bin}"
+set +e
+
+# Pre-claude: try to create a per-cycle isolated worktree on origin/main.
+# On any failure (no remote, no main, etc.) fall back to running in the
+# project's main tree (degraded — no isolation, like pre-037 behavior).
+CYCLE_ID="\$(date -u +%Y%m%d-%H%M%S)-\$\$"
+WT="\$(_worktree_path "${slug}" "cycle-\${CYCLE_ID}")"
+BRANCH="loop/cycle-\${CYCLE_ID}"
+_USE_WORKTREE=0
+cd "${project_path}" 2>/dev/null || true
+if _worktree_fetch_origin main \\
+   && _worktree_create "\$WT" "\$BRANCH" "origin/main"; then
+  _USE_WORKTREE=1
+  _worktree_submodule_init "\$WT" 2>/dev/null || true
+  echo "[loop] cycle \${CYCLE_ID}: worktree \$WT on \$BRANCH"
+else
+  echo "[loop] cycle \${CYCLE_ID}: worktree setup failed; running in main tree (no isolation)"
+  WT="${project_path}"
+fi
+
 FMT="${fmt_script}"
 for _attempt in 1 2 3; do
   if [ -f "\$FMT" ]; then
-    ( cd "${project_path}" && ${cmd_verbose} ) | python3 "\$FMT"
+    ( cd "\$WT" && ${claude_cmd} ) | python3 "\$FMT"
   else
-    ( cd "${project_path}" && ${cmd_verbose} )
+    ( cd "\$WT" && ${claude_cmd} )
   fi
   _exit=\$?
   [ "\$_exit" -eq 0 ] && break
@@ -2065,10 +2117,25 @@ for _attempt in 1 2 3; do
     sleep 30
   fi
 done
+
+# Post-claude: merge back if we used an isolated worktree.
+if [ "\$_USE_WORKTREE" = "1" ]; then
+  if [ "\$_exit" -eq 0 ]; then
+    if ( cd "${project_path}" && _worktree_merge_back "\$BRANCH" ); then
+      _worktree_cleanup "\$WT" "\$BRANCH"
+      echo "[loop] cycle \${CYCLE_ID}: merged and cleaned up"
+    else
+      _worktree_alert "cycle \${CYCLE_ID}: merge_back failed; worktree preserved at \$WT (branch \$BRANCH)"
+      echo "[loop] cycle \${CYCLE_ID}: merge_back failed; worktree preserved at \$WT"
+    fi
+  else
+    _worktree_alert "cycle \${CYCLE_ID}: claude exited \$_exit; worktree preserved at \$WT (branch \$BRANCH)"
+    echo "[loop] cycle \${CYCLE_ID}: claude failed (exit \$_exit); worktree preserved at \$WT"
+  fi
+fi
 INNER
   chmod +x "$inner_path"
 
-  local slug; slug=$(_project_slug "$project_path")
   cat > "$script_path" << SCRIPT
 #!/bin/bash -l
 # Active-window check — skipped when ROLL_LOOP_FORCE is set (manual 'roll loop now')
@@ -2218,8 +2285,13 @@ _install_launchd_plists() {
     if [[ "$before" != "$after" ]]; then
       updated=$((updated + 1))
       if _launchd_is_loaded "$label"; then
-        launchctl unload "$plist" 2>/dev/null || true
-        launchctl load "$plist" 2>/dev/null || true
+        # FIX-027: use bootout/bootstrap so we don't disturb the label's
+        # enabled flag in the launchd overrides db (which legacy
+        # unload/load no-`-w` wipes on macOS Sonoma+, causing
+        # `roll loop status` to falsely report off after `roll update`).
+        local uid; uid=$(id -u)
+        launchctl bootout "gui/${uid}/${label}" 2>/dev/null || true
+        launchctl bootstrap "gui/${uid}" "$plist" 2>/dev/null || true
       fi
     fi
   done
@@ -2595,11 +2667,12 @@ _loop_runs_dur() {
 }
 
 # Format a single JSONL run record for display.
+# Reads _LOOP_RUNS_BACKLOG global for ID→description lookup (set by _loop_runs).
 _loop_runs_format_line() {
-  local line="$1" show_project="$2"
+  local line="$1" show_project="$2" is_darwin="$3"
   command -v jq >/dev/null 2>&1 || { echo "  (jq required)"; return 0; }
 
-  local ts status project tcr duration alerts run_id reason built_count built_csv skipped_count
+  local ts status project tcr duration alerts run_id reason built_count skipped_count
   ts=$(jq -r '.ts // ""' <<<"$line")
   status=$(jq -r '.status // ""' <<<"$line")
   project=$(jq -r '.project // ""' <<<"$line")
@@ -2609,10 +2682,16 @@ _loop_runs_format_line() {
   run_id=$(jq -r '.run_id // ""' <<<"$line")
   reason=$(jq -r '.reason // ""' <<<"$line")
   built_count=$(jq -r '(.built // []) | length' <<<"$line")
-  built_csv=$(jq -r '(.built // []) | join(", ")' <<<"$line")
   skipped_count=$(jq -r '(.skipped // []) | length' <<<"$line")
 
-  local hhmm; hhmm=$(printf "%s" "$ts" | sed -E 's/.*T([0-9]{2}):([0-9]{2}).*/\1:\2/')
+  local hhmm epoch=""
+  if [[ "$is_darwin" == "1" ]]; then
+    epoch=$(date -j -u -f "%Y-%m-%dT%H:%M:%SZ" "$ts" "+%s" 2>/dev/null) || epoch=""
+    [[ -n "$epoch" ]] && hhmm=$(date -j -f "%s" "$epoch" "+%H:%M" 2>/dev/null) || hhmm=""
+  else
+    hhmm=$(date -d "$ts" "+%H:%M" 2>/dev/null) || hhmm=""
+  fi
+  [[ -z "$hhmm" ]] && hhmm=$(printf "%s" "$ts" | sed -E 's/.*T([0-9]{2}):([0-9]{2}).*/\1:\2/')
   local prefix=""
   if [[ "$show_project" == "true" ]]; then
     prefix="[$(basename "$project")] "
@@ -2622,8 +2701,29 @@ _loop_runs_format_line() {
     built)
       local skipped_note=""
       [[ "$skipped_count" -gt 0 ]] && skipped_note=", ${skipped_count} skipped"
-      printf "  %s  %s✅ built %s  (%d items, %d tcr%s, %s)\n" \
-        "$hhmm" "$prefix" "$built_csv" "$built_count" "$tcr" "$skipped_note" "$(_loop_runs_dur "$duration")"
+      local items_word; [[ "$built_count" -eq 1 ]] && items_word="item" || items_word="items"
+      printf "  %s  %s✅ built %d %s (%d tcr%s, %s)\n" \
+        "$hhmm" "$prefix" "$built_count" "$items_word" "$tcr" "$skipped_note" "$(_loop_runs_dur "$duration")"
+      local id desc
+      while IFS= read -r id; do
+        [[ -z "$id" ]] && continue
+        desc=""
+        if [[ -n "$_LOOP_RUNS_BACKLOG" ]]; then
+          desc=$(printf "%s\n" "$_LOOP_RUNS_BACKLOG" | awk -F'|' -v id="$id" '
+            NF >= 3 {
+              cell = $2; gsub(/^[[:space:]]+|[[:space:]]+$/, "", cell)
+              if (cell == id || cell ~ "^\\[" id "\\]") {
+                gsub(/^[[:space:]]+|[[:space:]]+$/, "", $3); print $3; exit
+              }
+            }')
+        fi
+        if [[ -n "$desc" ]]; then
+          [[ ${#desc} -gt 72 ]] && desc="${desc:0:69}..."
+          printf "    • %-14s %s\n" "$id" "$desc"
+        else
+          printf "    • %s\n" "$id"
+        fi
+      done < <(jq -r '(.built // []) | .[]' <<<"$line")
       ;;
     idle)
       printf "  %s  %s○ idle — no Todo items\n" "$hhmm" "$prefix"
@@ -2676,10 +2776,17 @@ _loop_runs() {
   local reversed; reversed=$(printf "%s\n" "$filtered" | awk '{a[NR]=$0} END{for(i=NR; i>=1; i--) print a[i]}')
   local recent; recent=$(printf "%s\n" "$reversed" | head -n "$n")
 
+  local _is_darwin=""
+  [[ "$(uname)" == "Darwin" ]] && _is_darwin="1"
+
+  _LOOP_RUNS_BACKLOG=""
+  [[ -f "$project_path/BACKLOG.md" ]] && _LOOP_RUNS_BACKLOG=$(cat "$project_path/BACKLOG.md")
+
   while IFS= read -r line; do
     [[ -z "$line" ]] && continue
-    _loop_runs_format_line "$line" "$all_flag"
+    _loop_runs_format_line "$line" "$all_flag" "$_is_darwin"
   done <<<"$recent"
+  unset _LOOP_RUNS_BACKLOG
 }
 
 # Send a macOS system notification. No-op when muted, non-macOS, or osascript unavailable.
@@ -2699,9 +2806,27 @@ _loop_tcr_count() {
     | awk '/^[a-f0-9]+ tcr:/{n++} END{print n+0}'
 }
 
+# Parse origin remote URL → "owner/repo" for GitHub repos.
+# Returns non-zero if no origin, or origin is not github.com.
+# Decoupled from `gh` auto-detection so SSH config host rewrites don't break it.
+_gh_repo_slug() {
+  local url
+  url=$(git config --get remote.origin.url 2>/dev/null) || return 1
+  case "$url" in
+    git@github.com:*)          url="${url#git@github.com:}" ;;
+    ssh://git@github.com/*)    url="${url#ssh://git@github.com/}" ;;
+    https://github.com/*)      url="${url#https://github.com/}" ;;
+    http://github.com/*)       url="${url#http://github.com/}" ;;
+    *)                         return 1 ;;
+  esac
+  url="${url%.git}"
+  [[ -z "$url" ]] && return 1
+  printf "%s\n" "$url"
+}
+
 # Poll gh run list until current commit's CI completes.
-# Returns 0 on success or when gh is unavailable (graceful skip).
-# Returns 1 on CI failure or timeout.
+# Returns 0 on success (or when gh binary missing — graceful skip).
+# Returns 1 on CI failure, timeout, or any gh call failure.
 _ci_wait() {
   local timeout="${1:-300}"
   local interval=15
@@ -2712,13 +2837,20 @@ _ci_wait() {
   local commit; commit=$(git rev-parse HEAD 2>/dev/null) || { err "Not a git repo  非 git 仓库"; return 1; }
   local short; short=$(git rev-parse --short HEAD 2>/dev/null)
 
-  ok "Waiting for CI on ${short}  等待 CI: ${short}"
+  # Resolve owner/repo from git remote so we don't depend on gh's auto-detection,
+  # which breaks when ~/.ssh/config rewrites `Host github.com` → IP address.
+  local repo_slug; repo_slug=$(_gh_repo_slug) || {
+    err "Cannot determine GitHub repo from origin remote  无法从 origin 推导 GitHub 仓库"
+    return 1
+  }
+
+  ok "Waiting for CI on ${short} (${repo_slug})  等待 CI: ${short}"
 
   while (( elapsed < timeout )); do
     local runs
-    runs=$(gh run list --commit "$commit" --json status,conclusion 2>/dev/null) || {
-      warn "gh run list failed — skipping CI gate"
-      return 0
+    runs=$(gh -R "$repo_slug" run list --commit "$commit" --json status,conclusion 2>&1) || {
+      err "gh run list failed for ${repo_slug}@${short}: ${runs}  gh 调用失败"
+      return 1
     }
 
     if [[ -z "$runs" || "$runs" == "[]" ]]; then
@@ -2754,6 +2886,46 @@ _ci_wait() {
   return 1
 }
 
+# Pre-run CI health check — call before picking up new stories.
+# Refuses to build on a red base (HEAD CI failed). Lenient on unknown states
+# (gh missing, repo unparseable, no runs yet) — the post-build _loop_enforce_ci
+# is the strict gate.
+# Returns 0: ok to proceed (green / pending / unknown / no gh).
+# Returns 1: HEAD CI is definitively red → ALERT written, do not build.
+_loop_precheck_ci() {
+  command -v gh &>/dev/null || return 0
+
+  local commit; commit=$(git rev-parse HEAD 2>/dev/null) || return 0
+  local slug; slug=$(_gh_repo_slug) || return 0
+
+  local runs
+  runs=$(gh -R "$slug" run list --commit "$commit" --json conclusion 2>/dev/null) || return 0
+  [[ -z "$runs" || "$runs" == "[]" ]] && return 0
+
+  local failed
+  failed=$(echo "$runs" | jq -r '[.[] | select(.conclusion != null and .conclusion != "success" and .conclusion != "skipped")] | length' 2>/dev/null || echo "0")
+
+  if [[ "$failed" -gt 0 ]]; then
+    local short; short=$(git rev-parse --short HEAD 2>/dev/null || echo unknown)
+    err "Pre-run CI check: HEAD CI is red — refuse to build on broken base (${short})  HEAD CI 红，拒绝在破损的基础上构建"
+    mkdir -p "$(dirname "$_LOOP_ALERT")"
+    cat > "$_LOOP_ALERT" << EOF
+# ALERT — Pre-run CI check failed (red base)
+
+**Time**: $(date '+%Y-%m-%d %H:%M')
+**Commit**: ${short}
+**Reason**: HEAD CI is red — loop refused to build on a broken base  HEAD CI 红，loop 拒绝在破损的基础上构建
+
+**Action required**:
+- Investigate and fix CI: \`gh -R $(_gh_repo_slug) run list --commit ${commit}\`
+- After fixing and pushing green commit: \`roll loop now\`
+EOF
+    _notify "roll ⚠ CI red" "loop refused to build on broken base (${short})"
+    return 1
+  fi
+  return 0
+}
+
 # CI gate before marking a story Done.
 # On CI failure: writes ALERT, returns 1 (caller keeps story 🔨 In Progress).
 # When gh unavailable: returns 0 (graceful skip).
@@ -2819,6 +2991,165 @@ EOF
   return 0
 }
 
+# FIX-032: dependency gate — parses BACKLOG inline tags so the loop SKILL
+# can enforce them at Step 2 (story pickup). Pure functions, no side effects.
+#
+# BACKLOG row format (relevant fragments):
+#   | [US-AUTO-033](...) | desc `depends-on:US-AUTO-037` `manual-only:true` | 📋 Todo |
+#   | FIX-100 | desc `depends-on:US-A,US-B` | 📋 Todo |
+#
+# Row matching is anchored on `^| [?<id>\b` so a story-id appearing in some
+# other row's depends-on list is not mistaken for the row that defines it.
+
+# _loop_check_depends_on <story-id> [backlog-path]
+#   Exit 0: all listed depends-on are ✅ Done, or no depends-on tag present.
+#   Exit 1: any dep not ✅ Done, story-id not found, or backlog missing.
+#   Stdout (on exit 1 due to unsatisfied deps): space-separated unsatisfied IDs.
+_loop_check_depends_on() {
+  local id="$1"
+  local backlog="${2:-BACKLOG.md}"
+  [ -n "$id" ] || return 1
+  [ -f "$backlog" ] || return 1
+
+  local row
+  row=$(grep -E "^\| \[?${id}[]| ]" "$backlog" | head -1)
+  [ -n "$row" ] || return 1
+
+  local deps
+  deps=$(echo "$row" | grep -oE 'depends-on:[A-Z][A-Z0-9,-]+' | head -1 | sed 's/depends-on://')
+  [ -n "$deps" ] || return 0
+
+  local unsatisfied=""
+  local dep
+  local IFS_save="$IFS"
+  IFS=','
+  for dep in $deps; do
+    local dep_row
+    dep_row=$(grep -E "^\| \[?${dep}[]| ]" "$backlog" | head -1)
+    if [ -z "$dep_row" ] || ! echo "$dep_row" | grep -qF '✅ Done'; then
+      unsatisfied="${unsatisfied:+$unsatisfied }${dep}"
+    fi
+  done
+  IFS="$IFS_save"
+
+  if [ -n "$unsatisfied" ]; then
+    echo "$unsatisfied"
+    return 1
+  fi
+  return 0
+}
+
+# _loop_is_manual_only <story-id> [backlog-path]
+#   Exit 0: story's own row carries `manual-only:true`.
+#   Exit 1: tag absent, story-id not found, or backlog missing.
+_loop_is_manual_only() {
+  local id="$1"
+  local backlog="${2:-BACKLOG.md}"
+  [ -n "$id" ] || return 1
+  [ -f "$backlog" ] || return 1
+
+  local row
+  row=$(grep -E "^\| \[?${id}[]| ]" "$backlog" | head -1)
+  [ -n "$row" ] || return 1
+
+  echo "$row" | grep -qE 'manual-only:true'
+}
+
+# US-AUTO-036: worktree helpers (loop-safe pure additions).
+#
+# Phase 1 of worktree isolation — these helpers are NOT yet called by
+# runner.sh. US-AUTO-037 (manual-only) wires them into
+# _write_loop_runner_script. Do not delete or inline; they are unit-tested
+# in tests/unit/roll_worktree.bats.
+
+# _worktree_path <slug> <us-id>
+#   Echoes the canonical worktree directory for a (project, story) pair.
+_worktree_path() {
+  echo "${_SHARED_ROOT}/worktrees/${1}-${2}"
+}
+
+# _worktree_alert <msg>
+#   Append a timestamped line to $_LOOP_ALERT. Used by failure paths in
+#   _worktree_merge_back to surface stuck worktrees.
+_worktree_alert() {
+  mkdir -p "$(dirname "$_LOOP_ALERT")" 2>/dev/null
+  printf '[%s] worktree: %s\n' "$(date -u +%FT%TZ)" "$1" >> "$_LOOP_ALERT"
+}
+
+# _worktree_create <path> <branch> <base>
+#   Create a worktree at <path> on a new branch <branch> rooted at <base>.
+#   Idempotent: if <branch> already exists locally (from a prior failed
+#   run) it is deleted first so `git worktree add -b` does not error.
+_worktree_create() {
+  local path="$1" branch="$2" base="$3"
+  mkdir -p "$(dirname "$path")"
+  if [ -e "$path" ]; then
+    git worktree remove --force "$path" 2>/dev/null || true
+    rm -rf "$path" 2>/dev/null || true
+  fi
+  if git show-ref --verify --quiet "refs/heads/${branch}"; then
+    git branch -D "$branch" >/dev/null 2>&1 || true
+  fi
+  git worktree add "$path" -b "$branch" "$base"
+}
+
+# _worktree_cleanup <path> <branch>
+#   Remove the worktree at <path> and delete <branch>. Tolerant when
+#   either is already absent so retries / partial-failure rollback is safe.
+_worktree_cleanup() {
+  local path="$1" branch="$2"
+  git worktree remove --force "$path" 2>/dev/null || true
+  rm -rf "$path" 2>/dev/null || true
+  git branch -D "$branch" 2>/dev/null || true
+  return 0
+}
+
+# _worktree_fetch_origin <branch>
+#   `git fetch origin <branch>` quietly. Lenient on failure: a missing
+#   remote / network blip must not derail the loop, so we return 0 even
+#   when fetch fails (the loop's later ff-only check is the strict gate).
+_worktree_fetch_origin() {
+  local branch="$1"
+  if ! git fetch origin "$branch" --quiet 2>/dev/null; then
+    echo "[worktree] fetch origin ${branch} failed (lenient, continuing)" >&2
+  fi
+  return 0
+}
+
+# _worktree_submodule_init <path>
+#   Run `git submodule update --init --recursive` inside the worktree at
+#   <path> so its working tree is materially complete. Runs in a subshell
+#   (cd is local) so the caller's cwd and the parent worktree's submodule
+#   state are untouched. Returns submodule update's exit code.
+_worktree_submodule_init() {
+  local path="$1"
+  ( cd "$path" && git submodule update --init --recursive --quiet )
+}
+
+# _worktree_merge_back <branch>
+#   Caller must be in the main worktree (cwd = main). Steps:
+#     1. git pull --ff-only origin main   (sync local main with remote)
+#     2. git merge --ff-only <branch>     (linear merge of loop branch)
+#     3. git push origin main             (publish)
+#   Any failure → write to $_LOOP_ALERT and return 1 (worktree is left
+#   in place by the caller for human inspection, per US-AUTO-036 non-goal).
+_worktree_merge_back() {
+  local branch="$1"
+  if ! git pull --ff-only origin main --quiet 2>/dev/null; then
+    _worktree_alert "pull --ff-only origin main failed (remote diverged?)"
+    return 1
+  fi
+  if ! git merge --ff-only "$branch" --quiet 2>/dev/null; then
+    _worktree_alert "merge --ff-only ${branch} failed (not fast-forwardable from main)"
+    return 1
+  fi
+  if ! git push origin main --quiet 2>/dev/null; then
+    _worktree_alert "push origin main failed after merging ${branch}"
+    return 1
+  fi
+  return 0
+}
+
 _loop_monitor() {
   local interval="${1:-3}"
   local project_path; project_path=$(pwd -P)
@@ -3317,82 +3648,365 @@ cmd_backlog() {
 }
 
 # ─────────────────────────────────────────────────────────────────────────────
+# DASHBOARD — 自治优先六块布局 (US-AUTO-029)
+# ─────────────────────────────────────────────────────────────────────────────
+
+# ① Identity — git working tree state.
+_dash_git_status() {
+  git rev-parse --is-inside-work-tree &>/dev/null || { echo "—"; return; }
+  if [[ -z "$(git status --porcelain 2>/dev/null)" ]]; then
+    echo "✓"
+  else
+    echo "dirty"
+  fi
+}
+
+# ② Loop layer: extract in-progress story id|title|feature-link from BACKLOG.md.
+# Output empty if no row's *status column* is 🔨 In Progress (substring matches
+# anywhere on the row would catch description text that mentions the emoji).
+_dash_in_progress_story() {
+  [[ -f "BACKLOG.md" ]] || return 0
+  local row
+  row=$(grep -F '| 🔨 In Progress |' BACKLOG.md | head -1) || return 0
+  [[ -z "$row" ]] && return 0
+  local id desc
+  id=$(echo "$row" | grep -oE '(US|FIX|REFACTOR)-[A-Z]*-?[0-9]+' | head -1)
+  desc=$(echo "$row" | awk -F'|' '{print $3}' | sed 's/^ *//;s/ *$//' | cut -c1-60)
+  local link
+  link=$(echo "$row" | grep -oE 'docs/features/[^)]+' | head -1 || true)
+  printf '%s|%s|%s' "$id" "$desc" "$link"
+}
+
+# ② Loop layer: minutes since last "tcr:" commit, or empty if none.
+_dash_last_tcr_minutes() {
+  git rev-parse --is-inside-work-tree &>/dev/null || return 0
+  local last_ts
+  last_ts=$(git log --grep='^tcr:' -1 --format=%ct 2>/dev/null)
+  [[ -z "$last_ts" ]] && return 0
+  local now; now=$(date +%s)
+  echo $(( (now - last_ts) / 60 ))
+}
+
+# ② Loop layer: tcr: commits since midnight today.
+_dash_tcr_today_count() {
+  git rev-parse --is-inside-work-tree &>/dev/null || { echo 0; return; }
+  local since; since=$(date '+%Y-%m-%d 00:00:00')
+  git log --since="$since" --grep='^tcr:' --oneline 2>/dev/null | grep -c '^' || echo 0
+}
+
+# ② Dream layer: hours since last dream log entry on disk.
+_dash_last_dream_hours() {
+  local dream_log="${HOME}/.shared/roll/dream/log.md"
+  [[ -f "$dream_log" ]] || return 0
+  local mod_time now
+  mod_time=$(stat -c %Y "$dream_log" 2>/dev/null || stat -f %m "$dream_log" 2>/dev/null || echo 0)
+  now=$(date +%s)
+  echo $(( (now - mod_time) / 3600 ))
+}
+
+# ② Dream layer: count of REFACTOR-XXX rows currently 📋 Todo in BACKLOG.
+_dash_refactor_pending() {
+  [[ -f "BACKLOG.md" ]] || { echo 0; return; }
+  grep -E '^\| REFACTOR-' BACKLOG.md 2>/dev/null | grep -F '| 📋 Todo |' | wc -l | tr -d ' '
+}
+
+# ② Peer layer: last result + days ago from peer log, empty if no log.
+_dash_last_peer() {
+  local peer_log_dir="${HOME}/.shared/roll/peer"
+  local latest
+  latest=$(ls "$peer_log_dir"/*.log 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)
+  local mod_time now days
+  mod_time=$(stat -c %Y "$latest" 2>/dev/null || stat -f %m "$latest" 2>/dev/null || echo 0)
+  now=$(date +%s)
+  days=$(( (now - mod_time) / 86400 ))
+  printf '%s|%s' "${result:-—}" "${days}"
+}
+
+# ③ Pipeline counts → Idea Backlog Build (Verify/Release reserved).
+_dash_pipeline_counts() {
+  [[ -f "BACKLOG.md" ]] || { echo "0 0 0 0 0"; return; }
+  local idea backlog build
+  idea=$(grep -E '^\| IDEA-' BACKLOG.md 2>/dev/null | grep -F '| 📋 Todo |' | wc -l | tr -d ' ')
+  backlog=$(grep -E '^\| (\[?US-|FIX-|REFACTOR-)' BACKLOG.md 2>/dev/null | grep -F '| 📋 Todo |' | wc -l | tr -d ' ')
+  build=$(grep -F '| 🔨 In Progress |' BACKLOG.md 2>/dev/null | wc -l | tr -d ' ')
+  printf '%s %s %s 0 0' "$idea" "$backlog" "$build"
+}
+
+# ④ DoD AC signal — read [x]/total checkboxes for a US section in feature doc.
+# Echoes "x/total"; "0/0" if no checkboxes found.
+_dash_ac_completion() {
+  local feature_link="$1"
+  [[ -z "$feature_link" ]] && { echo "0/0"; return; }
+  local path="${feature_link%%#*}"
+  local anchor="${feature_link##*#}"
+  [[ ! -f "$path" ]] && { echo "0/0"; return; }
+  # Extract the section from <a id="anchor"></a> or ## heading to next ## heading.
+  local section
+  section=$(awk -v anc="$anchor" '
+    BEGIN{in_sec=0}
+    /^<a id="/{
+      gsub(/<a id="|"><\/a>/, "")
+      if ($0 == anc) { in_sec=1; next }
+    }
+    in_sec && /^## /{ if(!started){ started=1; next } else { exit } }
+    in_sec && started { print }
+    in_sec { started_default=1 }
+  ' "$path" 2>/dev/null)
+  [[ -z "$section" ]] && {
+    # Fallback: match heading line containing the anchor pattern directly.
+    section=$(awk -v pat="$anchor" 'BEGIN{IGNORECASE=1}
+      tolower($0) ~ pat && /^## /{p=1;next}
+      p && /^## /{exit}
+      p{print}' "$path" 2>/dev/null)
+  }
+  local done total
+  done=$(echo "$section" | grep -cE '\[x\]' || echo 0)
+  total=$(echo "$section" | grep -cE '\[[ x]\]' || echo 0)
+  printf '%s/%s' "$done" "$total"
+}
+
+# ④ DoD CI signal — query gh for HEAD's most-recent run conclusion.
+# Returns: success | pending | failure | none
+_dash_ci_status() {
+  command -v gh &>/dev/null || { echo "none"; return; }
+  local commit; commit=$(git rev-parse HEAD 2>/dev/null) || { echo "none"; return; }
+  local slug; slug=$(_gh_repo_slug 2>/dev/null) || true
+  local out
+  if [[ -n "$slug" ]]; then
+    out=$(gh -R "$slug" run list --commit "$commit" --json status,conclusion 2>/dev/null) || { echo "none"; return; }
+  else
+    out=$(gh run list --commit "$commit" --json status,conclusion 2>/dev/null) || { echo "none"; return; }
+  fi
+  [[ -z "$out" || "$out" == "[]" ]] && { echo "none"; return; }
+  local concl status
+  concl=$(echo "$out" | jq -r '.[0].conclusion // ""' 2>/dev/null)
+  status=$(echo "$out" | jq -r '.[0].status // ""' 2>/dev/null)
+  if [[ "$status" == "in_progress" || "$status" == "queued" ]]; then
+    echo "pending"
+  elif [[ "$concl" == "success" ]]; then
+    echo "success"
+  elif [[ -n "$concl" ]]; then
+    echo "failure"
+  else
+    echo "pending"
+  fi
+}
+
+# ⑤ Active ALERT count (number of "# ALERT" headings in ALERT.md, 0 if absent).
+_dash_alert_count() {
+  [[ -f "$_LOOP_ALERT" ]] || { echo 0; return; }
+  grep '^# ALERT' "$_LOOP_ALERT" 2>/dev/null | wc -l | tr -d ' '
+}
+
+# ⑤ Pending proposal count — "## PROPOSAL:" entries in PROPOSALS.md.
+_dash_proposal_count() {
+  [[ -f "PROPOSALS.md" ]] || { echo 0; return; }
+  grep '^## PROPOSAL' PROPOSALS.md 2>/dev/null | wc -l | tr -d ' '
+}
+
+# ⑤ Release-ready signal — true if latest brief contains 可发版 or "Release ready".
+_dash_release_ready() {
+  local latest
+  latest=$(ls docs/briefs/*.md 2>/dev/null | sort | tail -1 || true)
+  [[ -z "$latest" ]] && return 1
+  grep -qE '✅ 可发版|Release ready' "$latest" 2>/dev/null
+}
+
+# ⑥ Latest brief summary — first non-trivial line after frontmatter.
+_dash_brief_summary() {
+  local latest="$1"
+  [[ -z "$latest" || ! -f "$latest" ]] && return 0
+  awk '
+    NR==1 && /^#/ { next }       # skip H1 title
+    /^>/ { next }                # skip blockquote
+    /^---$/ { next }
+    /^$/ { next }
+    /^## /{ gsub(/^## */,""); print; exit }
+    /^[^[:space:]]/{ print; exit }
+  ' "$latest" 2>/dev/null | head -1 | cut -c1-60
+}
 
 _dashboard() {
   local project_path; project_path=$(pwd -P)
   local project_name; project_name=$(basename "$project_path")
   local agent; agent=$(_project_agent)
+  local git_state; git_state=$(_dash_git_status)
+  local is_darwin=false
+  [[ "$(uname)" == "Darwin" ]] && is_darwin=true
+
+  # ── ① Identity ─────────────────────────────────────────────────────────────
+  echo ""
+  printf "  ${BOLD}${CYAN}%s${NC}  ${YELLOW}v%s${NC}  ${BOLD}·${NC}  agent ${CYAN}%s${NC}  ${BOLD}·${NC}  git " \
+    "$project_name" "$VERSION" "$agent"
+  case "$git_state" in
+    ✓) printf "${GREEN}✓${NC}\n" ;;
+    dirty) printf "${YELLOW}dirty${NC}\n" ;;
+    *) printf "${YELLOW}%s${NC}\n" "$git_state" ;;
+  esac
+  echo ""
 
-  echo -e "\n  ${BOLD}${CYAN}${project_name}${NC}  ${YELLOW}v${VERSION}${NC}\n"
+  # ── ② AI 自治 — 三层 × 四道防线 (主视觉) ────────────────────────────────
+  echo -e "  ${BOLD}╔══ 🤖 AI 自治 — 三层 × 四道防线 ══════════════════════════╗${NC}"
 
+  # Loop layer
+  local loop_state="not-installed"
   local _dash_loop_paused=false
   [[ -f "$_LOOP_STATE" ]] && grep -q "^status: paused" "$_LOOP_STATE" 2>/dev/null && _dash_loop_paused=true
+  if $is_darwin; then
+    loop_state=$(_launchd_svc_state "loop" "$project_path")
+  else
+    crontab -l 2>/dev/null | grep -q "${_LOOP_TAG}:${project_path}" && loop_state="enabled"
+  fi
+  local active_start active_end loop_minute dream_hour dream_minute brief_hour brief_minute
+  active_start=$(_config_read_int "loop_active_start" "10")
+  active_end=$(_config_read_int "loop_active_end" "18")
+  loop_minute=$(_config_read_int "loop_minute" "$(_loop_derive_minute "$project_path" 0)")
+  dream_hour=$(_config_read_int "loop_dream_hour" "3")
+  dream_minute=$(_config_read_int "loop_dream_minute" "$(_loop_derive_minute "$project_path" 2)")
+  brief_hour=$(_config_read_int "loop_brief_hour" "9")
+  brief_minute=$(_config_read_int "loop_brief_minute" "$(_loop_derive_minute "$project_path" 4)")
 
-  local _dash_loop_enabled=false
-  if [[ "$(uname)" == "Darwin" ]]; then
-    _launchd_is_loaded "$(_launchd_label "loop" "$project_path")" && _dash_loop_enabled=true
+  local loop_badge loop_sched
+  loop_sched=$(printf "every :%02d  active %02d:00–%02d:00" "$loop_minute" "$active_start" "$active_end")
+  case "$loop_state" in
+    enabled)       loop_badge="${GREEN}● enabled${NC}" ;;
+    installed-off) loop_badge="${YELLOW}⚠ off${NC}" ;;
+    *)             loop_badge="${RED}○ missing${NC}" ;;
+  esac
+  $_dash_loop_paused && loop_badge="${YELLOW}⏸ paused${NC}"
+  printf "  Loop Layer    %b  %s\n" "$loop_badge" "$loop_sched"
+
+  # Loop "Now:" line — current in-progress story, if any.
+  local in_prog; in_prog=$(_dash_in_progress_story)
+  if [[ -n "$in_prog" ]]; then
+    local p_id p_desc
+    p_id=${in_prog%%|*}
+    p_desc=$(echo "$in_prog" | awk -F'|' '{print $2}')
+    printf "                Now: ${BOLD}🔨 %s${NC}  %s\n" "$p_id" "$p_desc"
   else
-    crontab -l 2>/dev/null | grep -q "${_LOOP_TAG}:${project_path}" && _dash_loop_enabled=true
+    printf "                Now: ${DIM:-}idle${NC}\n"
   fi
-  if $_dash_loop_paused; then
-    echo -e "  Loop  ${YELLOW}⏸ paused${NC}   run: roll loop resume"
-  elif $_dash_loop_enabled; then
-    echo -e "  Loop  ${GREEN}● on${NC}   Agent: ${CYAN}${agent}${NC}"
-    if [[ "$(uname)" == "Darwin" ]]; then
-      local active_start active_end loop_minute dream_hour dream_minute brief_hour brief_minute
-      active_start=$(_config_read_int "loop_active_start" "10")
-      active_end=$(_config_read_int "loop_active_end" "18")
-      loop_minute=$(_config_read_int "loop_minute" "$(_loop_derive_minute "$project_path" 0)")
-      dream_hour=$(_config_read_int "loop_dream_hour" "3")
-      dream_minute=$(_config_read_int "loop_dream_minute" "$(_loop_derive_minute "$project_path" 2)")
-      brief_hour=$(_config_read_int "loop_brief_hour" "9")
-      brief_minute=$(_config_read_int "loop_brief_minute" "$(_loop_derive_minute "$project_path" 4)")
-      local loop_sched dream_sched brief_sched
-      loop_sched=$(printf "every hour :%02d  active %02d:00–%02d:00" "$loop_minute" "$active_start" "$active_end")
-      dream_sched=$(printf "%02d:%02d" "$dream_hour" "$dream_minute")
-      brief_sched=$(printf "%02d:%02d" "$brief_hour" "$brief_minute")
-      local svcs=("loop" "dream" "brief")
-      local scheds=("$loop_sched" "$dream_sched" "$brief_sched")
-      for i in "${!svcs[@]}"; do
-        local svc="${svcs[$i]}" schedule="${scheds[$i]}"
-        local state; state=$(_launchd_svc_state "$svc" "$project_path")
-        case "$state" in
-          enabled)       printf "    ${GREEN}%-8s ● enabled${NC}  (%s)\n" "$svc" "$schedule" ;;
-          installed-off) printf "    ${YELLOW}%-8s ⚠ off${NC}       (%s)  run: roll loop on\n" "$svc" "$schedule" ;;
-          not-installed) printf "    ${RED}%-8s ○ missing${NC}  (%s)  run: roll setup\n" "$svc" "$schedule" ;;
-        esac
-      done
-    fi
+
+  # last TCR + today count
+  local last_tcr_min today_tcr
+  last_tcr_min=$(_dash_last_tcr_minutes)
+  today_tcr=$(_dash_tcr_today_count)
+  if [[ -n "$last_tcr_min" ]]; then
+    printf "                last TCR ${CYAN}%smin${NC} ago · ${CYAN}%s${NC} micro-commits today\n" "$last_tcr_min" "$today_tcr"
   else
-    echo -e "  Loop  ${YELLOW}○ off${NC}   run: roll loop on"
+    printf "                no tcr commits yet\n"
   fi
-  [[ -f "$_LOOP_ALERT" ]] && echo -e "  ${RED}⚠ ALERT — run: roll alert${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"
+  # Dream layer
+  local dream_state="not-installed"
+  $is_darwin && dream_state=$(_launchd_svc_state "dream" "$project_path")
+  local dream_badge
+  case "$dream_state" in
+    enabled)       dream_badge="${GREEN}● enabled${NC}" ;;
+    installed-off) dream_badge="${YELLOW}⚠ off${NC}" ;;
+    *)             dream_badge="${RED}○ missing${NC}" ;;
+  esac
+  printf "  Dream Layer   %b  %02d:%02d\n" "$dream_badge" "$dream_hour" "$dream_minute"
+  local dream_hours refac_pending
+  dream_hours=$(_dash_last_dream_hours)
+  refac_pending=$(_dash_refactor_pending)
+  if [[ -n "$dream_hours" ]]; then
+    printf "                Last scan ${CYAN}%sh${NC} ago → ${CYAN}%s${NC} REFACTOR queued\n" "$dream_hours" "$refac_pending"
+  else
+    printf "                no scan yet → ${CYAN}%s${NC} REFACTOR queued\n" "$refac_pending"
+  fi
+
+  # Peer layer
+  local peer; peer=$(_dash_last_peer)
+  printf "  Peer Layer    ${GREEN}● ready${NC}    on complexity=large\n"
+  if [[ -n "$peer" ]]; then
+    local peer_res peer_days
+    peer_res=${peer%%|*}
+    peer_days=${peer##*|}
+    printf "                Last call ${CYAN}%sd${NC} ago · %s\n" "$peer_days" "$peer_res"
+  else
+    printf "                Last call —\n"
+  fi
+
+  # 四道防线
+  echo -e "  ${BOLD}─ 四道防线 ─${NC}"
+  local def_tcr="${RED}○${NC}" def_review="${GREEN}●${NC}" def_spar="${YELLOW}○${NC}" def_sentinel="${YELLOW}○ off${NC}"
+  if [[ -n "$last_tcr_min" ]]; then
+    def_tcr="${GREEN}● ${last_tcr_min}min${NC}"
+  fi
+  printf "  TCR %b   Spar %b   Auto Review %b   Sentinel %b\n" \
+    "$def_tcr" "$def_spar" "$def_review" "$def_sentinel"
+  echo -e "  ${BOLD}╚══════════════════════════════════════════════════════════╝${NC}"
+  echo ""
+
+  # ── ③ Pipeline 全景 ────────────────────────────────────────────────────────
+  read -r pl_idea pl_backlog pl_build pl_verify pl_release <<< "$(_dash_pipeline_counts)"
+  local build_color="${DIM:-}"
+  (( pl_build > 0 )) && build_color="${BOLD}${YELLOW}"
+  printf "  ${BOLD}📦 Pipeline${NC}   Idea %s ▸ Backlog %s ▸ Build %b%s🔨${NC} ▸ Verify %s ▸ Release %s\n" \
+    "$pl_idea" "$pl_backlog" "$build_color" "$pl_build" "$pl_verify" "$pl_release"
+  echo ""
+
+  # ── ④ Current Focus · DoD (仅当 Build > 0) ──────────────────────────────
+  if [[ -n "$in_prog" && "$pl_build" -gt 0 ]]; then
+    local p_id p_desc p_link
+    p_id=${in_prog%%|*}
+    p_desc=$(echo "$in_prog" | awk -F'|' '{print $2}')
+    p_link=$(echo "$in_prog" | awk -F'|' '{print $3}')
+    local ac_ratio; ac_ratio=$(_dash_ac_completion "$p_link")
+    local ac_done="${ac_ratio%%/*}" ac_total="${ac_ratio##*/}"
+    local ac_badge ci_badge
+    if [[ "$ac_total" != "0" && "$ac_done" == "$ac_total" ]]; then
+      ac_badge="${GREEN}✓ AC${NC}"
     else
-      echo -e "  Backlog  ${GREEN}✓ clear${NC}"
+      ac_badge="${YELLOW}○ AC ${ac_done}/${ac_total}${NC}"
     fi
+    local ci_state; ci_state=$(_dash_ci_status)
+    case "$ci_state" in
+      success) ci_badge="${GREEN}✓ CI${NC}" ;;
+      pending) ci_badge="${YELLOW}… CI${NC}" ;;
+      failure) ci_badge="${RED}✗ CI${NC}" ;;
+      *)       ci_badge="${YELLOW}○ CI${NC}" ;;
+    esac
+    printf "  ${BOLD}📊 Current Focus · DoD${NC}\n"
+    printf "    🔨 ${BOLD}%s${NC}  %s\n" "$p_id" "$p_desc"
+    printf "    [%b]  [%b]\n" "$ac_badge" "$ci_badge"
+    printf "    ${YELLOW}其余 4 项 DoD 信号源待接入：see US-AUTO-030/031, IDEA-013/014${NC}\n"
+    echo ""
   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 ))
-    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"
+  # ── ⑤ Human × AI 介入区 ───────────────────────────────────────────────────
+  local alerts proposals release_ready
+  alerts=$(_dash_alert_count); alerts=${alerts//[^0-9]/}; alerts=${alerts:-0}
+  proposals=$(_dash_proposal_count); proposals=${proposals//[^0-9]/}; proposals=${proposals:-0}
+  release_ready=false; _dash_release_ready && release_ready=true
+  printf "  ${BOLD}👤 需要你介入${NC}\n"
+  if (( alerts == 0 )) && (( proposals == 0 )) && ! $release_ready; then
+    printf "    ${GREEN}✓ AI 自驱中 — 无需介入${NC}\n"
   else
-    echo -e "\n  No brief yet — run: roll brief"
+    (( alerts > 0 )) && printf "    ${RED}⚠ %s ALERT${NC}          run: roll alert\n" "$alerts"
+    (( proposals > 0 )) && printf "    ${YELLOW}📋 %s PROPOSAL${NC}      run: roll backlog\n" "$proposals"
+    $release_ready && printf "    ${GREEN}✓ Release ready${NC}    run: roll release\n"
   fi
+  echo ""
 
+  # ── ⑥ Schedules & Last Brief ──────────────────────────────────────────────
+  printf "  ${BOLD}⏰ Schedules & Last Brief${NC}\n"
+  printf "    loop :%02d · dream %02d:%02d · brief %02d:%02d\n" \
+    "$loop_minute" "$dream_hour" "$dream_minute" "$brief_hour" "$brief_minute"
+  local latest_brief; latest_brief=$(ls docs/briefs/*.md 2>/dev/null | sort | tail -1 || true)
+  if [[ -n "$latest_brief" ]]; then
+    local mod_time now age summary
+    mod_time=$(stat -c %Y "$latest_brief" 2>/dev/null || stat -f %m "$latest_brief" 2>/dev/null || echo 0)
+    now=$(date +%s); age=$(( (now - mod_time) / 3600 ))
+    summary=$(_dash_brief_summary "$latest_brief")
+    printf "    Brief ${CYAN}%sh${NC} ago — %s\n" "$age" "${summary:-—}"
+  else
+    printf "    Brief: ${YELLOW}none yet${NC} — run: roll brief\n"
+  fi
   echo ""
 }