npm - @delorenj/pjangler - Versions diffs - 1.4.2 → 1.4.4 - Mend

@delorenj/pjangler 1.4.2 → 1.4.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (39) hide show

package/templates/hermes-agent/template/.scripts/providers/trello.sh CHANGED Viewed

@@ -81,8 +81,14 @@ list_id_for() {
   [ -n "$BOARD" ] || die "ticket_provider.board not set"
   want="$(list_name_for "$1")"
   api GET "boards/$BOARD/lists" | NM="$want" python3 -c 'import sys,json,os
-rows=json.load(sys.stdin); nm=os.environ["NM"].lower()
-print(next((l["id"] for l in rows if l.get("name","").lower()==nm), ""))'
+rows=json.load(sys.stdin); nm=os.environ["NM"].strip().casefold()
+matches=[row for row in rows if str(row.get("name") or "").strip().casefold()==nm]
+if len(matches) != 1:
+    raise SystemExit("trello: exact list name %r resolved %d lists; exactly one is required" % (os.environ["NM"], len(matches)))
+list_id=str(matches[0].get("id") or "")
+if not list_id:
+    raise SystemExit("trello: resolved list omitted its id")
+print(list_id)'
 }
 # All Trello ops require credentials; fail fast and clean before any pipe.
@@ -134,14 +140,52 @@ print(json.dumps({"id":c.get("id",""),"key":c.get("id",""),"title":c.get("name",
   comment)
     ID="${1:?usage: comment <id> <body>}"; BODY="${2:?}"
     api POST "cards/$ID/actions/comments" "text=$(python3 -c 'import urllib.parse,sys; print(urllib.parse.quote(sys.argv[1]))' "$BODY")" \
-      | python3 -c 'import sys,json; print(json.load(sys.stdin).get("id",""))'
+      | EXPECTED_ID="$ID" python3 -c 'import sys,json,os
+action=json.load(sys.stdin)
+if not isinstance(action,dict):
+    raise SystemExit("trello: comment response was not an action object")
+action_id=action.get("id")
+if not isinstance(action_id,str) or not action_id.strip():
+    raise SystemExit("trello: comment response omitted its action id")
+data=action.get("data")
+card=data.get("card") if isinstance(data,dict) else None
+if not isinstance(card,dict) or str(card.get("id") or "").strip()!=os.environ["EXPECTED_ID"]:
+    raise SystemExit("trello: comment response did not identify the requested card")
+print(action_id.strip())'
     ;;
   transition)
     ID="${1:?usage: transition <id> <normalized-state>}"; TARGET="${2:?}"
     LID="$(list_id_for "$TARGET")"
     [ -n "$LID" ] || die "no Trello list mapped for normalized '$TARGET' (check state_map)"
-    api PUT "cards/$ID" "idList=$LID" | python3 -c 'import sys,json; c=json.load(sys.stdin); print("ok "+c.get("id",""))'
+    api PUT "cards/$ID" "idList=$LID" >/dev/null
+    api GET "cards/$ID" "fields=id,idList" \
+      | EXPECTED_ID="$ID" EXPECTED_LIST_ID="$LID" python3 -c 'import sys,json,os
+card=json.load(sys.stdin)
+if str(card.get("id") or "") != os.environ["EXPECTED_ID"]:
+    raise SystemExit("trello: transition read-back did not identify the requested card")
+if str(card.get("idList") or "") != os.environ["EXPECTED_LIST_ID"]:
+    raise SystemExit("trello: transition read-back did not confirm the exact target list")
+print("ok " + str(card.get("id") or ""))'
+    ;;
+  describe_board)
+    # Read-only board lookup against an EXPLICIT workspace argument, mirroring
+    # the Plane op, so no ambient binding can send the query somewhere else.
+    # Trello mints NO project key, so `identifier` is ALWAYS empty here: an
+    # empty identifier is this provider's authoritative answer, not a lookup
+    # failure, and callers must never promote it to a confirmed value.
+    DWS="${1:?usage: describe_board <workspace> <board_id>}"
+    DBID="${2:?usage: describe_board <workspace> <board_id>}"
+    api GET "boards/$DBID" "fields=id,name,idOrganization" \
+      | WS="$DWS" BID="$DBID" python3 -c 'import sys, json, os
+b = json.load(sys.stdin)
+print(json.dumps({
+    "board_id": str(b.get("id") or os.environ["BID"]),
+    "identifier": "",
+    "workspace": str(b.get("idOrganization") or os.environ["WS"]),
+    "name": str(b.get("name") or ""),
+}))'
     ;;
   create_board)
