@delorenj/pjangler 1.1.3

package/templates/hermes-agent/template/.scripts/scrum-master/bin/issue-autonomous-review.sh

@@ -0,0 +1,125 @@
+#!/usr/bin/env bash
+# Provider-agnostic autonomous adversarial-review decision gate (act, don't wait).
+#
+# The rigorous, INDEPENDENT ADVERSARIAL review is the normal per-pass path: an
+# adversarial microscope that couples the close gate, an independent-reviewer
+# drift attestation, and the BloodBank decision event. A clean adversarial
+# verdict is acted on AUTONOMOUSLY -- the loop treats the ticket as done and
+# moves on; it never parks the ticket waiting on the operator for approval or
+# sign-off. Every adversarial check stays at full strength (locked-intent
+# baseline, drift none|minor|significant with significant -> hold, any unresolved
+# critical/high finding -> hold, independence, and the close gate as a hard
+# automated lock). The ONLY thing removed is the human-approval stall.
+#
+# A default clean run (no --close) means the loop autonomously treats the ticket
+# as done and leaves it in the review lane (the operator's deferred-QA queue).
+# --close is OPTIONAL (operator QA sweep): closure goes through the
+# ticket-provider adapter (tp transition <id> completed), so the same logic works
+# on Linear | Plane | Trello.
+#
+# Protocol: .scripts/scrum-master/docs/autonomous-delegated-review.md
+#
+# Usage: issue-autonomous-review.sh ISSUE_ID REPORT_FILE [--close]
+#
+# Exit codes: 0 accepted (treat as done; with --close, transitioned to completed)
+#             3 held    2 usage/missing inputs
+set -euo pipefail
+
+if [[ "${1:-}" == "" || "${2:-}" == "" ]]; then
+  printf 'Usage: %s ISSUE_ID REPORT_FILE [--close]\n' "$0" >&2; exit 2
+fi
+ISSUE="$1"; REPORT="$2"; CLOSE=0
+[[ "${3:-}" == "--close" ]] && CLOSE=1
+case "$ISSUE" in *[!A-Za-z0-9_-]*) printf 'Invalid issue id: %s\n' "$ISSUE" >&2; exit 2 ;; esac
+
+BIN_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ENGINE_DIR="$(cd "$BIN_DIR/.." && pwd)"          # .scripts/scrum-master
+SCRIPTS_DIR="$(cd "$ENGINE_DIR/.." && pwd)"      # .scripts
+ROLE_DIR="$(cd "$SCRIPTS_DIR/.." && pwd)"
+ROLE_YAML="$ROLE_DIR/role.yaml"
+ROOT="$(git -C "$ROLE_DIR" rev-parse --show-toplevel 2>/dev/null || pwd)"
+cd "$ROOT"
+
+EMIT="$BIN_DIR/emit-event.py"
+CLOSE_GATE="$BIN_DIR/issue-close-gate.sh"
+EVIDENCE="_bmad-output/implementation-artifacts/issue-evidence/$ISSUE.md"
+
+yget() { sed -n "s/^[[:space:]]*$1:[[:space:]]*//p" "$ROLE_YAML" 2>/dev/null | head -n1 | tr -d '"' | tr -d '\r'; }
+REPO="$(yget repo)"; REPO="${REPO:-unknown}"
+# Informational only: recorded in the decision event/comment, never a blocking
+# wait. Default 0 (no grace); an operator may set grace_hours>0 to reintroduce one.
+GRACE_HOURS="${DRUMJANGLER_AUTO_REVIEW_GRACE_HOURS:-$(yget grace_hours)}"; GRACE_HOURS="${GRACE_HOURS:-0}"
+AUTO="$(yget auto_review)"; AUTO="${AUTO:-true}"
+EVT="bloodbank.v1.repo.$REPO.issue.autonomous_review.decided"
+
+if [[ "${SCRUM_MASTER_AUTO_REVIEW:-$AUTO}" == "false" || "${SCRUM_MASTER_AUTO_REVIEW:-}" == "off" ]]; then
+  printf 'Autonomous review is disabled (scrum_master.auto_review=false).\n' >&2; exit 3
+fi
+[[ -f "$REPORT" ]]   || { printf 'Missing review report file: %s\n' "$REPORT" >&2; exit 2; }
+[[ -f "$EVIDENCE" ]] || { printf 'Missing issue evidence file: %s\n' "$EVIDENCE" >&2; exit 2; }
+
+HOLD=""
+hold() { HOLD="${HOLD}${HOLD:+; }$1"; }
+
+for s in '^## Reviewer' '^## Locked Intent Baseline' '^## Drift Assessment' '^## Adversarial Findings' '^## Decision'; do
+  grep -q "$s" "$REPORT" || hold "report missing section ${s#^## }"
+done
+grep -qi '^- *Independent of implementer: *yes' "$REPORT" || hold "reviewer did not attest independence"
+REVIEWER="$(sed -n 's/^- *Reviewer agent: *//p' "$REPORT" | head -n1 | tr -d '\r')"; REVIEWER="${REVIEWER:-unknown}"
+IMPL="$(sed -n 's/^- *\(Worker\|Implemented by\): *//p' "$EVIDENCE" | head -n1 | tr -d '\r')"
+[[ -n "$IMPL" && "$IMPL" == "$REVIEWER" ]] && hold "reviewer ($REVIEWER) is the implementer"
+
+DRIFT="$(sed -n 's/^- *Drift assessment: *//p' "$REPORT" | head -n1 | tr -d '\r' | tr 'A-Z' 'a-z' | awk '{print $1}')"
+case "$DRIFT" in
+  none|minor) : ;;
+  significant) hold "significant drift from locked intent" ;;
+  *) hold "drift assessment missing/invalid ('${DRIFT:-none-found}')"; DRIFT="${DRIFT:-unknown}" ;;
+esac
+grep -qi '^- *Critical/high findings: *none' "$REPORT" || hold "unresolved critical/high findings (or line missing)"
+# Accept the keyword `accept` as clearing; tolerate the legacy `close`.
+DEC="$(sed -n 's/^- *Decision: *//p' "$REPORT" | head -n1 | tr -d '\r' | tr 'A-Z' 'a-z' | awk '{print $1}')"
+[[ "$DEC" == "accept" || "$DEC" == "close" ]] || hold "reviewer decision is not 'accept' (got '${DEC:-none}')"
+
+GATE=fail
+if sh "$CLOSE_GATE" "$ISSUE" "$ROOT" >/dev/null 2>&1 </dev/null; then GATE=pass; else hold "close gate failed"; fi
+
+if [[ -n "$HOLD" ]]; then DECISION=held; else DECISION=accepted; fi
+
+python3 "$EMIT" "$EVT" --root "$ROOT" \
+  --source "repo://scrum-master/bin/issue-autonomous-review.sh" --actor-id "$REVIEWER" \
+  --field issue="$ISSUE" --field decision="$DECISION" --field drift="$DRIFT" \
+  --field close_gate="$GATE" --field reviewer_agent="$REVIEWER" \
+  --field evidence_file="$EVIDENCE" --field report_file="$REPORT" \
+  --field grace_hours="$GRACE_HOURS" --field hold_reasons="${HOLD:-none}" \
+  --quiet </dev/null || printf 'WARN: decision event emission failed; event trail incomplete.\n' >&2
+
+if [[ "$DECISION" == "held" ]]; then
+  printf 'AUTONOMOUS REVIEW: HOLD for %s\nReasons: %s\n' "$ISSUE" "$HOLD" >&2
+  exit 3
+fi
+
+printf 'AUTONOMOUS REVIEW: ACCEPTED - treat as done (no human wait) for %s (reviewer: %s | drift: %s | gate: %s)\n' \
+  "$ISSUE" "$REVIEWER" "$DRIFT" "$GATE"
+
+if [[ "$CLOSE" -eq 1 ]]; then
+  # Optional operator QA sweep: close through the ticket-provider adapter.
+  PROV="$(yget name)"; PROV="${PROV:-}"
+  if TICKET_PROVIDER="$PROV" bash -c '. "$1"; tp transition "$2" completed' _ "$SCRIPTS_DIR/lib/ticket-provider.sh" "$ISSUE"; then
+    printf 'Ticket %s transitioned to completed via adapter.\n' "$ISSUE"
+    TICKET_PROVIDER="$PROV" bash -c '. "$1"; tp comment "$2" "$3"' _ "$SCRIPTS_DIR/lib/ticket-provider.sh" "$ISSUE" \
+      "Autonomously accepted by $REVIEWER under the independent adversarial-review protocol (drift: $DRIFT, gate: $GATE, grace ${GRACE_HOURS}h informational). Treated as done; review report: $REPORT." >/dev/null 2>&1 || true
+  else
+    printf 'Adapter transition failed; decision event recorded, issue left open.\n' >&2
+    exit 1
+  fi
+else
+  # Accepted: the loop autonomously treats the ticket as done and leaves it in
+  # the review lane (deferred-QA queue). Record the autonomous acceptance via the
+  # adapter -- no approval request, no "waiting on the operator".
+  PROV="$(yget name)"; PROV="${PROV:-}"
+  TICKET_PROVIDER="$PROV" bash -c '. "$1"; tp comment "$2" "$3"' _ "$SCRIPTS_DIR/lib/ticket-provider.sh" "$ISSUE" \
+    "Autonomously accepted by $REVIEWER under the independent adversarial-review protocol (drift: $DRIFT, gate: $GATE, grace ${GRACE_HOURS}h informational). Treated as done; stays in the review lane (deferred-QA queue). Review report: $REPORT." >/dev/null 2>&1 || true
+  printf 'Accepted: ticket stays in the review lane (deferred-QA queue); the loop moves on.\n'
+  printf 'Optional operator QA sweep: re-run with --close to transition %s to completed via the adapter.\n' "$ISSUE"
+fi
+exit 0

