opencode-thrum-pro 0.1.0 → 0.1.2

package/assets/skills/persistent-watcher-archetype/SKILL.md

@@ -42,6 +42,13 @@ every agent in your `roster`:
   pattern check, not a judgment call.
 - Never approve blind: read the actual command text first.
 - Verify by re-capture after acting — never trust exit status alone.
+- To unblock a REMOTE roster member's modal, use `thrum tmux send <agent> " "`
+  (proxies by agent name to the owning peer daemon and appends Enter, so a
+  space+Enter confirms the default-focused option) — never `thrum tmux key`,
+  which is local-socket-only and errors on a remote agent. This grants only
+  the leftmost/default option; the bright line above still applies. From the
+  CLI/peer-router path this send is QUEUED behind the conservative
+  monitor-silence wait, not instant — don't re-send while waiting it out.
 
 ## Your own restart (auto-restart-at-ctx-threshold)
 
@@ -171,25 +178,77 @@ failure this archetype exists to prevent, inflicted on itself by the wrong
 choice of plumbing.
 
 Register the loop as a `thrum monitor` instead — a daemon-scheduled job,
-independent of your session, that keeps running across your restarts:
+independent of your session, that keeps running across your restarts.
+
+**A ready-to-use script ships with this skill** — `resources/thrum-watch-
+pane-capture.sh` (paired with `resources/thrum-capture-fallback.sh`,
+thrum-3mhrt). It is generic and roster-driven: it reads your own
+`watch_params.json`, captures each roster member's pane (local `thrum tmux
+capture` first, always — that already reaches remote agents by name via the
+normal rpcrouter proxy; see "SSH fallback" below for what the second script
+is for), runs `thrum detect --category permission`, applies the two-capture
+stability check, writes one report file, and emits one matchable summary
+line. It is mechanical only — no auto-escalate, no auto-key — exactly the
+scope this section already describes; judgment stays in your own turn.
+
+**Setup (one-time per watcher instance):** `CLAUDE_PLUGIN_ROOT` is a
+Claude-Code-hook-only env var — it is NOT present in `thrum monitor`'s
+scheduled-process environment, so the script cannot locate itself inside
+the plugin tree at run time. Copy both scripts out of the skill's
+`resources/` into your own agent directory first:
 
 ```bash
-thrum monitor start --name <descriptive-name> \
-  --match "<a regex matching your script's one-line ready signal>" \
+cp "${CLAUDE_PLUGIN_ROOT}/skills/persistent-watcher-archetype/resources/thrum-watch-pane-capture.sh" \
+   "${CLAUDE_PLUGIN_ROOT}/skills/persistent-watcher-archetype/resources/thrum-capture-fallback.sh" \
+   .thrum/agents/<you>/
+chmod +x .thrum/agents/<you>/thrum-watch-pane-capture.sh .thrum/agents/<you>/thrum-capture-fallback.sh
+```
+
+Then register the monitor against that absolute copy path —
+**`--notify-on-success` is MANDATORY, not optional decoration**: a
+`--schedule`d job delivers NOTHING on `--match` alone (thrum-ruz1z §5c —
+this fails completely silently, every status field reads healthy, and it
+is exactly the trap a literal reading of the syntax below used to walk
+readers into):
+
+```bash
+thrum monitor start --name <you>-pane-watch \
+  --match "^watch-tick: (cycle done|RESOLUTION-FAIL)" \
   --to @<you> \
