@ianwremmel/dispatch 0.32.1-bootstrap.0

package/bin/pr-status

@@ -0,0 +1,931 @@
+#!/usr/bin/env bash
+# pr-status — emit PR state XML per §2.2.2 PR Status Protocol.
+#
+# Usage: pr-status <pr>
+#
+# Config comes from the plugin's userConfig. The harness exports
+# CLAUDE_PLUGIN_OPTION_* to hook processes only — commands the model runs via
+# the Bash tool never receive them — so when
+# CLAUDE_PLUGIN_OPTION_OPERATOR_LOGIN is absent from the environment, the
+# script reads the option from Claude Code's own settings files (managed →
+# project local → project → user; first match wins). operator_login is the
+# only required option; the script errors, pointing at the plugin config, if
+# it can't be resolved either way.
+#
+# Requires: gh + jq (hard — the script exits if either is missing). git and
+# claude are optional: content_present (terminal resolution) and summarize
+# degrade gracefully without them. Run from inside the repo's git worktree.
+
+set -euo pipefail
+
+PR=""
+REPO_ARG=""
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --repo) REPO_ARG="${2:-}"; shift 2 ;;
+    --repo=*) REPO_ARG="${1#--repo=}"; shift ;;
+    *) PR="$1"; shift ;;
+  esac
+done
+[[ -n "$PR" ]] || { echo "usage: pr-status [--repo <owner>/<name>] <pr>" >&2; exit 2; }
+
+# The repository the PR belongs to. Without this the script can only read a PR
+# in the repo it is standing in, so a server watching PRs across repos — or
+# running outside a worktree at all — cannot produce a payload. `gh` reads
+# GH_REPO, so resolving it once here reaches every call below.
+#
+# A URL is always decomposed, whether or not --repo was also given: leaving PR
+# as a URL puts the URL in the emitted pr="" attribute, and a --repo that
+# disagrees with it would label the output with one repo while reporting
+# another's data. Disagreement is a caller error, not something to resolve by
+# precedence.
+if [[ "$PR" =~ ^https?://[^/]+/([^/]+)/([^/]+)/pull/([0-9]+) ]]; then
+  _url_repo="${BASH_REMATCH[1]}/${BASH_REMATCH[2]}"
+  PR="${BASH_REMATCH[3]}"
+  if [[ -n "$REPO_ARG" && "$REPO_ARG" != "$_url_repo" ]]; then
+    echo "pr-status: --repo $REPO_ARG contradicts the URL, which names $_url_repo" >&2
+    exit 2
+  fi
+  REPO_ARG="$_url_repo"
+fi
+[[ -n "$REPO_ARG" ]] && export GH_REPO="$REPO_ARG"
+
+# Required tools: the script cannot emit valid XML without gh + jq. Fail loudly
+# up front rather than partway through with a cryptic error. (git and claude
+# degrade gracefully in content_present/summarize, so they are not hard-required.)
+for _tool in gh jq; do
+  command -v "$_tool" >/dev/null 2>&1 \
+    || { echo "pr-status: required tool not found on PATH: $_tool" >&2; exit 3; }
+done
+
+# claude is optional — without it items are emitted without a <summary>. Resolve
+# it once here so the absence is reported once, not once per item.
+HAVE_CLAUDE=true
+if ! command -v claude >/dev/null 2>&1; then
+  HAVE_CLAUDE=false
+  echo "pr-status: claude not found on PATH; items will be emitted without summaries" >&2
+fi
+
+# Required plugin option (§2.2.2 Operator identity). The env var wins when set
+# (hook processes get it injected; a caller may also export it). Otherwise read
+# it from the settings files Claude Code itself reads, in Claude Code's
+# precedence order. The plugin key is matched as `dispatch` or `dispatch@<any
+# marketplace>` — the marketplace name is chosen at install time, so it can't
+# be hardcoded. If nothing resolves, the operator hasn't configured the
+# dispatch plugin — surface that (the agent must NOT invent a login or fall
+# back to the ticket assigner; it's the operator's to set).
+resolve_operator_login() {
+  if [[ -n "${CLAUDE_PLUGIN_OPTION_OPERATOR_LOGIN:-}" ]]; then
+    printf '%s' "$CLAUDE_PLUGIN_OPTION_OPERATOR_LOGIN"
+    return 0
+  fi
+  # CLAUDE_PROJECT_DIR is only injected into hook processes; fall back to the
+  # enclosing git worktree, or the current directory outside one (the script
+  # requires a worktree anyway and fails later in gh if there isn't one).
+  local project_root
+  project_root="${CLAUDE_PROJECT_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"
+  # ${HOME:-} keeps `set -u` from aborting the whole lookup when HOME is unset;
+  # the resulting /.claude/... path simply fails the -f test.
+  local -a settings_files=(
+    '/etc/claude-code/managed-settings.json'
+    '/Library/Application Support/ClaudeCode/managed-settings.json'
+    "$project_root/.claude/settings.local.json"
+    "$project_root/.claude/settings.json"
+    "${HOME:-}/.claude/settings.json"
+  )
+  local f login
+  for f in "${settings_files[@]}"; do
+    [[ -f "$f" ]] || continue
+    # A file that exists but doesn't parse is warned about and skipped rather
+    # than treated as "no login found" silently — otherwise a corrupt
+    # higher-precedence file invisibly hands the answer to a lower one.
+    if ! login="$(jq -r '
+      [ (.pluginConfigs // {})
+        | to_entries[]
+        | select(.key == "dispatch" or (.key | startswith("dispatch@")))
+        | .value.options.operator_login // empty
+        | select(. != "")
+      ] | first // empty
+    ' "$f" 2>/dev/null)"; then
+      echo "pr-status: warning: could not parse $f; skipping it for operator_login resolution" >&2
+      continue
+    fi
+    if [[ -n "$login" ]]; then
+      printf '%s' "$login"
+      return 0
+    fi
+  done
+  return 1
+}
+
+OPERATOR_LOGIN="$(resolve_operator_login)" || {
+  echo "pr-status: the dispatch plugin option operator_login is not set; the operator must configure it in the dispatch plugin config (or export CLAUDE_PLUGIN_OPTION_OPERATOR_LOGIN) — pr-status cannot classify reviews without it" >&2
+  exit 3
+}
+
+OPERATOR_LC="$(printf '%s' "$OPERATOR_LOGIN" | tr '[:upper:]' '[:lower:]')"
+
+REPO="${REPO_ARG:-$(gh repo view --json nameWithOwner -q .nameWithOwner)}"
+SLUG="${REPO/\//__}"
+BASE="${DISPATCH_CACHE_DIR:-${XDG_CACHE_HOME:-$HOME/.cache}/dispatch}"
+DIR="$BASE/deliver/$SLUG/$PR"
+mkdir -p "$DIR/comments" "$DIR/threads" "$DIR/annotations" "$DIR/reviews"
+
+# A run killed mid-summary leaves its staging files behind. Nothing reads them —
+# only <id>.summary.md is — but they accumulate. A day is far longer than any
+# `claude -p` call, which has no timeout of its own, so sweeping at that age
+# cannot take a staging file a live run still owns.
+find "$DIR" -type f \( -name '*.summary.md.out.*' -o -name '*.summary.md.err.*' \) \
+  -mmin +1440 -delete 2>/dev/null || true
+
+INFORMATIONAL_RE="${DISPATCH_INFORMATIONAL_CHECKS:-}"     # e.g. "^(coverage|codeql)$"
+STUCK_AFTER_SEC="${DISPATCH_STUCK_AFTER_SEC:-3600}"
+
+# Per reference.md → Terminal signals: the text tokens must be the *last
+# non-empty line* of the body. Canonical tokens are `Done.`, `Declined.`,
+# `Shipped.`; `✓`/`✅` are accepted as inline reaction-equivalents; the
+# remaining legacy tokens (`acknowledged`, etc.) preserve pre-existing
+# behavior. Match is case-insensitive and tolerant of an optional trailing
+# period.
+TERMINAL_RE='^[[:space:]]*(✓|✅|done\.?|declined\.?|shipped\.?|acknowledged\.?|wontfix\.?|dismissed\.?|resolved\.?)[[:space:]]*$'
+
+# gh-authenticated identity — the agent's own login. classify_actionable uses it
+# (author match + marker) to recognize the calling agent's own plan/engagement/
+# terminal-tagged artifacts and suppress them. It's the only identity source, so
+# a failure here is fatal — without it every self-authored item stays actionable.
+CALLER_LOGIN="$(gh api user --jq .login 2>/dev/null || true)"
+[[ -n "$CALLER_LOGIN" ]] || { echo "pr-status: could not resolve the authenticated GitHub user (gh api user failed); run 'gh auth status' — cannot proceed" >&2; exit 3; }
+
+xml_attr() { printf '%s' "$1" | sed -e 's/&/\&amp;/g' -e 's/</\&lt;/g' -e 's/>/\&gt;/g' -e 's/"/\&quot;/g'; }
+xml_text() { printf '%s' "$1" | sed -e 's/&/\&amp;/g' -e 's/</\&lt;/g' -e 's/>/\&gt;/g'; }
+
+# --- summary helper -----------------------------------------------------------
+# Args: <body-file> <out-file>
+#
+# Writes <out-file> only when the call succeeds and produced a real summary, and
+# returns non-zero otherwise. The emitters read the file's existence as "already
+# summarized", so anything written on failure is never retried and latches for
+# the life of the cache — a missing summary must stay missing. Nested `claude -p`
+# calls intermittently answer with Claude Code's own "Not logged in" banner on a
+# zero exit, so a plausible-looking body is checked too. Diagnostics go to
+# stderr; stdout carries the XML payload.
+#
+# The output is staged in a sibling temp file and moved into place, so a
+# concurrent pr-status over the same PR never reads a half-written summary.
+summarize() {
+  local body="$1" out="$2"
+  [[ "$HAVE_CLAUDE" == true ]] || return 1
+
+  # Every caller guards this function with `|| true`, which disables errexit for
+  # its whole body — so each step that can fail is checked by hand here.
+  local tmp_out tmp_err rc=0
+  tmp_out="$(mktemp "$out.out.XXXXXX")" || {
+    echo "pr-status: could not create a temp file beside $out; skipping its summary" >&2
+    return 1
+  }
+  tmp_err="$(mktemp "$out.err.XXXXXX")" || {
+    echo "pr-status: could not create a temp file beside $out; skipping its summary" >&2
+    rm -f "$tmp_out"
+    return 1
+  }
+
+  claude -p --max-turns 1 \
+    "Summarize the following PR item in 1-3 sentences describing its outcome. Plain prose only.
+
+$(cat "$body")" > "$tmp_out" 2>"$tmp_err" </dev/null || rc=$?
+
+  local text; text="$(cat "$tmp_out")" || text=""
+  local first_line; first_line="$(grep -m1 -v '^[[:space:]]*$' <<<"$text")" || first_line=""
+  local reason=""
+  if (( rc != 0 )); then
+    reason="claude exited $rc"
+  elif [[ -z "${text//[[:space:]]/}" ]]; then
+    reason="claude produced no output"
+  elif grep -qiE '^[[:space:]]*(not logged in|please run /login|invalid api key|authentication failed)' \
+       <<<"$first_line"; then
+    # Claude Code generates these banners locally and exits zero, so the exit
+    # code cannot tell them from a summary. Matching only the opening line keeps
+    # a recap that discusses an auth bug — which mentions the same words, but
+    # further in — from being thrown away, while still catching a banner that
+    # runs long or spans lines.
+    reason="claude answered with an auth error instead of a summary"
+  elif ! mv "$tmp_out" "$out"; then
+    reason="the summary could not be moved into place"
+  fi
+
+  if [[ -z "$reason" ]]; then
+    rm -f "$tmp_err"
+    return 0
+  fi
+
+  echo "pr-status: could not summarize $body ($reason); leaving it unsummarized so a later run retries" >&2
+  [[ -s "$tmp_err" ]] && sed 's/^/pr-status:   /' "$tmp_err" >&2
+  rm -f "$tmp_out" "$tmp_err"
+  return 1
+}
+
+# Args: <summary-file>
+# A summary file that is empty, or that holds the literal `(summary
+# unavailable)`, records a failure rather than a recap. It still satisfies the
+# existence check that gates regeneration, so evict it and let this run write a
+# real one.
+evict_placeholder_summary() {
+  local sum="$1"
+  [[ -f "$sum" ]] || return 0
+  if [[ ! -s "$sum" ]] || [[ "$(cat "$sum")" == "(summary unavailable)" ]]; then
+    # An unremovable file is this item's problem, not the payload's: swallow the
+    # failure so the run keeps emitting rather than dying mid-section.
+    rm -f "$sum" || true
+  fi
+}
+
+# Args: <id> <subdir> <body>
+# Writes <id>.md when the body changes. The summary is intentionally NOT deleted
+# on change: a summary, once generated for a settled (non-actionable) item, is a
+# recap the agent reads alongside the new content when the item later flips back
+# to actionable (a reviewer reply) — instead of re-reading the whole thread. It
+# is generated lazily (see the per-section emitters: only when an item is
+# non-actionable and no summary exists yet) and then persists.
+cache_item() {
+  local id="$1" sub="$2" body="$3"
+  local md="$DIR/$sub/$id.md"
+  local hash_file="$DIR/$sub/$id.hash"
+  evict_placeholder_summary "$DIR/$sub/$id.summary.md"
+  local new_hash; new_hash="$(printf '%s' "$body" | sha256sum | cut -d' ' -f1)"
+  local old_hash=""; [[ -f "$hash_file" ]] && old_hash="$(cat "$hash_file")"
+  if [[ ! -f "$md" || "$new_hash" != "$old_hash" ]]; then
+    printf '%s' "$body" > "$md"
+    printf '%s' "$new_hash" > "$hash_file"
+  fi
+}
+
+# --- fetch --------------------------------------------------------------------
+PR_JSON="$(gh pr view "$PR" --json \
+  number,headRefName,headRefOid,baseRefName,state,mergedAt,mergeable,reviewDecision,isDraft,statusCheckRollup)"
+
+HEAD="$(jq -r .headRefName <<<"$PR_JSON")"
+
+# reviewThreads and top-level comments aren't both exposed with the fields we
+# need by `gh pr view --json` (in particular it omits comment reactions, which
+# Gate 6 needs), so fetch them via GraphQL.
+# Use the numeric PR number from PR_JSON since `$PR` may have been passed as
+# a URL or branch name (both accepted by `gh pr view`).
+#
+# `state` on the thread comments is load-bearing. A review still being drafted
+# has PENDING comments, visible only to their author — so when the agent shares
+# the operator's credentials they come back on this query and would otherwise
+# read as ordinary actionable threads, putting the agent to work on feedback
+# nobody has submitted. They are dropped per comment rather than per thread: a
+# draft reply on an existing thread must hide the reply without also hiding the
+# submitted feedback beneath it. A thread left with no comments disappears.
+PR_NUMBER="$(jq -r .number <<<"$PR_JSON")"
+OWNER="${REPO%/*}"
+REPO_NAME="${REPO#*/}"
+
+# Gate 5 is "zero actionable threads", so a thread the query never returns reads
+# as a passing gate: the review-heavy PR that exceeds one 100-node page is
+# exactly the one where dropped feedback matters. `--paginate` walks every page
+# via $endCursor; `--jq …nodes[]` emits one node per line across all pages, which
+# `jq -s` collects back into a single array.
+#
+# The nested comments(last:50) cap stays. Actionability keys on the newest
+# submitted comment, which `last:50` keeps unless all 50 newest are unsubmitted
+# drafts — in that one corner the PENDING filter empties the thread and it drops
+# out of the snapshot, so Gate 5 can pass over real feedback. Otherwise the cap
+# costs only a truncated cached thread body on a >50-comment thread, tracked
+# separately as issue #203. Lifting it needs a per-thread follow-up query rather
+# than a flag, since `--paginate` follows exactly one connection's cursor and
+# this query spends it on reviewThreads.
+THREADS_JSON="$(gh api graphql --paginate \
+  -F owner="$OWNER" -F repo="$REPO_NAME" -F pr="$PR_NUMBER" \
+  -f query='
+    query($owner:String!, $repo:String!, $pr:Int!, $endCursor:String) {
+      repository(owner:$owner, name:$repo) {
+        pullRequest(number:$pr) {
+          reviewThreads(first:100, after:$endCursor) {
+            nodes {
+              id
+              isResolved
+              comments(last:50) {
+                nodes { body state author { login } }
+              }
+            }
+            pageInfo { hasNextPage endCursor }
+          }
+        }
+      }
+    }' --jq '.data.repository.pullRequest.reviewThreads.nodes[]' \
+  | jq -s '
+      map(.comments.nodes = ((.comments.nodes // []) | map(select(.state != "PENDING"))))
+      | map(select((.comments.nodes | length) > 0))
+    ')"
+
+# §2.2.2 requires EVERY top-level comment to appear, and Gate 6 reads reactions
+# off the (recent) engagement comment, so the comments connection must be fully
+# paginated — a `first:100` single page silently drops the engagement comment
+# (and its approval reaction) on long-running PRs. `--paginate` walks every page
+# via $endCursor; `--jq …nodes[]` emits one node per line across all pages, which
+# `jq -s` collects back into a single array.
+COMMENTS_JSON="$(gh api graphql --paginate \
+  -F owner="$OWNER" -F repo="$REPO_NAME" -F pr="$PR_NUMBER" \
+  -f query='
+    query($owner:String!, $repo:String!, $pr:Int!, $endCursor:String) {
+      repository(owner:$owner, name:$repo) {
+        pullRequest(number:$pr) {
+          comments(first:100, after:$endCursor) {
+            nodes {
+              id
+              databaseId
+              body
+              author { login }
+              reactions(first:100) {
+                nodes { content user { login } }
+              }
+              reactionGroups { content viewerHasReacted }
+            }
+            pageInfo { hasNextPage endCursor }
+          }
+        }
+      }
+    }' --jq '.data.repository.pullRequest.comments.nodes[]' | jq -s '.')"
+
+# Reviews and review requests come from GraphQL, not `gh pr view --json`, because
+# the latter's exporter only marshals User/Team requested reviewers and silently
+# drops Bot-typed ones (e.g. Copilot) — which would break the pending override
+# for a re-requested bot review. GraphQL's RequestedReviewer union lets us pull
+# the login for User/Bot/Mannequin (and name/slug for Team), and the review
+# author's __typename gives an authoritative bot flag.
+#
+# The reviews connection must be fully paginated: every review event is a node,
+# so a long-running PR exceeds a single 100-node page, and a `first:100` cap
+# silently drops the newest reviews — breaking the "most recent submitted review
+# per reviewer" rule (a recent changes_requested, or a bot review that has since
+# landed against an outstanding request, would be missed). `--paginate` walks
+# every page via $endCursor; `--jq …nodes[]` emits one node per line, which
+# `jq -s` collects into a single array. reviewRequests is bounded by the
+# reviewer count (only currently-outstanding requests stand), so its single
+# 100-node page is sufficient and is fetched separately — `--paginate` follows
+# exactly one connection's cursor, so the two can't share a query.
+#
+# `id` and `body` come along because the review's own prose appears nowhere else
+# in the snapshot — inline remarks arrive as review threads, but the body a
+# `changes_requested` was submitted with has no other carrier. `id` keys its
+# cache file and its `.ack`.
+REVIEW_NODES="$(gh api graphql --paginate \
+  -F owner="$OWNER" -F repo="$REPO_NAME" -F pr="$PR_NUMBER" \
+  -f query='
+    query($owner:String!, $repo:String!, $pr:Int!, $endCursor:String) {
+      repository(owner:$owner, name:$repo) {
+        pullRequest(number:$pr) {
+          reviews(first:100, after:$endCursor) {
+            nodes { id body author { login __typename } state }
+            pageInfo { hasNextPage endCursor }
+          }
+        }
+      }
+    }' --jq '.data.repository.pullRequest.reviews.nodes[]' | jq -s '.')"
+
+REVIEW_REQUEST_NODES="$(gh api graphql \
+  -F owner="$OWNER" -F repo="$REPO_NAME" -F pr="$PR_NUMBER" \
+  -f query='
+    query($owner:String!, $repo:String!, $pr:Int!) {
+      repository(owner:$owner, name:$repo) {
+        pullRequest(number:$pr) {
+          reviewRequests(first:100) {
+            nodes {
+              requestedReviewer {
+                __typename
+                ... on User { login }
+                ... on Bot { login }
+                ... on Mannequin { login }
+                ... on Team { name slug }
+              }
+            }
+          }
+        }
+      }
+    }' --jq '.data.repository.pullRequest.reviewRequests.nodes // []')"
+
+# Re-wrap the two connections back into the {reviews:{nodes:…},
+# reviewRequests:{nodes:…}} pullRequest-node shape reviews_xml's jq reads.
+REVIEWS_JSON="$(jq -n \
+  --argjson reviews "$REVIEW_NODES" \
+  --argjson reqs "$REVIEW_REQUEST_NODES" \
+  '{reviews: {nodes: $reviews}, reviewRequests: {nodes: $reqs}}')"
+
+# GraphQL ReactionContent → platform-normalized name per §2.2.2 reactions schema.
+reaction_emoji() {
+  case "$1" in
+    THUMBS_UP)   printf '+1' ;;
+    THUMBS_DOWN) printf -- '-1' ;;
+    LAUGH)       printf 'laugh' ;;
+    HOORAY)      printf 'hooray' ;;
+    CONFUSED)    printf 'confused' ;;
+    HEART)       printf 'heart' ;;
+    ROCKET)      printf 'rocket' ;;
+    EYES)        printf 'eyes' ;;
+    *)           printf '%s' "$(tr '[:upper:]' '[:lower:]' <<<"$1")" ;;
+  esac
+}
+
+# --- checks -------------------------------------------------------------------
+checks_xml() {
+  jq -r --arg info "$INFORMATIONAL_RE" --argjson stuck_after "$STUCK_AFTER_SEC" '
+    (now | floor) as $now |
+    .statusCheckRollup // [] | map({
+      name: (.name // .context // "check"),
+      conclusion: (.conclusion // .state // ""),
+      status: (.status // ""),
+      url: (.detailsUrl // .targetUrl // ""),
+      started: (.startedAt // ""),
+      informational: ($info != "" and (((.name // .context // "")) | test($info; "i")))
+    }) | map(. + {
+      pending: (.status == "IN_PROGRESS" or .status == "QUEUED" or .status == "PENDING" or .conclusion == "" and .status != ""),
+      failing: ((.conclusion // "") | test("FAILURE|TIMED_OUT|CANCELLED|STARTUP_FAILURE"; "i")),
+      stuck: (.status == "IN_PROGRESS" and .started != "" and (($now - (.started | fromdateiso8601? // $now)) > $stuck_after))
+    }) as $cs
+    | (any($cs[]; .pending and (.stuck | not))) as $any_pending
+    | (any($cs[]; .failing and (.informational | not) and (.pending | not))) as $any_failing
+    | (if $any_pending then "pending" elif $any_failing then "failing" else "passing" end) as $rollup
+    | "  <checks state=\"\($rollup)\">",
+      ($cs[] | "    <check name=\"\(.name)\" conclusion=\"\(.conclusion)\" url=\"\(.url)\" informational=\"\(.informational)\" stuck=\"\(.stuck)\"/>"),
+      "  </checks>"
+  ' <<<"$PR_JSON"
+}
+
+# --- merge conflicts ----------------------------------------------------------
+conflicts_xml() {
+  local m; m="$(jq -r '.mergeable // ""' <<<"$PR_JSON")"
+  local present=false; [[ "$m" == "CONFLICTING" ]] && present=true
+  echo "  <merge-conflicts present=\"$present\"/>"
+}
+
+# --- reviews ------------------------------------------------------------------
+# One persistent record per reviewer (PR #132 model): a reviewer who was
+# requested OR has reviewed appears exactly once, carrying a status that walks
+# pending -> commented/changes_requested/approved (plus dismissed). An
+# outstanding request OVERRIDES any prior verdict back to "pending" — a fresh
+# request "replaces" the old review until the reviewer re-reviews — so a
+# re-requested Copilot, or an operator re-requested after approving, reads as
+# pending and the agent keeps polling instead of treating the stale verdict as
+# current. `state="pending"` is the in-flight signal: an empty thread set while a
+# pending review stands is NOT convergence. Mode is bot iff GitHub types the
+# account a Bot or the login matches the agent-identity regex; role is operator
+# iff the login is the configured operator, else team (humans only). Input is the
+# GraphQL pullRequest node ($REVIEWS_JSON): `.reviews.nodes` and
+# `.reviewRequests.nodes` (the latter wrapping a RequestedReviewer union).
+#
+# The review body is a first-class work item: it carries `actionable` and, when
+# there is a body to read, `cache`. Actionable unless the review it came from was
+# dismissed or the agent has written the `.ack` sibling; a review with no body (a
+# bare verdict, or a requested reviewer who has not reviewed) is never
+# actionable. Reviews have no reply thread and take no reactions, so `.ack` — the
+# annotation mechanism — is the only settling signal available.
+#
+# Emitted as one compact JSON object per review rather than TSV: a body carries
+# newlines and tabs, which @tsv cannot round-trip through `read`.
+reviews_xml() {
+  echo "  <reviews>"
+  jq -c '
+    # Requested reviewers (currently-outstanding requests): login + bot-ness.
+    # The GraphQL union nests under .requestedReviewer; User/Bot/Mannequin carry
+    # .login, Team carries .slug/.name.
+    ( [ (.reviewRequests.nodes // [])[]
+        | .requestedReviewer
+        | { login: ((.login // .slug // .name) // ""), is_bot: ((.__typename // "") == "Bot") }
+        | select(.login != "") ] ) as $reqs
+    | ( [ $reqs[].login | ascii_downcase ] ) as $reqset
+    # Latest SUBMITTED review per author, keyed by lowercased login. PENDING here
+    # means an unsubmitted draft (visible only to its author, e.g. the agent
+    # itself); it is invisible to the protocol, so drop it — "pending" in the
+    # output comes from an outstanding REQUEST, never an unsubmitted review.
+    | ( reduce (.reviews.nodes // [])[] as $r ({};
+          ( ($r.author.login // "") ) as $lg
+          | if $lg == "" or ($r.state == "PENDING") then .
+            else ($lg | ascii_downcase) as $k
+            | (.[$k] // {}) as $prev
+            | .[$k] = { login: $lg,
+                        is_bot: (($r.author.__typename // "") == "Bot"),
+                        state: ($r.state // "COMMENTED") }
+                    # The newest review supplies the state; the newest one that
+                    # actually carries prose supplies the body. Otherwise a bare
+                    # verdict submitted on top of a substantive review erases the
+                    # body before the agent ever polls — the exact disappearance
+                    # this element exists to prevent.
+                    + ( if (($r.body // "") | test("\\S"))
+                        then { id: ($r.id // ""), body: ($r.body // ""),
+                               body_state: ($r.state // "COMMENTED") }
+                        else { id: ($prev.id // ""), body: ($prev.body // ""),
+                               body_state: ($prev.body_state // "") }
+                        end )
+            end
+        ) ) as $rev
+    # Add a pending stub for any requested reviewer that has not reviewed.
+    | ( $rev + ( reduce $reqs[] as $q ({};
+          ( $q.login | ascii_downcase ) as $k
+          | if ($rev[$k]) then . else .[$k] = { login: $q.login, is_bot: $q.is_bot, state: "PENDING", id: "", body: "", body_state: "" } end
+        ) ) )
+    # Pending override: an outstanding request forces the status back to pending.
+    | to_entries
+    | map( .key as $k | .value + { state: ( if ($reqset | index($k)) then "PENDING" else .value.state end ) } )
+    | .[]
+  ' <<<"$REVIEWS_JSON" |
+  while read -r r; do
+    local author is_bot state rid body body_state
+    author="$(jq -r '.login // ""' <<<"$r")"
+    [[ -n "$author" ]] || continue
+    is_bot="$(jq -r '.is_bot // false' <<<"$r")"
+    state="$(jq -r '.state // ""' <<<"$r")"
+    rid="$(jq -r '.id // ""' <<<"$r")"
+    body="$(jq -r '.body // ""' <<<"$r")"
+    # The state of the review the body came from, which is not always the
+    # element's state: a later bare verdict moves state without moving body.
+    body_state="$(jq -r '.body_state // ""' <<<"$r" | tr '[:upper:]' '[:lower:]')"
+
+    local mode="human"
+    if [[ "$is_bot" == "true" ]] || [[ "${author,,}" =~ (copilot|codex|claude|ai-agent) ]]; then
+      mode="bot"
+    fi
+    local s; s="$(tr '[:upper:]' '[:lower:]' <<<"$state")"
+    case "$s" in pending|commented|approved|changes_requested|dismissed) ;; *) s=commented ;; esac
+
+    local role_attr=""
+    if [[ "$mode" == "human" ]]; then
+      local role="team"
+      [[ "${author,,}" == "$OPERATOR_LC" ]] && role="operator"
+      role_attr=" role=\"$role\""
+    fi
+
+    # A body of only whitespace is the same as none: a bare verdict with nothing
+    # to read, so it gets no cache file and can never be work.
+    local actionable="false" reason_attr=' reason="no-body"' cache_attr="" inner=""
+    if [[ -n "$rid" && -n "${body//[[:space:]]/}" ]]; then
+      local id="${rid//[^A-Za-z0-9_=-]/_}"
+      cache_item "$id" "reviews" "$body"
+      local cache_path="$DIR/reviews/$id.md"
+      local sum_path="$DIR/reviews/$id.summary.md"
+      cache_attr=" cache=\"$(xml_attr "$cache_path")\""
+      if [[ -f "$DIR/reviews/$id.ack" ]]; then
+        reason_attr=' reason="acked"'
+      elif [[ "$body_state" == "dismissed" ]]; then
+        reason_attr=' reason="dismissed"'
+      else
+        actionable="true"; reason_attr=""
+      fi
+      # Same lazy recap as comments and threads: written once the item settles,
+      # then persisted and emitted in either state. A failed summary writes
+      # nothing and must not abort the payload — the item is emitted without one.
+      if [[ "$actionable" == "false" && ! -f "$sum_path" ]]; then
+        summarize "$cache_path" "$sum_path" || true
+      fi
+      [[ -f "$sum_path" ]] && inner="<summary>$(xml_text "$(cat "$sum_path")")</summary>"
+    fi
+
+    if [[ -z "$inner" ]]; then
+      printf '    <review author="%s" mode="%s"%s state="%s" actionable="%s"%s%s/>\n' \
+        "$(xml_attr "$author")" "$mode" "$role_attr" "$s" "$actionable" "$reason_attr" "$cache_attr"
+    else
+      printf '    <review author="%s" mode="%s"%s state="%s" actionable="%s"%s%s>%s</review>\n' \
+        "$(xml_attr "$author")" "$mode" "$role_attr" "$s" "$actionable" "$reason_attr" "$cache_attr" "$inner"
+    fi
+  done
+  echo "  </reviews>"
+}
+
+# Returns 0 iff $1's last non-empty line is a canonical terminal signal.
+# Anchoring to the last non-empty line matches reference.md ("must be the
+# last non-empty line"); inline mentions of "done" in prose stay actionable.
+has_terminal_signal() {
+  local last
+  last="$(printf '%s\n' "$1" | grep -v '^[[:space:]]*$' | tail -n1)"
+  [[ -n "$last" ]] || return 1
+  grep -qiE "$TERMINAL_RE" <<<"$last"
+}
+
+# --- actionability ------------------------------------------------------------
+# Args: <newest-body> <newest-author-login> <thread-resolved:true|false>
+# Echoes a tab-separated "<actionable>\t<reason>" pair: actionable is "true" or
+# "false"; reason is empty when actionable, else a stable token explaining *why*
+# the item is suppressed (`resolved`, `agent-artifact`, `agent-terminal-reply`).
+# The reason is surfaced as a `reason=` attribute so the agent never has to
+# re-derive suppression from the human-facing <summary> prose (which describes
+# the thread's *content* and will read as if an addressed reviewer point still
+# stands).
+# Full rules: reference.md → Actionability. Summary: non-actionable iff
+# thread-resolved, or the body is the calling agent's plan comment or
+# engagement comment (line-anchored agent-plan/agent-engagement sentinel +
+# author identity, so a human quoting the marker stays actionable), or the body
+# is the calling agent's terminal-tagged reply (any agent-reply marker + author
+# identity + terminal signal on the last non-empty line), or the calling agent
+# reacted to the item with a terminal reaction (+1/-1/rocket). The author checks
+# key on $CALLER_LOGIN (guaranteed set — the script exits earlier if it can't be
+# resolved).
+classify_actionable() {
+  local body="$1" author="$2" resolved="$3" reaction_groups="${4:-[]}"
+  [[ "$resolved" == "true" ]] && { printf 'false\tresolved\n'; return; }
+
+  # Plan or engagement comment by the calling agent. Both are agent artifacts,
+  # not reviewer items: the engagement comment in particular anchors operator
+  # approval (Gate 6) and would otherwise stay actionable forever — blocking
+  # Gate 4 and thus the draft-clear/merge transitions — since the agent never
+  # "addresses" its own request.
+  if [[ "$author" == "$CALLER_LOGIN" ]] \
+      && grep -qE '^<!-- agent-(plan|engagement):[^ ]+ -->$' <<<"$body"; then
+    printf 'false\tagent-artifact\n'; return
+  fi
+
+  # Terminal-tagged reply by the calling agent: own login + an agent-reply marker
+  # + a terminal signal on the last non-empty line.
+  if has_terminal_signal "$body" \
+      && [[ "$author" == "$CALLER_LOGIN" ]] \
+      && grep -qF '<!-- agent-reply:' <<<"$body"; then
+    printf 'false\tagent-terminal-reply\n'; return
+  fi
+
+  # A terminal reaction (+1/-1/rocket, reference.md → Terminal signals) by the
+  # calling agent. Top-level comments have no reply threading, so this is the
+  # only signal that can ever settle a comment someone else authored — without
+  # it an operator note stays actionable forever and Gate 4 never passes.
+  # Keys on reactionGroups' viewerHasReacted rather than scanning reaction
+  # nodes: the GraphQL viewer is the same identity as $CALLER_LOGIN (one gh
+  # token), and viewerHasReacted is set regardless of how many reactions the
+  # comment has — a nodes scan is capped at the first page and can miss the
+  # caller's reaction on a heavily-reacted comment.
+  if jq -e 'any(.[]; .viewerHasReacted == true
+                and (.content == "THUMBS_UP" or .content == "THUMBS_DOWN"
+                     or .content == "ROCKET"))' \
+       <<<"$reaction_groups" >/dev/null 2>&1; then
+    printf 'false\tagent-terminal-reply\n'; return
+  fi
+  printf 'true\t\n'
+}
+
+# Parse a classify_actionable result into the globals $CA_ACTIONABLE and
+# $CA_REASON_ATTR (the latter ready to splice into a start tag, empty unless
+# non-actionable with a reason). Keeps the tab-splitting in one place.
+parse_actionable() {
+  CA_ACTIONABLE="${1%%$'\t'*}"
+  local reason="${1#*$'\t'}"
+  if [[ "$CA_ACTIONABLE" == "false" && -n "$reason" ]]; then
+    CA_REASON_ATTR=" reason=\"$(xml_attr "$reason")\""
+  else
+    CA_REASON_ATTR=""
+  fi
+}
+
+# Emit <reactions>…</reactions> for a reactions-node JSON array, or nothing if
+# the array is empty. Used by comments_xml.
+reactions_xml_for() {
+  local rj="$1"
+  if [[ -z "$rj" || "$rj" == "[]" || "$rj" == "null" ]]; then
+    return 0
+  fi
+  echo "<reactions>"
+  jq -r '.[] | [(.user.login // ""), (.content // "")] | @tsv' <<<"$rj" |
+  while IFS=$'\t' read -r user content; do
+    [[ -n "$user" && -n "$content" ]] || continue
+    local emoji; emoji="$(reaction_emoji "$content")"
+    printf '        <reaction author="%s" emoji="%s"/>\n' \
+      "$(xml_attr "$user")" "$(xml_attr "$emoji")"
+  done
+  echo "      </reactions>"
+  return 0
+}
+
+# --- comments (top-level PR comments) -----------------------------------------
+comments_xml() {
+  echo "  <comments>"
+  jq -c '.[]' <<<"$COMMENTS_JSON" | while read -r c; do
+    local raw_id id author body reactions reaction_groups
+    raw_id="$(jq -r '.id // .databaseId // ""' <<<"$c")"
+    author="$(jq -r '.author.login // ""' <<<"$c")"
+    body="$(jq -r '.body // ""' <<<"$c")"
+    reactions="$(jq -c '.reactions.nodes // []' <<<"$c")"
+    reaction_groups="$(jq -c '.reactionGroups // []' <<<"$c")"
+    [[ -n "$raw_id" ]] || continue
+    id="${raw_id//[^A-Za-z0-9_=-]/_}"
+    cache_item "$id" "comments" "$body"
+    parse_actionable "$(classify_actionable "$body" "$author" "false" "$reaction_groups")"
+    local actionable="$CA_ACTIONABLE" reason_attr="$CA_REASON_ATTR"
+    local cache_path="$DIR/comments/$id.md"
+    local sum_path="$DIR/comments/$id.summary.md"
+    # Generate the recap lazily, only for a settled (non-actionable) item with no
+    # summary yet; once written it persists and is emitted in either state so the
+    # agent can read it when the item later flips back to actionable.
+    if [[ "$actionable" == "false" && ! -f "$sum_path" ]]; then
+      summarize "$cache_path" "$sum_path" || true
+    fi
+    local inner=""
+    [[ -f "$sum_path" ]] && inner+="<summary>$(xml_text "$(cat "$sum_path")")</summary>"
+    inner+="$(reactions_xml_for "$reactions")"
+    if [[ -z "$inner" ]]; then
+      printf '    <comment id="%s" actionable="%s"%s cache="%s"/>\n' \
+        "$(xml_attr "$id")" "$actionable" "$reason_attr" "$(xml_attr "$cache_path")"
+    else
+      printf '    <comment id="%s" actionable="%s"%s cache="%s">%s</comment>\n' \
+        "$(xml_attr "$id")" "$actionable" "$reason_attr" "$(xml_attr "$cache_path")" "$inner"
+    fi
+  done
+  echo "  </comments>"
+}
+
+# --- review threads -----------------------------------------------------------
+threads_xml() {
+  echo "  <threads>"
+  jq -c '.[]' <<<"$THREADS_JSON" | while read -r t; do
+    local id resolved newest_body newest_author body
+    id="$(jq -r '.id // ""' <<<"$t")"
+    resolved="$(jq -r '.isResolved // false' <<<"$t")"
+    body="$(jq -r '[.comments.nodes[]? | "[" + (.author.login // "?") + "] " + (.body // "")] | join("\n\n---\n\n")' <<<"$t")"
+    newest_body="$(jq -r '.comments.nodes // [] | last.body // ""' <<<"$t")"
+    newest_author="$(jq -r '.comments.nodes // [] | last.author.login // ""' <<<"$t")"
+    [[ -n "$id" ]] || continue
+    id="${id//[^A-Za-z0-9_=-]/_}"
+    cache_item "$id" "threads" "$body"
+    parse_actionable "$(classify_actionable "$newest_body" "$newest_author" "$resolved")"
+    local actionable="$CA_ACTIONABLE" reason_attr="$CA_REASON_ATTR"
+    local cache_path="$DIR/threads/$id.md"
+    local sum_path="$DIR/threads/$id.summary.md"
+    # Generate the recap lazily for a settled (non-actionable) thread with none
+    # yet; it persists and is emitted in either state. When the thread flips back
+    # to actionable (a reviewer reply), the agent reads this recap plus the new
+    # content from the cache file instead of re-reading the whole thread.
+    if [[ "$actionable" == "false" && ! -f "$sum_path" ]]; then
+      summarize "$cache_path" "$sum_path" || true
+    fi
+    if [[ -f "$sum_path" ]]; then
+      printf '    <thread id="%s" actionable="%s"%s cache="%s"><summary>%s</summary></thread>\n' \
+        "$(xml_attr "$id")" "$actionable" "$reason_attr" "$(xml_attr "$cache_path")" "$(xml_text "$(cat "$sum_path")")"
+    else
+      printf '    <thread id="%s" actionable="%s"%s cache="%s"/>\n' \
+        "$(xml_attr "$id")" "$actionable" "$reason_attr" "$(xml_attr "$cache_path")"
+    fi
+  done
+  echo "  </threads>"
+}
+
+# --- annotations (code scanning / check annotations) --------------------------
+annotations_xml() {
+  echo "  <annotations>"
+  local owner="${REPO%/*}" repo="${REPO#*/}"
+  local sha; sha="$(jq -r .headRefOid <<<"$PR_JSON")"
+  local runs
+  runs="$(gh api "repos/$owner/$repo/commits/$sha/check-runs" --jq '.check_runs // []' 2>/dev/null || echo '[]')"
+  jq -c '.[]' <<<"$runs" | while read -r run; do
+    local run_id; run_id="$(jq -r '.id' <<<"$run")"
+    gh api "repos/$owner/$repo/check-runs/$run_id/annotations" 2>/dev/null \
+      | jq -c '.[]?' | while read -r a; do
+      local path line msg id body
+      path="$(jq -r '.path // ""' <<<"$a")"
+      line="$(jq -r '.start_line // 0' <<<"$a")"
+      msg="$(jq -r '.message // ""' <<<"$a")"
+      body="[$path:$line] $msg"
+      id="$(printf '%s' "$body" | sha256sum | cut -c1-16)"
+      cache_item "$id" "annotations" "$body"
+      local ack="$DIR/annotations/$id.ack"
+      local cache_path="$DIR/annotations/$id.md"
+      local sum_path="$DIR/annotations/$id.summary.md"
+      if [[ -f "$ack" ]]; then
+        [[ -f "$sum_path" ]] || summarize "$cache_path" "$sum_path" || true
+        # The summary is best-effort: an acked annotation is still emitted, and
+        # still non-actionable, when the summary could not be generated.
+        if [[ -f "$sum_path" ]]; then
+          printf '    <annotation id="%s" actionable="false" reason="acked" cache="%s"><summary>%s</summary></annotation>\n' \
+            "$(xml_attr "$id")" "$(xml_attr "$cache_path")" "$(xml_text "$(cat "$sum_path")")"
+        else
+          printf '    <annotation id="%s" actionable="false" reason="acked" cache="%s"/>\n' \
+            "$(xml_attr "$id")" "$(xml_attr "$cache_path")"
+        fi
+      else
+        printf '    <annotation id="%s" actionable="true" cache="%s"/>\n' \
+          "$(xml_attr "$id")" "$(xml_attr "$cache_path")"
+      fi
+    done
+  done
+  echo "  </annotations>"
+}
+
+# --- terminal resolution ------------------------------------------------------
+# Returns 0 if the PR's net change is present in the base tip (shipped), 1 if
+# not (abandoned), 2 if the check could not run (no repo / git or fetch failure).
+# Squash/rebase-safe: builds the PR's combined net patch and reverse-applies it
+# against a temp index seeded from the base tip, so an n→1 squash or a rebase
+# rewrite still matches by content (per-commit patch-ids, which `git cherry`
+# uses, break under squash). Side-effect-free — never touches the caller's
+# worktree, index, or HEAD. An empty net patch (no-op PR) reverse-applies
+# trivially → present → shipped, which is intended.
+content_present() {
+  local base_ref="$1"
+  command -v git >/dev/null 2>&1 || return 2
+  git rev-parse --git-dir >/dev/null 2>&1 || return 2
+
+  # Fetch the head commit by SHA via refs/pull/<n>/head — the head branch may
+  # have been deleted on close, but GitHub keeps the SHA reachable here.
+  git fetch --quiet origin "refs/pull/$PR_NUMBER/head" 2>/dev/null || return 2
+  local head_sha; head_sha="$(git rev-parse --verify --quiet FETCH_HEAD)" || return 2
+  [[ -n "$head_sha" ]] || return 2
+
+  # Fetch the base tip (FETCH_HEAD gets overwritten, so head_sha is captured first).
+  git fetch --quiet origin "$base_ref" 2>/dev/null || return 2
+  local base_sha; base_sha="$(git rev-parse --verify --quiet FETCH_HEAD)" || return 2
+  [[ -n "$base_sha" ]] || return 2
+
+  local mb; mb="$(git merge-base "$base_sha" "$head_sha" 2>/dev/null)" || return 2
+  [[ -n "$mb" ]] || return 2
+
+  # No-op PR: an empty net patch is trivially present in base → shipped. Must be
+  # short-circuited because `git apply --check` rejects empty input ("No valid
+  # patches in input"), which would otherwise misclassify a no-op PR as abandoned.
+  if git diff --quiet "$mb" "$head_sha" 2>/dev/null; then
+    return 0
+  fi
+
+  # Reverse-apply the net patch against a temp index seeded from the base tip.
+  # `rm -f` the mktemp file so the index path is free: some git versions read an
+  # existing empty GIT_INDEX_FILE as a corrupt index, failing read-tree. Clean up
+  # inline rather than via a RETURN trap — a RETURN trap would re-fire on the
+  # *caller's* return and, under `set -u`, abort the rest of the XML emission.
+  local tmp_index; tmp_index="$(mktemp)" || return 2
+  rm -f "$tmp_index"
+  if ! GIT_INDEX_FILE="$tmp_index" git read-tree "$base_sha" 2>/dev/null; then
+    rm -f "$tmp_index"
+    return 2
+  fi
+  # --binary emits an applyable full binary patch; without it git diff writes a
+  # "Binary files differ" placeholder that git apply rejects, misclassifying any
+  # PR touching binary files as abandoned.
+  local rc=1
+  if git diff --binary "$mb" "$head_sha" \
+       | GIT_INDEX_FILE="$tmp_index" git apply --reverse --cached --check - 2>/dev/null; then
+    rc=0
+  fi
+  rm -f "$tmp_index"
+  return "$rc"
+}
+
+# Resolve the PR's terminal end-to-end and emit <terminal>. Binary at closure
+# (shipped|abandoned); non-terminal while the PR is live (open|draft). Cheapest
+# signals first; git is shelled only on the CLOSED-but-not-merged + ahead_by>0
+# branch, never on the hot poll loop. Carries the raw signals it used.
+terminal_xml() {
+  local state merged_at base_ref head_oid is_draft
+  state="$(jq -r '.state // ""' <<<"$PR_JSON")"
+  merged_at="$(jq -r '.mergedAt // ""' <<<"$PR_JSON")"
+  base_ref="$(jq -r '.baseRefName // ""' <<<"$PR_JSON")"
+  head_oid="$(jq -r '.headRefOid // ""' <<<"$PR_JSON")"
+  is_draft="$(jq -r '.isDraft // false' <<<"$PR_JSON")"
+
+  local gh_merged=false
+  [[ "$state" == "MERGED" || ( -n "$merged_at" && "$merged_at" != "null" ) ]] && gh_merged=true
+
+  # Non-terminal: PR still open.
+  if [[ "$state" == "OPEN" ]]; then
+    local s=open; [[ "$is_draft" == "true" ]] && s=draft
+    printf '  <terminal state="%s" gh-merged="%s" ahead-by="-"/>\n' "$s" "$gh_merged"
+    return
+  fi
+
+  # Step 1: GitHub says merged → shipped. API only.
+  if [[ "$gh_merged" == "true" ]]; then
+    printf '  <terminal state="shipped" gh-merged="true" ahead-by="-"/>\n'
+    return
+  fi
+
+  # CLOSED without `merged`. Step 2: one three-dot compare call, read ahead_by.
+  # ahead_by == 0 → every head commit is already in base (plain merge /
+  # fast-forward / merge-queue close where GitHub never set merged) → shipped,
+  # no git. Works even if the head branch was deleted — compare accepts the SHA.
+  local ahead_by
+  ahead_by="$(gh api "repos/$OWNER/$REPO_NAME/compare/$base_ref...$head_oid" \
+    --jq '.ahead_by' 2>/dev/null || echo "")"
+
+  if [[ "$ahead_by" == "0" ]]; then
+    printf '  <terminal state="shipped" gh-merged="false" ahead-by="0"/>\n'
+    return
+  fi
+
+  # ahead_by > 0 (or compare failed): could be squash/rebase-landed or genuinely
+  # abandoned; the API can't tell. Step 3: content check via git (the only path
+  # that shells git). On no-repo / fetch failure we do NOT guess — emit abandoned
+  # with an error breadcrumb so delivery is never falsely claimed.
+  local ab_attr="${ahead_by:--}"
+  local rc=0
+  if content_present "$base_ref"; then rc=0; else rc=$?; fi
+  case "$rc" in
+    0) printf '  <terminal state="shipped" gh-merged="false" ahead-by="%s"/>\n' "$ab_attr" ;;
+    1) printf '  <terminal state="abandoned" gh-merged="false" ahead-by="%s"/>\n' "$ab_attr" ;;
+    *) printf '  <terminal state="abandoned" gh-merged="false" ahead-by="%s" error="content-check-unavailable"/>\n' "$ab_attr" ;;
+  esac
+}
+
+# --- emit ---------------------------------------------------------------------
+printf '<pr-status repo="%s" pr="%s" head="%s">\n' \
+  "$(xml_attr "$REPO")" "$(xml_attr "$PR")" "$(xml_attr "$HEAD")"
+terminal_xml
+checks_xml
+conflicts_xml
+reviews_xml
+comments_xml
+threads_xml
+annotations_xml
+echo '</pr-status>'