package/templates/hermes-agent/template/.scripts/scrum-master/bin/issue-close-gate.sh

@@ -0,0 +1,62 @@
+#!/usr/bin/env sh
+# Provider-agnostic close gate. Verifies an issue's evidence file is complete
+# before any closure (manual or autonomous). Repo name is read from role.yaml so
+# event types carry the right repo lane.
+#
+# Usage: issue-close-gate.sh ISSUE_ID [REPO_ROOT]
+set -eu
+
+if [ "${1:-}" = "" ]; then
+  printf 'Usage: %s ISSUE_ID [REPO_ROOT]\n' "$0" >&2
+  exit 2
+fi
+ISSUE="$1"
+case "$ISSUE" in *[!A-Za-z0-9_-]*) printf 'Invalid issue id: %s\n' "$ISSUE" >&2; exit 2 ;; esac
+
+BIN_DIR="$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)"
+ROLE_DIR="$(cd "$BIN_DIR/../../.." && pwd)"
+ROLE_YAML="$ROLE_DIR/role.yaml"
+EMIT="$BIN_DIR/emit-event.py"
+ROOT="${2:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"
+cd "$ROOT"
+
+REPO="$(sed -n 's/^repo:[[:space:]]*//p' "$ROLE_YAML" 2>/dev/null | head -n1 | tr -d '"' | tr -d '\r')"
+REPO="${REPO:-unknown}"
+EVT_PREFIX="bloodbank.v1.repo.$REPO.issue"
+
+FILE="_bmad-output/implementation-artifacts/issue-evidence/$ISSUE.md"
+FAIL=0
+check() { grep -q "$1" "$FILE" || { printf 'Missing required evidence: %s\n' "$2" >&2; FAIL=1; }; }
+
+if [ ! -f "$FILE" ]; then
+  printf 'Missing issue evidence file: %s\n' "$FILE" >&2
+  exit 1
+fi
+
+check '^## Issue' 'Issue'
+check '^## Acceptance Criteria' 'Acceptance Criteria'
+check '^## Repo Changes' 'Repo Changes'
+check '^## Verification' 'Verification'
+check '^## Ledger Update' 'Ledger Update'
+check '^## Known Gaps' 'Known Gaps'
+check '^## Close Recommendation' 'Close Recommendation'
+
+if grep -Eiq 'TBD|TODO|not run|pending|unknown' "$FILE"; then
+  printf 'Evidence file still contains unresolved placeholders or unverified work.\n' >&2
+  FAIL=1
+fi
+grep -q 'Ledger updated: yes' "$FILE" || { printf 'Ledger update is not marked yes.\n' >&2; FAIL=1; }
+grep -q 'Close recommendation: ready' "$FILE" || { printf 'Close recommendation is not ready.\n' >&2; FAIL=1; }
+
+if [ "$FAIL" -ne 0 ]; then
+  python3 "$EMIT" "$EVT_PREFIX.gate.failed" --root "$ROOT" \
+    --source "repo://scrum-master/bin/issue-close-gate.sh" \
+    --field issue="$ISSUE" --field evidence_file="$FILE" --quiet </dev/null || true
+  printf '\nCLOSE GATE: FAIL for %s\n' "$ISSUE" >&2
+  exit 1
+fi
+
+python3 "$EMIT" "$EVT_PREFIX.gate.passed" --root "$ROOT" \
+  --source "repo://scrum-master/bin/issue-close-gate.sh" \
+  --field issue="$ISSUE" --field evidence_file="$FILE" --quiet </dev/null || true
+printf 'CLOSE GATE: PASS for %s\n' "$ISSUE"