@@ -154,8 +198,12 @@ print(next((b["id"] for b in rows if b.get("name","").lower()==nm), ""))')"
         | python3 -c 'import sys,json; print(json.load(sys.stdin).get("id",""))')"
     fi
     [ -n "$BID" ] || die "create_board failed"
-    api GET "boards/$BID" "fields=url" | BID="$BID" python3 -c 'import sys,json,os
-b=json.load(sys.stdin); print(json.dumps({"board_id":os.environ["BID"],"board_url":b.get("url","")}))'
+    # Trello assigns no project key, so the caller's prefix IS the identity and
+    # this adapter is the only thing that can confirm it. Echo it back: the
+    # create_board envelope always carries the identifier the board is bound
+    # under, so no caller ever has to invent one.
+    api GET "boards/$BID" "fields=url" | BID="$BID" IDENT="${2:-}" python3 -c 'import sys,json,os
+b=json.load(sys.stdin); print(json.dumps({"board_id":os.environ["BID"],"board_url":b.get("url",""),"identifier":os.environ.get("IDENT","")}))'
     ;;
   create_issue)

package/templates/hermes-agent/template/.scripts/sentinel/bin/issue-autonomous-review.sh CHANGED Viewed

@@ -2,8 +2,8 @@
 # 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
+# adversarial microscope that couples the close gate with an independent-reviewer
+# drift attestation. 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
@@ -40,44 +40,246 @@ 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="${RECONCILE_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"
+role_mapping_value() {
+  python3 - "$ROLE_YAML" "$1" "$2" <<'PY'
+import pathlib
+import re
+import sys
-if [[ "${RECONCILE_AUTO_REVIEW:-$AUTO}" == "false" || "${RECONCILE_AUTO_REVIEW:-}" == "off" ]]; then
-  printf 'Autonomous review is disabled (reconcile.auto_review=false).\n' >&2; exit 3
-fi
+path = pathlib.Path(sys.argv[1])
+section = sys.argv[2]
+key = sys.argv[3]
+text = path.read_text(encoding="utf-8") if path.is_file() else ""
+lines = text.splitlines()
+headers = [
+    index
+    for index, line in enumerate(lines)
+    if re.fullmatch(rf"{re.escape(section)}:\s*(?:#.*)?", line)
+]
+if not headers:
+    print("")
+    raise SystemExit(0)
+if len(headers) != 1:
+    raise SystemExit(f"role config has duplicate top-level {section!r} mappings")
+block = []
+for line in lines[headers[0] + 1 :]:
+    if line.strip() and not line[0].isspace() and not line.lstrip().startswith("#"):
+        break
+    block.append(line)
+content = [
+    line
+    for line in block
+    if line.strip() and not line.lstrip().startswith("#") and line[0].isspace()
+]
+if not content:
+    print("")
+    raise SystemExit(0)
+direct_indent = min(len(line) - len(line.lstrip()) for line in content)
+matches = []
+for line in content:
+    if len(line) - len(line.lstrip()) != direct_indent:
+        continue
+    match = re.fullmatch(rf"\s{{{direct_indent}}}{re.escape(key)}:\s*(.*?)\s*", line)
+    if match:
+        matches.append(match.group(1))
+if len(matches) > 1:
+    raise SystemExit(f"role config has duplicate {section}.{key} values")
+value = matches[0] if matches else ""
+value = re.sub(r"\s+#.*$", "", value).strip()
+if len(value) >= 2 and value[0] == value[-1] and value[0] in "\"'":
+    value = value[1:-1]
+print(value.strip())
+PY
+}
+# Informational only: recorded in the ticket comment, never a blocking wait.
+# Default 0 (no grace); an operator may set grace_hours>0 to reintroduce one.
+ROLE_GRACE_HOURS="$(role_mapping_value reconcile grace_hours)"
+GRACE_HOURS="${RECONCILE_GRACE_HOURS:-$ROLE_GRACE_HOURS}"
+GRACE_HOURS="$(printf '%s' "${GRACE_HOURS:-0}" | sed 's/^[[:space:]]*//; s/[[:space:]]*$//')"
+case "$GRACE_HOURS" in
+  ''|*[!0-9]*)
+    printf "AUTONOMOUS REVIEW: CONFIG INVALID - reconcile.grace_hours must be a nonnegative integer (got '%s').\n" "$GRACE_HOURS" >&2
+    exit 3
+    ;;
+esac
+GRACE_HOURS="$(python3 -c 'import sys; print(int(sys.argv[1]))' "$GRACE_HOURS")"
+ROLE_AUTO="$(role_mapping_value reconcile auto_review)"
+AUTO="${RECONCILE_AUTO_REVIEW:-$ROLE_AUTO}"
+AUTO="$(printf '%s' "${AUTO:-true}" | sed 's/^[[:space:]]*//; s/[[:space:]]*$//' | tr '[:upper:]' '[:lower:]')"
+case "$AUTO" in
+  true|on) : ;;
+  false|off)
+    printf 'Autonomous review is disabled (reconcile.auto_review=%s).\n' "$AUTO" >&2
+    exit 3
+    ;;
+  *)
+    printf "AUTONOMOUS REVIEW: CONFIG INVALID - reconcile.auto_review must be true|on|false|off (got '%s').\n" "$AUTO" >&2
+    exit 3
+    ;;
+esac
 [[ -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')"
+# Structural parse of the review report (and the evidence's implementer
+# identity): every required H2 exactly once, each authoritative field read
+# only as a direct field of its own section. Lookalike bullets or examples in
+# other sections can never stand in for -- or override -- the authoritative
+# value, and duplicate/missing/blank sections or fields are rejected here,
+# before any provider call.
+PARSED=""
+if ! PARSED="$(python3 - "$REPORT" "$EVIDENCE" <<'PY'
+import re
+import sys
+report_path, evidence_path = sys.argv[1], sys.argv[2]
+heading = re.compile(r"^(#{1,6})\s+(.*?)\s*$")
+def parse_sections(path):
+    with open(path, encoding="utf-8") as stream:
+        lines = stream.read().splitlines()
+    sections = {}
+    order = []
+    current = None
+    for line in lines:
+        match = heading.match(line)
+        if match and len(match.group(1)) <= 2:
+            current = match.group(2) if len(match.group(1)) == 2 else None
+            if current is not None:
+                sections.setdefault(current, [])
+                order.append(current)
+            continue
+        if current is not None:
+            sections[current].append(line)
+    return sections, order
+def direct_fields(sections, section, *names):
+    found = []
+    for line in sections.get(section, []):
+        for name in names:
+            match = re.fullmatch(
+                r"\s*(?:[-*+]\s+)?" + re.escape(name) + r"\s*:\s*(.*?)\s*", line
+            )
+            if match:
+                found.append(match.group(1))
+                break
+    return found
+errors = []
+out = {}
+sections, order = parse_sections(report_path)
+for name in (
+    "Reviewer",
+    "Locked Intent Baseline",
+    "Drift Assessment",
+    "Adversarial Findings",
+    "Decision",
+):
+    count = order.count(name)
+    if count == 0:
+        errors.append(f"report missing section {name}")
+    elif count > 1:
+        errors.append(f"report has duplicate {name} sections")
+def report_field(section, name):
+    if order.count(section) != 1:
+        return ""
+    found = direct_fields(sections, section, name)
+    if len(found) != 1:
+        errors.append(
+            f"report section {section} must contain exactly one"
+            f" '{name}:' field (found {len(found)})"
+        )
+        return ""
+    if not found[0]:
+        errors.append(f"report field '{name}:' in section {section} is blank")
+        return ""
+    return found[0]
+def first_token(value):
+    tokens = value.split()
+    return tokens[0].lower() if tokens else ""
+out["reviewer"] = report_field("Reviewer", "Reviewer agent")
+out["independent"] = first_token(report_field("Reviewer", "Independent of implementer"))
+out["drift"] = first_token(report_field("Drift Assessment", "Drift assessment"))
+out["findings"] = first_token(report_field("Adversarial Findings", "Critical/high findings"))
+out["decision"] = first_token(report_field("Decision", "Decision"))
+evidence_sections, evidence_order = parse_sections(evidence_path)
+implementer = ""
+if evidence_order.count("Issue") != 1:
+    errors.append(
+        "evidence must contain exactly one Issue section carrying the"
+        " implementer identity"
+    )
+else:
+    found = direct_fields(evidence_sections, "Issue", "Worker", "Implemented by")
+    if len(found) != 1:
+        errors.append(
+            "evidence section Issue must contain exactly one implementer"
+            " identity ('Worker:' / 'Implemented by:') field"
+            f" (found {len(found)})"
+        )
+    elif not found[0]:
+        errors.append("evidence implementer identity in section Issue is blank")
+    else:
+        implementer = found[0]
+out["implementer"] = implementer
+for key, value in out.items():
+    print("F\t{}\t{}".format(key, value.replace("\t", " ").replace("\n", " ")))
+for error in errors:
+    print(f"E\t{error}")
+PY
+)"; then
+  hold "review report could not be parsed"
+fi
+REVIEWER=""; INDEP=""; DRIFT=""; FINDINGS=""; DEC=""; IMPL=""
+while IFS="$(printf '\t')" read -r kind key value; do
+  case "$kind" in
+    E) hold "$key" ;;
+    F)
+      case "$key" in
+        reviewer) REVIEWER="$value" ;;
+        independent) INDEP="$value" ;;
+        drift) DRIFT="$value" ;;
+        findings) FINDINGS="$value" ;;
+        decision) DEC="$value" ;;
+        implementer) IMPL="$value" ;;
+      esac
+      ;;
+  esac
+done <<EOF
+$PARSED
+EOF
+REVIEWER="${REVIEWER:-unknown}"
+[[ "$INDEP" == "yes" ]] || hold "reviewer did not attest independence"
 [[ -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)"
+[[ "$FINDINGS" == "none" ]] || hold "unresolved critical/high findings (or field 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
@@ -85,40 +287,52 @@ if sh "$CLOSE_GATE" "$ISSUE" "$ROOT" >/dev/null 2>&1 </dev/null; then GATE=pass;
 if [[ -n "$HOLD" ]]; then DECISION=held; else DECISION=accepted; fi
-python3 "$EMIT" "$EVT" --root "$ROOT" \
-  --source "repo://sentinel/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"
+PROV="$(role_mapping_value ticket_provider name)"; PROV="${PROV:-}"
 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
+  if ! TICKET_PROVIDER="$PROV" bash -c '. "$1"; tp transition "$2" completed' _ "$SCRIPTS_DIR/lib/ticket-provider.sh" "$ISSUE" \
+    >/dev/null 2>&1; then
+    printf 'AUTONOMOUS REVIEW: CLOSE FAILED for %s - adapter transition failed; issue left open.\n' "$ISSUE" >&2
+    exit 1
+  fi
+  COMMENT_ID=""
+  if ! COMMENT_ID="$(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." 2>/dev/null)"; then
+    printf 'AUTONOMOUS REVIEW: CLOSE INCOMPLETE for %s - transition succeeded, but acceptance comment failed; issue may already be completed.\n' "$ISSUE" >&2
     exit 1
   fi