-  -- <path-to-a-script-that-loops-and-emits-that-signal>
+  --notify-on-success \
+  --schedule '*/15 * * * *' \
+  -- /absolute/path/to/.thrum/agents/<you>/thrum-watch-pane-capture.sh
 ```
 
-The script's job is mechanical only: loop, capture each roster member's
-pane to a file, and emit one matchable line per cycle. It does not judge or
-act — `thrum monitor` matches that line and delivers it to you as a thrum
-message, which is your wake signal. Judgment (duties 1-4 above) happens in
-your own turn when you read that message, not in the script.
+(The `RESOLUTION-FAIL` alternative in `--match` is the script's own
+fork-default signal — see "SSH fallback" below.)
 
 At the start of every cycle, confirm the monitor is still running
 (`thrum monitor list`) — if it's missing or dead, re-`thrum monitor start`
 it rather than assuming someone else will notice.
 
+### SSH fallback (resilience net, not the primary path)
+
+`thrum tmux capture <agent>` already reaches remote agents by name via the
+rpcrouter proxy — that is how fleet-wide watching works today for a healthy
+peer. `thrum-capture-fallback.sh` exists for when that proxy path is
+broken on the caller's side (known bug classes: thrum-7vwgy same-host
+dual-daemon caller-identity collision; thrum-zkqut phantom-routing
+regression on a daemon build predating `EnsureProxies`). It is a strict
+FALLBACK, never primary and never SSH-first: `thrum-watch-pane-capture.sh`
+always tries the local proxy path first, and only retries via an SSH hop —
+using a per-agent SSH target resolved from `thrum state`
+(`agent_pool:<agent>` → box hostname → matched against `topology` →
+`ssh.target`/`ssh.user`/`repo_path`) — on the specific known proxy-failure
+error signature. Resolution fails CLOSED on any gap (missing box, no
+matching topology row, a placeholder `repo_path`) — that agent simply gets
+no SSH fallback for the run, it is not skipped from capture entirely, and
+local-only capture failures still show up in the report. If EVERY roster
+agent fails resolution in one run (likely a fleet-wide topology/agent_pool
+data gap, not routine per-agent degradation), the script flips its summary
+line to the `RESOLUTION-FAIL` marker so `--match` treats it as a real
+problem rather than a clean tick.
+
 ## Relationship to the deterministic context-monitoring sweep
 
 You are NOT a replacement for `scripts/error-and-context-agent-sweep.sh`

package/assets/skills/persistent-watcher-archetype/resources/thrum-capture-fallback.sh

@@ -0,0 +1,123 @@
+#!/usr/bin/env bash
+# thrum-capture-fallback.sh — capture/key an agent, falling back to an SSH
+# hop when the local `thrum tmux capture|key` proxy path fails with a known
+# cross-daemon proxy-routing error signature (thrum-7vwgy / thrum-zkqut
+# class bugs: same-host dual-daemon caller-identity collision, and a
+# phantom-routing regression on daemon builds predating EnsureProxies).
+#
+# `thrum tmux capture <agent>` ALREADY reaches remote agents by name via the
+# rpcrouter proxy — this script is a resilience FALLBACK for when that path
+# is broken on the CALLER's side, not a replacement for it and not a
+# fleet-wide-watching enabler in its own right. Local-first, always.
+#
+# This papers over those bugs rather than fixing them — it does not touch
+# thrum's daemon/peer/proxy config. It retries the identical command via
+# SSH, cd'd into the TARGET AGENT's own repo checkout on its box, using a
+# caller-resolved ssh target/user/repo. There is no hardcoded host or repo
+# in this script — resolution is the CALLER's job (see the companion
+# thrum-watch-pane-capture.sh's resolve_agent_ssh, which reads thrum state
+# agent_pool/topology to find the right box + repo per agent).
+#
+# Usage:
+#   thrum-capture-fallback.sh capture <agent_name> <ssh_target> <ssh_user> <repo_path>
+#   thrum-capture-fallback.sh key <agent_name> <ssh_target> <ssh_user> <repo_path> <key1> [key2 ...]
+#
+# <ssh_target> may be the literal string "NONE" to mean "no SSH fallback is
+# available for this agent" (e.g. the caller's target resolution failed
+# closed on a missing/placeholder topology.repo_path) — in that case a
+# local failure is returned as-is, with no SSH attempt at all.
+#
+# <ssh_user> may be empty ("") to let ssh/its own config resolve the user
+# (e.g. when <ssh_target> is itself a configured Host alias) — in that case
+# the ssh destination is just <ssh_target>, not user@target.
+#
+# Exit status: propagates the underlying thrum command's exit status from
+# whichever path (local or SSH) actually produced the returned output.
+set -uo pipefail
+
+MODE="${1:?usage: $0 <capture|key> <agent_name> <ssh_target> <ssh_user> <repo_path> [keys...]}"
+AGENT="${2:?usage: $0 <capture|key> <agent_name> <ssh_target> <ssh_user> <repo_path> [keys...]}"
+SSH_TARGET="${3:?usage: $0 <capture|key> <agent_name> <ssh_target> <ssh_user> <repo_path> [keys...]}"
+SSH_USER="${4-}"
+REPO_PATH="${5-}"
+shift 5 || true
+EXTRA_ARGS=("$@")
+
+# Known local-proxy failure signatures that mean "try the SSH fallback."
+# MUST STAY IN SYNC BY HAND with thrum-watch-pane-capture.sh's identical
+# is_proxy_failure() -- no shared-sourcing across the two files. This
+# script is also directly callable standalone (e.g. `key` to approve/deny
+# a modal on a cross-daemon agent), so it re-derives the signature
+# independently rather than trusting a caller's prior classification.
+is_proxy_failure() {
+  grep -qE 'rpcrouter: caller-peer lacks required capability|peer unreachable|circuit open, dial skipped' <<<"$1"
+}
+
+ssh_destination() {
+  if [ -n "${SSH_USER}" ]; then
+    printf '%s@%s' "${SSH_USER}" "${SSH_TARGET}"
+  else
+    printf '%s' "${SSH_TARGET}"
+  fi
+}
+
+run_local() {
+  case "$MODE" in
+    # "${EXTRA_ARGS[@]:-}" not "${EXTRA_ARGS[@]}": a DECLARED-EMPTY array
+    # subscripted with [@] is a fatal unbound-variable under `set -u` on
+    # bash <4.4 (a real bug, not a style choice -- `key` mode with zero
+    # key args crashes on this fleet's /bin/bash 3.2.57 without the ":-").
+    capture) thrum tmux capture "$AGENT" 2>&1 ;;
+    key)     thrum tmux key "$AGENT" "${EXTRA_ARGS[@]:-}" 2>&1 ;;
+  esac
+}
+
+run_ssh() {
+  local dest cmd
+  dest="$(ssh_destination)"
+  case "$MODE" in
+    capture) cmd="thrum tmux capture '$AGENT'" ;;
+    key)     cmd="thrum tmux key '$AGENT' ${EXTRA_ARGS[*]:-}" ;;
+  esac
+  # Client-side expansion of REPO_PATH/cmd into the remote command string is
+  # intentional -- that's how the resolved repo path and thrum invocation
+  # reach the remote shell at all. REPO_PATH and AGENT are quoted here so a
+  # space in either (e.g. a topology repo_path with a space) doesn't break
+  # the remote `cd` -- consistent with fail-closed-on-bad-topology-data
+  # everywhere else in this pair of scripts.
+  # shellcheck disable=SC2029
+  ssh "${dest}" "cd '${REPO_PATH}' && ${cmd}" 2>&1
+}
+
+# ssh-add retry: if the SSH hop itself fails at the connection layer (not a
+# thrum-level error), the caller's identities may need re-adding to the
+# keychain-backed ssh-agent. No default keys ship here -- this is a
+# generic plugin script, and baking in one operator's specific key
+# filenames would be wrong for every other fleet/operator that copies it.
+# Set THRUM_CAPTURE_FALLBACK_SSH_KEYS (space-separated paths) per-operator
+# if this retry needs to add specific identities; with it unset, `ssh-add
+# --apple-use-keychain` still runs with no extra args, which adds ssh's
+# own default identities.
+retry_with_ssh_add() {
+  local keys="${THRUM_CAPTURE_FALLBACK_SSH_KEYS:-}"
+  # Intentional word-splitting of a space-separated key-path list below.
+  # shellcheck disable=SC2086
+  ssh-add --apple-use-keychain ${keys} >/dev/null 2>&1
+  run_ssh
+}
+
+OUT="$(run_local)"
+STATUS=$?
+
+if [ "${STATUS}" -ne 0 ] && is_proxy_failure "${OUT}" && [ "${SSH_TARGET}" != "NONE" ]; then
+  OUT="$(run_ssh)"
+  STATUS=$?
+  # SSH connection-layer failure (not a thrum proxy error) -> try ssh-add once.
+  if [ "${STATUS}" -ne 0 ] && grep -qE 'Permission denied|Could not resolve hostname|Connection refused|Connection timed out|Too many authentication failures' <<<"${OUT}"; then
+    OUT="$(retry_with_ssh_add)"
+    STATUS=$?
+  fi
+fi
+
+echo "${OUT}"
+exit "${STATUS}"