package/templates/hermes-agent/template/.scripts/scrum-master/continuous-ticket-sentinel.prompt.md.jinja

@@ -0,0 +1,94 @@
+# {{ display_name }} — continuous ticket sentinel pass
+
+Run one continuous ticket orchestration pass for the **{{ target_repo }}** repo.
+A cheap systemd heartbeat already decided this full pass is needed.
+
+Working repo: the git root containing this role at `agents/hermes/{{ role }}/`.
+Ticket provider: **{{ ticket_provider }}** (reached only through the adapter — see below).
+
+You are the **{{ target_repo }} Scrum Master**. Act autonomously, but stay inside
+the project contracts. Read `agents/hermes/{{ role }}/SOUL.md` and the engine
+docs under `.scripts/scrum-master/docs/` before acting:
+`continuous-ticket-orchestration.md`, `autonomous-delegated-review.md`,
+`bloodbank-events.md`.
+
+## Ticket access — adapter only
+
+Never call {{ ticket_provider }} directly. Use the adapter:
+
+```bash
+.scripts/lib/ticket-provider.sh        # defines tp(); source it, then:
+tp active_milestone                    # JSON {id,name,state}
+tp list_issues                         # JSON [{id,key,title,state,state_type,...}]
+tp get_issue <id>                      # JSON incl. description + comments
+tp comment <id> "<body>"               # post a PM/review note
+tp transition <id> <normalized-state>  # backlog|unstarted|started|in_review|completed
+```
+
+Reason in **normalized states**, not provider terms. This pass works identically
+on Linear, Plane, or Trello.
+
+## Pass
+
+1. Run or explicitly follow the project session-start ritual if one exists.
+2. Reconcile: active milestone (`tp active_milestone`), issues (`tp list_issues`),
+   local evidence under `_bmad-output/implementation-artifacts/issue-evidence/`,
+   and live worker state (zellij sessions, worktrees, git).
+3. If one worker ticket is `started` and healthy, monitor it and record state.
+4. If no worker is active and a ready unblocked issue exists, delegate exactly
+   one worker (see the orchestration doc), move the issue to `started`, and
+   create/refresh its evidence file. Do not self-accept review here.
+5. **Independent adversarial review — a NORMAL per-pass action.** For any
+   `in_review` ticket whose evidence is complete and for which an independent
+   reviewer exists (a reviewer agent id NOT equal to the implementer recorded in
+   the evidence, `Worker:` / `Implemented by:`), run the **independent
+   adversarial review** in `docs/autonomous-delegated-review.md`. Delegate to that
+   independent reviewer and have it run, as a rigorous adversarial review:
+
+   ```bash
+   .scripts/scrum-master/bin/issue-autonomous-review.sh <ISSUE> <REPORT>
+   ```
+
+   (NO `--close`.) This is an adversarial microscope: it holds the work against
+   the locked-intent baseline (acceptance criteria, active milestone / horizon
+   model, product north star, locked product/architecture decisions), scores
+   drift `none | minor | significant` (`significant` → HOLD), surfaces any
+   unresolved critical/high finding (→ HOLD), enforces reviewer independence, and
+   the close gate (evidence completeness) stays a hard automated lock. Then ACT on
+   the verdict autonomously — do not wait on the operator:
+   - **Accepted** (drift `none|minor`, no unresolved critical/high findings,
+     independence satisfied, close gate passes): autonomously TREAT THE TICKET AS
+     DONE. Leave it in the review lane as the operator's deferred-QA queue (do NOT
+     auto-transition to `completed`; `--close` is an optional operator-QA-sweep
+     flag the loop omits). Record the adversarial review report, emit the decision
+     event, and post ONE ticket comment stating the autonomous acceptance with a
+     pointer to the report — never a "waiting on you" comment, no grace wait. A
+     dependent blocked only on this review-accepted feature is now unblocked.
+   - **Held** (a real finding or gate failure): the ticket goes back to active
+     (`started` if a worker takes it now, else `unstarted`); record the hold
+     reasons and emit the decision event.
+6. **Regression rollback.** If a later dependent proves a review-accepted feature
+   is ACTUALLY BROKEN, move that feature back to active (`started` if a worker
+   takes it now, else `unstarted`) as a PREREQUISITE of the dependent; comment
+   naming the dependent + symptom; emit
+   `bloodbank.v1.repo.{{ target_repo }}.issue.review_rollback.recorded`
+   `{issue, surfaced_by, reason}`. The dependent stays blocked on the prerequisite
+   until it is fixed. This is expected and healthy — it is the trade for deferring
+   operator QA, not a failure.
+7. **External blockers only** (credentials, third-party access, paid actions,
+   undecided product decisions): record the blocker and wait on it. Do NOT
+   auto-review these.
+8. **Anti-stall.** Never end a pass with work parked waiting on the operator's
+   approval or sign-off. "Looks good, waiting on the operator" is never a terminal
+   pass state. The only legitimate review-lane outcomes are: **accepted** (treat
+   as done, move on), **held** (back to active), or a genuine **out-of-scope
+   blocker** (recorded and waited on). There is no fourth "waiting for the
+   operator's sign-off" state.
+9. Update `runtime/continuous-ticket-sentinel-state.json`: `active` /
+   `blocked` / `idle` / `stalled` with the required fields (`source`, `agent_id`,
+   `repo`, `ticket_provider`, `status`, `summary`, `reason`, `updated_at`,
+   `last_activity_at`, `log_path`).
+10. Run or follow the session-end ritual; report board status, issues touched,
+    evidence touched, and the active worker issue or blocker.
+
+Do not rely on a hard-coded seed ticket. Query the board every pass.