+  if [[ ! "$COMMENT_ID" =~ [^[:space:]] ]]; then
+    printf 'AUTONOMOUS REVIEW: CLOSE INCOMPLETE for %s - transition succeeded, but acceptance comment returned no id; comment write unproven and issue may already be completed.\n' "$ISSUE" >&2
+    exit 1
+  fi
+  # Acceptance is an assertion about both required writes on this path, so no
+  # acceptance-shaped output may escape until transition and comment succeed.
+  printf 'AUTONOMOUS REVIEW: ACCEPTED - treat as done (no human wait) for %s (reviewer: %s | drift: %s | gate: %s)\n' \
+    "$ISSUE" "$REVIEWER" "$DRIFT" "$GATE"
+  printf 'Ticket %s transitioned to completed via adapter.\n' "$ISSUE"
 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
+  COMMENT_ID=""
+  if ! COMMENT_ID="$(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." 2>/dev/null)"; then
+    printf 'AUTONOMOUS REVIEW: COMMENT FAILED for %s - acceptance comment was not recorded; issue left in review.\n' "$ISSUE" >&2
+    exit 1
+  fi
+  if [[ ! "$COMMENT_ID" =~ [^[:space:]] ]]; then
+    printf 'AUTONOMOUS REVIEW: COMMENT UNPROVEN for %s - acceptance comment returned no id; issue left in review.\n' "$ISSUE" >&2
+    exit 1
+  fi
+  printf 'AUTONOMOUS REVIEW: ACCEPTED - treat as done (no human wait) for %s (reviewer: %s | drift: %s | gate: %s)\n' \
+    "$ISSUE" "$REVIEWER" "$DRIFT" "$GATE"
   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