package/assets/skills/persistent-watcher-archetype/resources/thrum-watch-pane-capture.sh

@@ -0,0 +1,379 @@
+#!/usr/bin/env bash
+#
+# thrum-watch-pane-capture.sh
+#
+# The generic, roster-driven pane-watch capture-loop script that ships with
+# the persistent-watcher-archetype plugin skill (thrum-3mhrt). Works for
+# BOTH a persistent-watcher-archetype watcher and the brainstorm-steward
+# (one parameterized script serves both — the only differences, roster
+# contents and cadence, are already `watch_params.json` fields, not script
+# forks).
+#
+# WHAT THIS SCRIPT DOES (single, non-resident pass, driven by `thrum
+# monitor`'s own schedule — never a loop; the next wake is the monitor's
+# job, not this script's):
+#   Read roster from watch_params.json -> resolve each roster member's
+#   cross-daemon SSH-fallback target ONCE per run (thrum state
+#   agent_pool/topology; fail CLOSED on any gap, never guess a path) ->
+#   capture each member's pane (local `thrum tmux capture` first, ALWAYS —
+#   `thrum tmux capture <agent>` already reaches remote agents by name via
+#   the normal rpcrouter proxy; the SSH hop below is a resilience FALLBACK
+#   for when that path is broken on the caller's side, e.g. thrum-7vwgy/
+#   thrum-zkqut-class bugs, never a fleet-wide-watching enabler in its own
+#   right, and never SSH-first) -> run each capture through `thrum detect
+#   --category permission` -> for a STABLE (unchanged across two captures,
+#   two seconds apart) detected permission prompt, flag it in the report ->
+#   write ONE report file with a section per agent (pane tail + status) ->
+#   emit ONE matchable summary line on stdout for `thrum monitor` to catch
+#   and deliver as a wake message.
+#
+# DELIBERATE SCOPE LIMIT: this script is MECHANICAL ONLY — capture, detect,
+# emit. It never auto-escalates and never auto-approves/denies a modal
+# (never calls `thrum tmux key`/`thrum send`). The persistent-watcher-
+# archetype skill is explicit that judgment (approve/cancel/escalate/nudge)
+# happens in the watcher's OWN turn when it reads the wake message this
+# script's summary line triggers, not in a script. A bash script cannot
+# safely reproduce that judgment.
+#
+# SETUP (per watcher/steward instance — see the skill's SKILL.md for the
+# full recipe): copy BOTH this script and thrum-capture-fallback.sh from
+# the skill's resources/ into your own `.thrum/agents/<you>/`, then
+# register `thrum monitor start` against that absolute copy path.
+# `CLAUDE_PLUGIN_ROOT` is a Claude-Code-hook-only env var, NOT present in
+# `thrum monitor`'s scheduled-process environment, so the script cannot
+# locate itself inside the plugin tree at run time — it must be copied
+# next to the watch_params.json it reads.
+#
+# This script relies on that copy location to find its own paths: it lives
+# at `<repo>/.thrum/agents/<name>/thrum-watch-pane-capture.sh`, so its own
+# directory IS `.thrum/agents/<name>` and `<name>` (its own dirname's
+# basename) IS the watcher/steward's agent name — used to namespace log/
+# report/lock files so multiple watchers in one repo never collide.
+#
+# USAGE:
+#   thrum-watch-pane-capture.sh
+#
+# THRUM MONITOR EXAMPLE (see SKILL.md for the full, current recipe —
+# --notify-on-success is MANDATORY: a --schedule'd job delivers NOTHING on
+# --match alone, thrum-ruz1z/S5c):
+#   thrum monitor start --name <you>-pane-watch \
+#     --match "^watch-tick: (cycle done|RESOLUTION-FAIL)" \
+#     --to @<you> \
+#     --notify-on-success \
+#     --schedule '*/15 * * * *' \
+#     -- /path/to/.thrum/agents/<you>/thrum-watch-pane-capture.sh
+#
+set -uo pipefail
+
+# --- locate paths ------------------------------------------------------
+SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" >/dev/null 2>&1 && pwd)"
+AGENT_NAME="$(basename -- "${SCRIPT_DIR}")"
+# SCRIPT_DIR is <repo>/.thrum/agents/<AGENT_NAME> per the setup recipe above
+# -- never hardcode REPO_ROOT (the prior box-specific adaptation this
+# script generalizes did, and that was exactly the thing to fix).
+REPO_ROOT="$(cd -- "${SCRIPT_DIR}/../../.." >/dev/null 2>&1 && pwd)"
+PARAMS_FILE="${SCRIPT_DIR}/watch_params.json"
+FALLBACK_SCRIPT="${SCRIPT_DIR}/thrum-capture-fallback.sh"
+
+LOG_DIR="${REPO_ROOT}/.thrum/var/log"
+LOCK_DIR="${REPO_ROOT}/.thrum/var/${AGENT_NAME}-pane-watch.lockdir"
+LOG_FILE="${LOG_DIR}/${AGENT_NAME}-pane-watch.log"
+REPORT_FILE="${LOG_DIR}/${AGENT_NAME}-pane-watch-report.txt"
+
+mkdir -p "${LOG_DIR}"
+
+# --- logging -------------------------------------------------------------
+# ALWAYS write a line, even on a no-op run: a silent run is
+# indistinguishable from a run that never happened.
+log() {
+  printf '%s %s\n' "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$1" >>"${LOG_FILE}"
+}
+
+# --- single-instance lock -------------------------------------------------
+# macOS ships no `flock`(1) by default, so use `mkdir` as the atomic lock
+# primitive instead (mkdir on an existing dir fails atomically on every
+# POSIX filesystem -- same guarantee flock gives, no dependency, and
+# `thrum monitor` resolves `#!/usr/bin/env bash` to macOS system /bin/bash
+# 3.2 which also lacks flock's usual companion, `exec N>file`+flock -n N
+# patterns some other watchers use).
+# Stale-lock guard: if the lock dir is older than 10 min, a prior run
+# almost certainly crashed without cleaning up -- reclaim it rather than
+# wedging every future cycle forever.
+if ! mkdir "${LOCK_DIR}" 2>/dev/null; then
+  if [ -d "${LOCK_DIR}" ]; then
+    LOCK_AGE=$(( $(date +%s) - $(stat -f %m "${LOCK_DIR}" 2>/dev/null || echo 0) ))
+    if [ "${LOCK_AGE}" -gt 600 ]; then
+      log "WARN: stale lock dir (${LOCK_AGE}s old) -- reclaiming"
+      rm -r -- "${LOCK_DIR}"
+      mkdir "${LOCK_DIR}" || { log "SKIP: could not reclaim stale lock, exiting"; exit 0; }
+    else
+      log "SKIP: another instance holds the lock (${LOCK_AGE}s old), exiting"
+      exit 0
+    fi
+  else
+    log "SKIP: mkdir lock failed for an unexpected reason, exiting"
+    exit 0
+  fi
+fi
+
+log "START"
+
+# --- scratch dir for pane captures ----------------------------------------
+WORKDIR="$(mktemp -d "${TMPDIR:-/tmp}/${AGENT_NAME}-pane-watch.XXXXXX")"
+# Single combined trap: both the lock dir AND the scratch dir must be
+# cleaned up on exit, regardless of which path (success/error/SKIP) got
+# here -- a second `trap ... EXIT` would silently REPLACE this one, not
+# add to it, so both cleanups live in the same trap.
+trap 'rm -r -- "${LOCK_DIR}" "${WORKDIR}"' EXIT
+
+# --- load roster from watch_params.json -----------------------------------
+if [ ! -f "${PARAMS_FILE}" ]; then
+  log "ERROR: watch_params.json not found at ${PARAMS_FILE}, exiting"
+  exit 1
+fi
+
+# `mapfile`/`readarray` are bash-4+ only; `thrum monitor`'s scheduled-run
+# process resolves `bash` to macOS's system /bin/bash (3.2), not whatever
+# Homebrew bash an interactive shell's PATH might pick up -- so array
+# population must stick to bash-3.2-portable constructs throughout this
+# script (no mapfile/readarray, no `local -n`, no bash-4 associative
+# arrays -- parallel indexed arrays instead). Test with `/bin/bash
+# thrum-watch-pane-capture.sh`, not just `bash ...` or `./...`, or this
+# class of bug only surfaces on the live scheduled run (thrum-dnatz).
+ROSTER=()
+while IFS= read -r line; do
+  [ -n "${line}" ] && ROSTER+=("${line}")
+done < <(jq -r '.roster[]?' "${PARAMS_FILE}")
+
+if [ "${#ROSTER[@]}" -eq 0 ]; then
+  log "NOOP: roster is empty in watch_params.json"
+  exit 0
+fi
+log "roster: ${ROSTER[*]}"
+
+# NOTE: this script does NOT define its own is_proxy_failure() -- the
+# local-vs-SSH decision happens ENTIRELY inside thrum-capture-fallback.sh
+# (see capture_agent below, which always routes through that wrapper), so
+# duplicating the signature here would be genuinely dead code, not a
+# sync-source. If that division of responsibility ever changes, add the
+# check back here too and see the "MUST STAY IN SYNC" note in
+# thrum-capture-fallback.sh's own is_proxy_failure().
+
+# --- per-agent SSH-fallback target resolution -----------------------------
+# Resolved ONCE per roster agent, for the whole run (never guess a path;
+# fail CLOSED on any gap -- an agent with an unresolved target simply gets
+# no SSH fallback, it is NOT skipped from capture entirely: local capture
+# is always attempted regardless of resolution outcome).
+#
+#   thrum state get agent_pool:<agent>   -> .entry.value.box (a hostname)
+#   thrum state list --kind topology     -> enumerate topology SCOPES only
+#   thrum state show topology:<scope>    -> per-scope .entry.value, matched
+#                                            by .value.hostname == the box
+#                                            hostname above
+#
+# NOTE ON THE TWO-STEP TOPOLOGY LOOKUP: `thrum state list --kind topology
+# --json`'s CLI output does NOT include each entry's `.value` (verified
+# against cmd/thrum/state.go's stateListEntry struct, which has no Value
+# field, and confirmed live -- `state list --json` returns only
+# kind/scope/method/as_of/established_by). Only `state get`/`state show`
+# emit the full entry including `.value`. So topology resolution is
+# necessarily two calls: `list` to enumerate scopes, `show` per scope for
+# the value -- a single-call `.value.hostname` scan is not achievable
+# against the current CLI, regardless of how the field/scope names read.
+is_placeholder() {
+  case "$1" in
+    ""|PENDING-LEON|PENDING|TODO|TBD) return 0 ;;
+    *) return 1 ;;
+  esac
+}
+
+TOPO_HOSTNAME=()
+TOPO_SSH_TARGET=()
+TOPO_SSH_USER=()
+TOPO_REPO_PATH=()
+
+build_topology_table() {
+  local scopes_json scope show_json hostname ssh_target ssh_user repo_path
+  if ! scopes_json="$(thrum state list --kind topology --json 2>>"${LOG_FILE}")"; then
+    log "WARN: thrum state list --kind topology failed -- ALL per-agent ssh-fallback resolution will fail closed this run"
+    return 0
+  fi
+  while IFS= read -r scope; do
+    [ -n "${scope}" ] || continue
+    if ! show_json="$(thrum state show "topology:${scope}" --json 2>>"${LOG_FILE}")"; then
+      log "WARN: thrum state show topology:${scope} failed, skipping this topology row"
+      continue
+    fi
+    hostname="$(printf '%s' "${show_json}" | jq -r '.entry.value.hostname // empty')"
+    [ -n "${hostname}" ] || continue
+    ssh_target="$(printf '%s' "${show_json}" | jq -r '.entry.value.ssh.target // empty')"
+    ssh_user="$(printf '%s' "${show_json}" | jq -r '.entry.value.ssh.user // empty')"
+    repo_path="$(printf '%s' "${show_json}" | jq -r '.entry.value.repo_path // empty')"
+    TOPO_HOSTNAME+=("${hostname}")
+    TOPO_SSH_TARGET+=("${ssh_target}")
+    TOPO_SSH_USER+=("${ssh_user}")
+    TOPO_REPO_PATH+=("${repo_path}")
+  done < <(printf '%s' "${scopes_json}" | jq -r '.entries[]?.scope')
+}
+
+# Parallel arrays, indexed 1:1 with ROSTER -- bash 3.2 has no associative
+# arrays, so "agent -> resolved target" is a lookup-by-matching-ROSTER-
+# index, not a map.
+RESOLVED_SSH_TARGET=()
+RESOLVED_SSH_USER=()
+RESOLVED_SSH_REPO=()
+RESOLVED_COUNT=0
+
+resolve_roster_targets() {
+  local agent pool_json box i matched row_found
+  for agent in "${ROSTER[@]}"; do
+    matched=0
+    row_found=0
+    if pool_json="$(thrum state get "agent_pool:${agent}" --json 2>>"${LOG_FILE}")"; then
+      box="$(printf '%s' "${pool_json}" | jq -r '.entry.value.box // empty')"
+      if [ -n "${box}" ]; then
+        for i in "${!TOPO_HOSTNAME[@]}"; do
+          if [ "${TOPO_HOSTNAME[$i]}" = "${box}" ]; then
+            row_found=1
+            if is_placeholder "${TOPO_REPO_PATH[$i]}" || is_placeholder "${TOPO_SSH_TARGET[$i]}"; then
+              log "agent=${agent} WARN topology row for host=${box} has a placeholder/missing ssh.target or repo_path -- fail-closed, no ssh fallback for this agent"
+            else
+              RESOLVED_SSH_TARGET+=("${TOPO_SSH_TARGET[$i]}")
+              RESOLVED_SSH_USER+=("${TOPO_SSH_USER[$i]}")
+              RESOLVED_SSH_REPO+=("${TOPO_REPO_PATH[$i]}")
+              RESOLVED_COUNT=$((RESOLVED_COUNT + 1))
+              matched=1
+            fi
+            break
+          fi
+        done
+        if [ "${row_found}" -eq 0 ]; then
+          log "agent=${agent} WARN no topology row matches host=${box} -- fail-closed, no ssh fallback for this agent"
+        fi
+      else
+        log "agent=${agent} WARN agent_pool entry has no .value.box -- fail-closed, no ssh fallback for this agent"
+      fi
+    else
+      log "agent=${agent} WARN thrum state get agent_pool:${agent} failed -- fail-closed, no ssh fallback for this agent"
+    fi
+    if [ "${matched}" -eq 0 ]; then
+      RESOLVED_SSH_TARGET+=("NONE")
+      RESOLVED_SSH_USER+=("")
+      RESOLVED_SSH_REPO+=("")
+    fi
+  done
+}
+
+build_topology_table
+resolve_roster_targets
+
+# Fork default (coordinator-resolved, thrum-3mhrt plan): if EVERY roster
+# agent failed resolution, that is itself worth surfacing as a real
+# problem (likely a fleet-wide topology/agent_pool data gap), not a clean
+# tick -- flip the summary line's marker so `--match` treats it as a
+# monitor-level FAIL rather than routine per-agent degradation. This is
+# ORTHOGONAL to whether local capture actually needs the fallback this
+# run -- it fires on a total resolution outage regardless.
+RESOLUTION_ALL_FAILED=0
+if [ "${RESOLVED_COUNT}" -eq 0 ]; then
+  RESOLUTION_ALL_FAILED=1
+  log "WARN: ALL ${#ROSTER[@]} roster agent(s) failed ssh-fallback target resolution this run"
+fi
+
+# --- capture helper: local first, ALWAYS; SSH fallback only inside the ---
+# --- wrapper, only on the known proxy-failure signature -------------------
+# Always routes through thrum-capture-fallback.sh (never calls `thrum tmux
+# capture` directly itself) so the local/SSH/ssh-add retry logic lives in
+# exactly one place. "Local or cross-daemon" is decided EMPIRICALLY by the
+# wrapper's own local attempt succeeding/failing -- never by an up-front
+# hostname-equality heuristic here.
+capture_agent() {
+  local agent="$1" out_file="$2" idx="$3"
+  bash "${FALLBACK_SCRIPT}" capture "${agent}" \
+    "${RESOLVED_SSH_TARGET[$idx]}" "${RESOLVED_SSH_USER[$idx]}" "${RESOLVED_SSH_REPO[$idx]}" \
+    >"${out_file}" 2>&1
+}
+
+FLAGGED=0
+{
+  echo "# ${AGENT_NAME} pane-watch report"
+  echo "# generated: $(date -u +%Y-%m-%dT%H:%M:%SZ)"
+  echo "# roster: ${ROSTER[*]}"
+  echo "# ssh-fallback resolved: ${RESOLVED_COUNT}/${#ROSTER[@]} roster agent(s)"
+  echo
+} >"${REPORT_FILE}"
+
+ROSTER_IDX=0
+for agent in "${ROSTER[@]}"; do
+  CAP1="${WORKDIR}/${agent}.cap1"
+  CAP2="${WORKDIR}/${agent}.cap2"
+
+  if ! capture_agent "${agent}" "${CAP1}" "${ROSTER_IDX}"; then
+    log "agent=${agent} WARN capture failed (exit code), recording report entry anyway"
+  fi
+
+  if [ ! -s "${CAP1}" ]; then
+    log "agent=${agent} WARN empty capture, skipping detect"
+    {
+      echo "===== @${agent} ====="
+      echo "status: CAPTURE FAILED (empty output -- check local + ssh-fallback paths; ssh-fallback target: ${RESOLVED_SSH_TARGET[$ROSTER_IDX]})"
+      echo
+    } >>"${REPORT_FILE}"
+    ROSTER_IDX=$((ROSTER_IDX + 1))
+    continue
+  fi
+
+  STATUS="clean"
+  MATCH_NAME=""
+
+  # thrum detect exit-code contract (cmd/thrum/detect.go):
+  #   exit 0 + matched entry name on stdout  -> match
+  #   exit 1, silent                         -> no match
+  # `if VAR=$(...); then` is exempt from `set -e` semantics for this
+  # purpose (we run under set -u only, not -e), so a "no match" does not
+  # abort the loop -- this IS the intended branch.
+  if MATCH_NAME=$(thrum detect --category permission --pane-file "${CAP1}" --runtime claude 2>>"${LOG_FILE}"); then
+    # Stability check: a pane holding unsubmitted text or a live human/
+    # agent mid-composition is not idle. Require the pane to be unchanged
+    # across two captures, two seconds apart, before flagging.
+    sleep 2
+    if capture_agent "${agent}" "${CAP2}" "${ROSTER_IDX}" && [ -s "${CAP2}" ]; then
+      if diff -q "${CAP1}" "${CAP2}" >/dev/null; then
+        FLAGGED=$((FLAGGED + 1))
+        STATUS="FLAGGED: stable permission prompt (pattern=${MATCH_NAME})"
+        log "agent=${agent} pattern=${MATCH_NAME} STABLE permission prompt detected"
+      else
+        STATUS="pattern=${MATCH_NAME} detected but UNSTABLE across two captures -- pane is live, not flagging"
+        log "agent=${agent} pattern=${MATCH_NAME} UNSTABLE across two captures -- leaving alone"
+      fi
+    else
+      STATUS="pattern=${MATCH_NAME} detected, re-capture failed -- not flagging without stability confirmation"
+      log "agent=${agent} WARN re-capture failed during stability check, not flagging"
+    fi
+  else
+    log "agent=${agent} no permission prompt detected"
+  fi
+
+  {
+    echo "===== @${agent} ====="
+    echo "status: ${STATUS}"
+    echo "--- pane tail (last 40 lines) ---"
+    tail -n 40 "${CAP1}"
+    echo "--- end pane ---"
+    echo
+  } >>"${REPORT_FILE}"
+
+  ROSTER_IDX=$((ROSTER_IDX + 1))
+done
+
+log "DONE flagged=${FLAGGED} resolved=${RESOLVED_COUNT}/${#ROSTER[@]} report=${REPORT_FILE}"
+
+# One matchable line for `thrum monitor --match` to catch and deliver.
+# Two shapes: the routine tick, and the resolution-outage marker from the
+# fork default above -- SKILL.md's registration example's --match regex
+# must cover BOTH ("^watch-tick: (cycle done|RESOLUTION-FAIL)").
+if [ "${RESOLUTION_ALL_FAILED}" -eq 1 ]; then
+  echo "watch-tick: RESOLUTION-FAIL $(date -u +%Y-%m-%dT%H:%M:%SZ) -- ${#ROSTER[@]} agent(s), 0 ssh-fallback targets resolved -- report: ${REPORT_FILE}"
+else
+  echo "watch-tick: cycle done $(date -u +%Y-%m-%dT%H:%M:%SZ) -- ${#ROSTER[@]} agent(s), ${FLAGGED} flagged, ${RESOLVED_COUNT} ssh-fallback-ready -- report: ${REPORT_FILE}"
+fi

package/assets/skills/prime-agent/SKILL.md

@@ -85,8 +85,6 @@ needed, defer to `thrum prime`.
 
 Once both steps complete, proceed with the work the wake-primer asked for.
 
-The `/thrum:update-agent-state` and `/thrum:recover-agent-state` skills that
-used to be invoked here (recording end-of-session continuity into
-`.thrum/agents/<agent_id>/state.md` via `thrum agent state update` /
-`recover`) were retired — superseded by `thrum state` (personal_state kind). The
+The former agent-state update and recovery skills were retired. Personal
+continuity now uses `thrum state` (personal_state kind). The
 `last_seen_skills.txt` baseline write in Step 2 above is unaffected.