package/templates/hermes-agent/template/.scripts/scrum-master/continuous-ticket-sentinel.sh

@@ -0,0 +1,207 @@
+#!/usr/bin/env bash
+# Provider-agnostic continuous-ticket sentinel heartbeat (Scrum Master engine).
+#
+# Runs often (systemd timer). Only invokes Hermes when local state says no worker
+# is active, the worker heartbeat is stale, or the last full run is outside the
+# cooldown window. The full pass executes the role's
+# continuous-ticket-sentinel.prompt.md, which reasons about tickets through the
+# ticket-provider adapter (Linear | Plane | Trello) — never a hardcoded backend.
+set -euo pipefail
+
+ENGINE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"   # .scripts/scrum-master
+ROLE_DIR="$(cd "$ENGINE_DIR/../.." && pwd)"
+RUNTIME="$ROLE_DIR/runtime"
+PROMPT_FILE="$ENGINE_DIR/continuous-ticket-sentinel.prompt.md"
+STATE_FILE="$RUNTIME/continuous-ticket-sentinel-state.json"
+LOCK_FILE="$RUNTIME/continuous-ticket-sentinel.lock"
+ROLE_YAML="$ROLE_DIR/role.yaml"
+LOG_FILE="$RUNTIME/logs/continuous-ticket-sentinel.log"
+
+# Hermes binary: explicit env > ~/.config/hermes-agent/hermes-bin > PATH.
+HERMES_BIN="${HERMES_BIN:-}"
+if [[ -z "$HERMES_BIN" ]]; then
+  if [[ -r "$HOME/.config/hermes-agent/hermes-bin" ]]; then
+    HERMES_BIN="$(cat "$HOME/.config/hermes-agent/hermes-bin")"
+  else
+    HERMES_BIN="$(command -v hermes || echo hermes)"
+  fi
+fi
+
+ACTIVE_MAX_IDLE_SECONDS="${SENTINEL_ACTIVE_MAX_IDLE_SECONDS:-600}"
+FULL_RUN_COOLDOWN_SECONDS="${SENTINEL_FULL_RUN_COOLDOWN_SECONDS:-300}"
+BLOCKED_FULL_RUN_COOLDOWN_SECONDS="${SENTINEL_BLOCKED_FULL_RUN_COOLDOWN_SECONDS:-900}"
+
+yaml_value() {
+  python3 - "$ROLE_YAML" "$1" <<'PYEOF'
+import re, sys
+from pathlib import Path
+path, key = sys.argv[1:3]
+text = Path(path).read_text()
+m = re.search(rf'(?m)^\s*{re.escape(key)}:\s*"?([^"\n]*)"?\s*$', text)
+print(m.group(1).strip() if m else "")
+PYEOF
+}
+
+AGENT_ID="$(yaml_value agent_id)"
+REPO_NAME="$(yaml_value repo)"
+PROFILE_NAME="$(yaml_value profile)"
+PROVIDER="$(yaml_value name)"   # ticket_provider.name leaf
+[[ -n "$PROFILE_NAME" ]] || PROFILE_NAME="$AGENT_ID"
+FLEET_HOME="${HERMES_FLEET_HOME:-$HOME/.hermes}"
+PROFILE_HOME="$FLEET_HOME/profiles/$PROFILE_NAME"
+HERMES_PROFILE_HOME="${HERMES_HOME:-}"
+if [[ -z "$HERMES_PROFILE_HOME" ]]; then
+  if [[ -d "$PROFILE_HOME" ]]; then
+    HERMES_PROFILE_HOME="$PROFILE_HOME"
+  else
+    HERMES_PROFILE_HOME="$RUNTIME"
+  fi
+fi
+
+repo_root() {
+  local dir="$ROLE_DIR"
+  for _ in 1 2 3 4 5; do
+    dir="$(dirname "$dir")"
+    if [[ -d "$dir/.git" || -f "$dir/.git" ]]; then printf '%s\n' "$dir"; return 0; fi
+  done
+  return 1
+}
+REPO_ROOT="$(repo_root)"
+cd "$REPO_ROOT"
+mkdir -p "$RUNTIME/logs"
+
+# Single-run lock. Prefer flock (Linux); fall back to an atomic mkdir lock so
+# this also works on macOS, which doesn't ship flock.
+if command -v flock >/dev/null 2>&1; then
+  exec 9>"$LOCK_FILE"
+  if ! flock -n 9; then
+    printf '[sentinel] another heartbeat/full run is active; skipping\n'; exit 0
+  fi
+else
+  LOCK_DIR="$LOCK_FILE.d"
+  if ! mkdir "$LOCK_DIR" 2>/dev/null; then
+    # Steal a stale lock older than 60 minutes (a crashed run left it behind).
+    if [ -n "$(find "$LOCK_DIR" -maxdepth 0 -mmin +60 2>/dev/null)" ]; then
+      rmdir "$LOCK_DIR" 2>/dev/null && mkdir "$LOCK_DIR" 2>/dev/null \
+        || { printf '[sentinel] another run active; skipping\n'; exit 0; }
+    else
+      printf '[sentinel] another heartbeat/full run is active; skipping\n'; exit 0
+    fi
+  fi
+  trap 'rmdir "$LOCK_DIR" 2>/dev/null' EXIT
+fi
+
+decision="$(
+  python3 - "$STATE_FILE" "$ACTIVE_MAX_IDLE_SECONDS" "$FULL_RUN_COOLDOWN_SECONDS" "$BLOCKED_FULL_RUN_COOLDOWN_SECONDS" <<'PYEOF'
+import json, subprocess, sys, time
+from pathlib import Path
+state_path = Path(sys.argv[1]); active_max_idle = int(sys.argv[2])
+full_run_cooldown = int(sys.argv[3]); blocked_full_run_cooldown = int(sys.argv[4])
+now = time.time()
+state = {}
+if state_path.exists():
+    try: state = json.loads(state_path.read_text())
+    except Exception: state = {}
+session = str(state.get("session") or ""); status = str(state.get("status") or "")
+worktree = str(state.get("worktree") or "")
+def iso_epoch(value):
+    if not value: return 0
+    try: return time.mktime(time.strptime(str(value).replace("Z","+0000"), "%Y-%m-%dT%H:%M:%S%z"))
+    except Exception:
+        try:
+            from datetime import datetime
+            return datetime.fromisoformat(str(value).replace("Z","+00:00")).timestamp()
+        except Exception: return 0
+if status in {"blocked","stalled","error"}:
+    last_blocked_run = (float(state.get("last_full_run_epoch") or 0)
+        or iso_epoch(state.get("last_runner_completed_at")) or iso_epoch(state.get("updated_at")))
+    if last_blocked_run and (now - last_blocked_run) < blocked_full_run_cooldown:
+        print("skip:blocker-cooldown"); raise SystemExit(0)
+if status in {"active","delegated","working"} and session:
+    process_active = False
+    try:
+        result = subprocess.run(["ps","-u",str(__import__("os").getuid()),"-o","pid=,command="],
+            check=False, text=True, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, timeout=5)
+        markers = ("codex exec","opencode run","auggie","gemini","kimi","copilot")
+        process_active = any(((session and session in line) or (worktree and worktree in line))
+            and any(m in line for m in markers) for line in result.stdout.splitlines())
+    except Exception: process_active = False
+    log_path = Path.home()/".local"/"state"/"zellij"/"sessions"/session/"zellij.log"
+    log_recent = log_path.exists() and (now - log_path.stat().st_mtime) <= active_max_idle
+    marker_recent = False
+    last_activity = iso_epoch(state.get("last_activity_at")) or iso_epoch(state.get("updated_at"))
+    if last_activity: marker_recent = (now - last_activity) <= active_max_idle
+    if process_active and (log_recent or marker_recent):
+        print("skip:active-worker"); raise SystemExit(0)
+last_full_run = float(state.get("last_full_run_epoch") or 0)
+if last_full_run and (now - last_full_run) < full_run_cooldown: print("skip:cooldown")
+else: print("run:full")
+PYEOF
+)"
+
+write_state() {  # write_state <json-merge-via-python args...>
+  python3 - "$STATE_FILE" "$AGENT_ID" "$REPO_NAME" "$LOG_FILE" "$@" "$PROVIDER"
+}
+
+case "$decision" in
+  skip:*)
+    write_state "$decision" <<'PYEOF'
+import json, sys, time
+from datetime import datetime, timezone
+from pathlib import Path
+path = Path(sys.argv[1]); agent_id, repo, log_path, decision, provider = sys.argv[2:7]
+state = json.loads(path.read_text()) if path.exists() else {}
+now_iso = datetime.fromtimestamp(time.time(), timezone.utc).isoformat()
+state.update({"source":"hermes-continuous-ticket-sentinel","agent_id":agent_id,"repo":repo,
+    "ticket_provider":provider,"log_path":log_path,"last_heartbeat_at":now_iso,"last_decision":decision})
+state.setdefault("updated_at", now_iso); state.setdefault("summary", state.get("reason") or decision)
+tmp = path.with_suffix(path.suffix + ".tmp"); tmp.write_text(json.dumps(state, indent=2, sort_keys=True)+"\n"); tmp.replace(path)
+PYEOF
+    printf '[sentinel] %s\n' "$decision"; exit 0
+    ;;
+esac
+
+write_state "$decision" <<'PYEOF'
+import json, sys, time
+from datetime import datetime, timezone
+from pathlib import Path
+path = Path(sys.argv[1]); agent_id, repo, log_path, decision, provider = sys.argv[2:7]
+state = json.loads(path.read_text()) if path.exists() else {}
+now = time.time()
+state.update({"source":"hermes-continuous-ticket-sentinel","agent_id":agent_id,"repo":repo,
+    "ticket_provider":provider,"status":"checking",
+    "summary":"Scrum Master is reconciling the ticket board, evidence, and worker state.",
+    "log_path":log_path,"last_heartbeat_at":datetime.fromtimestamp(now,timezone.utc).isoformat(),
+    "last_decision":decision,"last_full_run_epoch":now,
+    "last_full_run_started_at":datetime.fromtimestamp(now,timezone.utc).isoformat()})
+tmp = path.with_suffix(path.suffix + ".tmp"); tmp.write_text(json.dumps(state, indent=2, sort_keys=True)+"\n"); tmp.replace(path)
+PYEOF
+
+prompt="$(<"$PROMPT_FILE")"
+set +e
+env HERMES_HOME="$HERMES_PROFILE_HOME" "$HERMES_BIN" chat -Q --source cron --max-turns 90 -q "$prompt"
+status=$?
+set -e
+
+runner_exit="$(
+  python3 - "$STATE_FILE" "$status" "$AGENT_ID" "$REPO_NAME" "$LOG_FILE" <<'PYEOF'
+import json, sys, time
+from datetime import datetime, timezone
+from pathlib import Path
+path = Path(sys.argv[1]); exit_code = int(sys.argv[2]); agent_id, repo, log_path = sys.argv[3:6]
+state = json.loads(path.read_text()) if path.exists() else {}
+now_iso = datetime.fromtimestamp(time.time(), timezone.utc).isoformat()
+state.update({"source":"hermes-continuous-ticket-sentinel","agent_id":agent_id,"repo":repo,
+    "log_path":log_path,"last_heartbeat_at":now_iso})
+state["last_runner_exit_code"] = exit_code; state["last_runner_completed_at"] = now_iso
+state.setdefault("last_full_run_epoch", time.time())
+if state.get("status") == "checking":
+    state["status"] = "idle" if exit_code == 0 else "error"
+    state["summary"] = ("Scrum Master completed the reconciliation pass without claiming work."
+        if exit_code == 0 else "Scrum Master reconciliation failed; inspect the sentinel log.")
+    state.setdefault("updated_at", now_iso)
+tmp = path.with_suffix(path.suffix + ".tmp"); tmp.write_text(json.dumps(state, indent=2, sort_keys=True)+"\n"); tmp.replace(path)
+print(0 if state.get("status") in {"active","blocked","stalled","idle"} else exit_code)
+PYEOF
+)"
+exit "$runner_exit"