package/templates/hermes-agent/template/.scripts/sentinel/bin/issue-close-gate.sh CHANGED Viewed

@@ -1,7 +1,7 @@
 #!/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.
+# before any closure (manual or autonomous). Pure gate: it reports PASS/FAIL on
+# stdout/stderr and via the exit code, and publishes nothing.
 #
 # Usage: issue-close-gate.sh ISSUE_ID [REPO_ROOT]
 set -eu
@@ -14,49 +14,166 @@ 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"
+ROLE_YAML="$BIN_DIR/../../../role.yaml"
+ROLE_REPO="$(sed -n 's/^repo:[[:space:]]*//p' "$ROLE_YAML" 2>/dev/null | head -n1 | tr -d '"' | tr -d '\r')"
 ROOT="${2:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"
 cd "$ROOT"
+ROOT="$(pwd -P)"
+PROJECT_MANIFEST="$ROOT/.project.json"
+if [ -e "$PROJECT_MANIFEST" ] || [ -L "$PROJECT_MANIFEST" ]; then
+  [ -f "$PROJECT_MANIFEST" ] || {
+    printf 'Project manifest is not a regular file: %s\n' "$PROJECT_MANIFEST" >&2
+    exit 1
+  }
+  REPO_SLUG="$(python3 - "$PROJECT_MANIFEST" <<'PY'
+import json
+import pathlib
+import sys
-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"
+path = pathlib.Path(sys.argv[1])
+try:
+    document = json.loads(path.read_text(encoding="utf-8"))
+except (OSError, UnicodeError, json.JSONDecodeError) as exc:
+    raise SystemExit(f"close gate: malformed project manifest {path}: {exc}")
+slug = document.get("project_slug") if isinstance(document, dict) else None
+if not isinstance(slug, str) or not slug.strip():
+    raise SystemExit(f"close gate: project manifest {path} has no non-blank project_slug")
+print(slug.strip())
+PY
+)" || exit 1
+else
+  REPO_SLUG="$(basename "$ROOT")"
+fi
+if [ -n "$ROLE_REPO" ] && [ "$ROLE_REPO" != "$REPO_SLUG" ]; then
+  printf 'Installed role repo %s disagrees with target project slug %s.\n' "$ROLE_REPO" "$REPO_SLUG" >&2
+  exit 1
+fi
 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'
+# Structural parse: every required H2 exactly once, and each authoritative
+# field read only as a direct field of its own section. Lookalike lines in
+# other sections can never stand in for -- or override -- the authoritative
+# value (an authoritative `no`/`hold` always fails the gate). The implementer
+# identity is defined as exactly one nonblank `Worker:` / `Implemented by:`
+# field in the Issue section; duplicates, blanks, and conflicting spellings
+# are rejected.
+GATE_PROBLEMS=""
+if ! GATE_PROBLEMS="$(python3 - "$FILE" <<'PY'
+import re
+import sys
+with open(sys.argv[1], encoding="utf-8") as stream:
+    lines = stream.read().splitlines()
+REQUIRED = [
+    "Issue",
+    "Acceptance Criteria",
+    "Repo Changes",
+    "Verification",
+    "Ledger Update",
+    "Known Gaps",
+    "Close Recommendation",
+]
+heading = re.compile(r"^(#{1,6})\s+(.*?)\s*$")
+sections = {}
+order = []
+current = None
+for line in lines:
+    match = heading.match(line)
+    if match and len(match.group(1)) <= 2:
+        current = match.group(2) if len(match.group(1)) == 2 else None
+        if current is not None:
+            sections.setdefault(current, [])
+            order.append(current)
+        continue
+    if current is not None:
+        sections[current].append(line)
+problems = []
+for name in REQUIRED:
+    count = order.count(name)
+    if count == 0:
+        problems.append(f"Missing required evidence: {name}")
+    elif count > 1:
+        problems.append(f"Duplicate required evidence section: {name}")
+def direct_fields(section, *names):
+    found = []
+    for line in sections.get(section, []):
+        for name in names:
+            match = re.fullmatch(
+                r"\s*(?:[-*+]\s+)?" + re.escape(name) + r"\s*:\s*(.*?)\s*", line
+            )
+            if match:
+                found.append(match.group(1))
+                break
+    return found
+def first_token(value):
+    tokens = value.split()
+    return tokens[0].lower() if tokens else ""
+if order.count("Ledger Update") == 1:
+    found = direct_fields("Ledger Update", "Ledger updated")
+    if len(found) != 1:
+        problems.append(
+            "Expected exactly one 'Ledger updated:' field in '## Ledger Update'"
+            f" (found {len(found)})."
+        )
+    elif first_token(found[0]) != "yes":
+        problems.append("Ledger update is not marked yes.")
+if order.count("Close Recommendation") == 1:
+    found = direct_fields("Close Recommendation", "Close recommendation")
+    if len(found) != 1:
+        problems.append(
+            "Expected exactly one 'Close recommendation:' field in"
+            f" '## Close Recommendation' (found {len(found)})."
+        )
+    elif first_token(found[0]) != "ready":
+        problems.append("Close recommendation is not ready.")
+if order.count("Issue") == 1:
+    found = direct_fields("Issue", "Worker", "Implemented by")
+    if len(found) != 1:
+        problems.append(
+            "Expected exactly one implementer identity ('Worker:' /"
+            f" 'Implemented by:') in '## Issue' (found {len(found)})."
+        )
+    elif not found[0]:
+        problems.append("The implementer identity in '## Issue' is blank.")
+for problem in problems:
+    print(problem)
+PY
+)"; then
+  printf 'Evidence file could not be parsed: %s\n' "$FILE" >&2
+  exit 1
+fi
+if [ -n "$GATE_PROBLEMS" ]; then
+  printf '%s\n' "$GATE_PROBLEMS" >&2
+  FAIL=1
+fi
 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://sentinel/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://sentinel/bin/issue-close-gate.sh" \
-  --field issue="$ISSUE" --field evidence_file="$FILE" --quiet </dev/null || true
-printf 'CLOSE GATE: PASS for %s\n' "$ISSUE"
+printf 'CLOSE GATE: PASS for %s (repo: %s)\n' "$ISSUE" "$REPO_SLUG"