package/templates/hermes-agent/template/.scripts/scrum-master/docs/autonomous-delegated-review.md

@@ -0,0 +1,168 @@
+# Autonomous adversarial review (act, do not wait)
+
+Status: Scrum Master engine protocol (provider-agnostic)
+
+## Purpose
+
+When a ticket reaches the review lane, the Scrum Master sentinel runs an
+**independent adversarial review** of the work against the operator's locked
+intent and acts on the verdict autonomously. This is the **normal per-pass
+path** for review-lane tickets — not a deliberately narrow escape hatch, and not
+the only sanctioned path. The reviewer is an **adversarial microscope**: it
+actively tries to break the work, surface unmet acceptance criteria, hidden
+regressions, and drift. On a clean adversarial verdict the loop treats the
+ticket as done and moves on — through the ticket-provider adapter
+(`tp transition <id> <state>`) — and emits a BloodBank decision event carrying
+the full report. This works identically on Linear, Plane, or Trello.
+
+The operator's verification is **deferred** to end-of-product QA over the review
+lane, backed by a queryable decision trail. A downstream regression rollback is
+the safety valve. The loop does NOT wait on a human to approve or close
+reviewed work.
+
+## Anti-stall rule
+
+The continuous ticket sentinel MUST act on the adversarial verdict autonomously.
+It MUST NOT idle, stop, or end a pass solely because reviewed work awaits human
+approval. "Looks good, waiting on the operator" is **never** a resting state and
+never a terminal pass state. For any review-lane ticket there are exactly three
+legitimate outcomes:
+
+- the independent adversarial review has run and the ticket is **accepted**
+  (treat as done, move on); or
+- the review **held** it on a real finding (back to / stays active); or
+- the ticket has a genuine **out-of-scope blocker** (recorded and waited on).
+
+There is no fourth "waiting for the operator's sign-off" state.
+
+## Out-of-scope blockers (not cleared by review)
+
+The review does not clear an out-of-scope blocker. Record the blocker and wait,
+exactly as before:
+
+- Blocked on external credentials, third-party access, or paid actions.
+- Blocked on an undecided product decision.
+- Acceptance criteria not actually satisfied by repository evidence.
+- Depends on another open, unblocked issue.
+
+## Preconditions
+
+1. **Review-lane ticket** — issue is `in_review`, complete, with no out-of-scope
+   blocker outstanding.
+2. **Evidence exists** — complete evidence file under
+   `_bmad-output/implementation-artifacts/issue-evidence/<ISSUE>.md`.
+3. **Independent reviewer available** — the reviewer agent id MUST differ from
+   the implementer recorded in the evidence (`Worker:` / `Implemented by:`) and
+   from the delegating PM. An implementer NEVER clears their own work.
+
+There is no mandatory grace window. `scrum_master.grace_hours` (role.yaml;
+override env `DRUMJANGLER_AUTO_REVIEW_GRACE_HOURS`) defaults to `0` and is an
+optional operator knob only — set `>0` to reintroduce a wait. The reviewer does
+not wait for the operator's first right of refusal; it reviews and acts.
+
+## Locked intent baseline
+
+Drift is measured against fixed intent, assembled from: the issue's acceptance
+criteria; the active milestone (`tp active_milestone`) and the project's horizon
+model; the product north star; and any locked planning/decision artifacts. The
+reviewer does not re-litigate intent.
+
+## Drift rubric
+
+- **significant (HOLD)** — an AC unmet; user-facing capability added/removed
+  beyond the ACs or milestone; contradicts a locked decision/north star; pulls
+  Later work into Now or touches another milestone; contradicts locked
+  architecture; introduces a new external dependency/credential/paid action.
+- **minor (accept allowed)** — internal refactors, extra tests, naming, cosmetic
+  deviations within locked intent, docs.
+- **none** — matches locked intent and ACs.
+
+Only `none`/`minor` with no unresolved critical/high findings may be accepted.
+
+## Decision
+
+Run from the role's bin (couples gate + drift + event + acceptance):
+
+```bash
+.scripts/scrum-master/bin/issue-autonomous-review.sh <ISSUE> <REPORT>
+```
+
+- **accepted** — independent adversarial review cleared it (drift `none|minor`,
+  no unresolved critical/high findings, independence satisfied, close gate
+  passes); the loop treats the ticket as done and moves on; event emitted with
+  `decision=accepted`. The ticket comment states the autonomous acceptance and
+  points to the review report — it does NOT request approval.
+- **held** — any adversarial gate fails; the ticket goes back to / stays active;
+  event `decision=held` with the reason. When in doubt, hold.
+
+The close gate (evidence completeness) remains a HARD, AUTOMATED lock: the
+script will not emit an `accepted` decision while the close gate fails, drift is
+`significant`, an unresolved critical/high finding stands, or independence is
+not satisfied.
+
+## Treat review as done
+
+An adversarially-**accepted** `in_review` ticket equals `completed` for
+dependents and flow. By default the ticket STAYS in the review lane — it is the
+operator's deferred-QA queue — and is NOT auto-transitioned to `completed`.
+`--close` is an OPTIONAL flag (operator QA sweep) and is omitted by the normal
+loop:
+
+```bash
+.scripts/scrum-master/bin/issue-autonomous-review.sh <ISSUE> <REPORT> --close
+```
+
+## Decision event
+
+```text
+bloodbank.v1.repo.<repo>.issue.autonomous_review.decided
+```
+
+Required data: `issue`, `decision` (`accepted | held`), `drift`, `close_gate`,
+`reviewer_agent`, `evidence_file`, `report_file`. See `bloodbank-events.md`.
+
+## Downstream regression rollback
+
+Deferring operator QA means a later dependent can prove a review-accepted
+feature is ACTUALLY BROKEN. When that happens, move the accepted ticket back to
+active (`started` if a worker takes it now, else `unstarted`) as a PREREQUISITE
+of the dependent, via the adapter (`tp transition <id> <state>`); comment naming
+the dependent + symptom; and emit:
+
+```text
+bloodbank.v1.repo.<repo>.issue.review_rollback.recorded
+```
+
+Required data: `issue`, `surfaced_by`, `reason`. The dependent is blocked on the
+prerequisite until it is fixed. This is expected and healthy — it is the trade
+for deferring operator QA, not a failure.
+
+## Review report shape
+
+Write `<ISSUE>.review.md`; the script validates it:
+
+```markdown
+# Autonomous Review Report: <ISSUE>
+## Issue
+- Linear/Plane/Trello issue: <ISSUE>
+- Review lane reason:
+## Reviewer
+- Reviewer agent: <independent-agent-id>
+- Independent of implementer: yes
+## Locked Intent Baseline
+- Acceptance criteria source:
+- Milestone / horizon:
+## Drift Assessment
+- Drift assessment: none        # none | minor | significant
+## Adversarial Findings
+- Critical/high findings: none
+## Decision
+- Decision: accept              # accept | hold (legacy `close` tolerated)
+```
+
+## Operator override
+
+`scrum_master.auto_review: false` (role.yaml) or `SCRUM_MASTER_AUTO_REVIEW=off`
+disables autonomous acceptance. Autonomous acceptances are fully traceable via
+the decision events in
+`_bmad-output/implementation-artifacts/bloodbank-events.jsonl`.