@plainconceptsplatform/workflows 0.20.1 → 0.20.2

package/loops/actions/housekeeping/action.yml

@@ -96,7 +96,13 @@ runs:
           for (const issue of issues) {
             if (issue.pull_request) continue;
             const labels = names(issue);
-            if (!labels.includes('review')) continue;
+            // `stalled` alone is enough to be looked at. This used to require `review`, on the
+            // assumption that a park always sets both, and an issue that ended up carrying
+            // `stalled` without it fell through every branch below: never retried, never
+            // reported, invisible. One sat that way for thirty hours in a consumer with
+            // `implement` still on it and a janitor running every six hours past it. `stalled`
+            // is the marker the retry keys on, so it is what decides whether to look.
+            if (!labels.includes('review') && !labels.includes('stalled')) continue;
 
             const comments = await github.paginate(github.rest.issues.listComments, {
               ...context.repo, issue_number: issue.number, per_page: 100,

package/loops/actions/validate-review-output/validate-review-output.sh

@@ -15,16 +15,30 @@ if [ ! -f "$output_file" ] || [ ! -f "$threads_file" ] \
   exit 0
 fi
 
+# Every jq error becomes "invalid" rather than a non-zero exit, the way the merge gate's
+# validator already does it. A crash here fails the step, which skips the apply job and parks
+# the issue as stalled -- while the agent's fix is already pushed and sitting on the branch.
+# Output the workflow cannot read is an outcome to report, not a reason to fall over.
 jq -r --arg pr "$pr_number" --slurpfile threads "$threads_file" '
+  def decide:
   .items as $items
   | ($threads[0] | map(select(.isResolved == false and .isOutdated == false) | .id) | sort) as $expected
   | ($items | [.[] | select(.type == "add_comment" and (.item_number | tostring) == $pr and (.body | type == "string"))]) as $comments
   | ($comments | map(.body | if test("\\*\\*Review outcome:\\*\\*\\s*(implemented|already-satisfied|needs-human)"; "i") then capture("\\*\\*Review outcome:\\*\\*\\s*(?<v>implemented|already-satisfied|needs-human)"; "i").v | ascii_downcase else empty end) | .[0] // "invalid") as $outcome
-  | ($comments | map(.body | scan("PRRT_[A-Za-z0-9_=-]+")) | add | unique | sort) as $reported
+  # `add` on an empty array is null, not [], and `unique` then dies with "Cannot iterate over
+  # null". That is not an edge case: it is every pull-request-level review. Requesting changes
+  # from the Files tab, or a plain review body with no inline comment, creates a review and no
+  # thread, so both sides of this comparison are empty and the validator crashed instead of
+  # agreeing. The agent had already read the feedback, pushed the fix and reported it; the run
+  # was marked failed, the issue was labelled stalled, and the board said nothing landed while
+  # the commit sat on the branch.
+  | ($comments | map(.body | [scan("PRRT_[A-Za-z0-9_=-]+")]) | add // [] | unique | sort) as $reported
   | ([$items[] | select(.type == "push_to_pull_request_branch")] | length) as $pushes
   | if $expected != $reported then "invalid"
     elif $outcome == "implemented" and $pushes == 1 then "implemented"
     elif ($outcome == "already-satisfied" or $outcome == "needs-human") and $pushes == 0 then $outcome
     else "invalid"
-    end
+    end;
+
+  try decide catch "invalid"
 ' "$output_file"

package/loops/actions/verify-route-matrix/verify-gate-metrics.mjs

@@ -48,4 +48,19 @@ check("lists every disposition it saw",
   run({ "auto-merge": 1, blocked: 2 }, [], []),
   (s) => s.includes("`blocked` · 2") && s.includes("`auto-merge` · 1"));
 
+
+// The triage loop's entry guard. An issue carrying `stalled` is the janitor's to retry; one
+// carrying `stalled` without `review` used to be skipped before any branch could see it, so it
+// was neither retried nor reported. Extracted and run rather than grepped, because "which
+// issues does this loop even look at" is exactly the kind of condition a grep reads past.
+const guardSrc = yml.match(/if \(!labels\.includes\('review'\)[^\n]*\n/);
+if (!guardSrc) { console.error("FAIL: housekeeping has no triage entry guard"); process.exit(1); }
+const looksAt = (labels) => !new Function("labels", `return ${guardSrc[0].trim().replace(/^if \(/, "").replace(/\)\s*continue;$/, "")};`)(labels);
+
+check("looks at a parked issue (review + stalled)", looksAt(["review", "stalled", "implement"]), true);
+check("looks at a decided issue (review only)", looksAt(["review", "implement"]), true);
+check("looks at an orphaned stall (stalled, no review)", looksAt(["stalled", "implement"]), true);
+check("ignores an issue with neither", looksAt(["implement", "sp-2"]), false);
+check("ignores a plain refined issue", looksAt(["refined"]), false);
+
 process.exit(failed);

package/loops/actions/verify-route-matrix/verify-route-matrix.sh

@@ -1319,6 +1319,52 @@ level=low")
   if [ "$BLAST_OK" -eq 1 ]; then PASS=$((PASS + 1)); else FAIL=$((FAIL + 1)); fi
 fi
 
+# apply-review's validator compares the unresolved review threads on a pull request against the
+# thread ids the agent reported handling. Two jq shapes broke it for every input: `add` on an
+# empty array is null, so a pull-request-level review with no inline thread crashed on `unique`,
+# and `scan` without a capture group emits strings, so `add` concatenated them and `unique`
+# crashed on a string. The agent had already pushed the fix; the run was marked failed and the
+# issue labelled stalled while the commit sat on the branch.
+REVIEW_VALIDATOR="${HERE}/../validate-review-output/validate-review-output.sh"
+if [ -f "$REVIEW_VALIDATOR" ] && worker_installed apply-review; then
+  REVIEW_OK=1
+  rv_fixture="${TMPDIR:-/tmp}/route-matrix-review-$$"
+
+  rv_case() {
+    local name="$1" want="$2" threads="$3" items="$4" got
+    printf '%s' "$threads" > "${rv_fixture}-threads.json"
+    printf '%s' "$items" > "${rv_fixture}-out.json"
+    # `|| true`: a validator that crashes must show up as a failed case, not kill this script.
+    got=$(bash "$REVIEW_VALIDATOR" "${rv_fixture}-out.json" 181 "${rv_fixture}-threads.json" 2>&1 || true)
+    if [ "$got" != "$want" ]; then
+      REVIEW_OK=0
+      echo "FAIL: the apply-review validator called '${name}' ${got}, expected ${want}" >&2
+    fi
+  }
+
+  rv_impl() { printf '{"items":[{"type":"add_comment","item_number":181,"body":"**Review outcome:** implemented %s"},{"type":"push_to_pull_request_branch","pr_number":181}]}' "$1"; }
+  rv_open() { printf '{"id":"%s","isResolved":false,"isOutdated":false}' "$1"; }
+
+  # The case that was failing in production: requesting changes from the Files tab creates a
+  # review and no thread, so both sides are empty and must agree rather than crash.
+  rv_case "a review with no threads at all"        implemented "[]" "$(rv_impl '')"
+  rv_case "no threads and no push needed"          needs-human "[]" '{"items":[{"type":"add_comment","item_number":181,"body":"**Review outcome:** needs-human"}]}'
+  rv_case "one thread, reported"                   implemented "[$(rv_open PRRT_aaa)]" "$(rv_impl 'PRRT_aaa')"
+  rv_case "one thread, silently skipped"           invalid     "[$(rv_open PRRT_aaa)]" "$(rv_impl '')"
+  rv_case "a thread id that was never opened"      invalid     "[$(rv_open PRRT_aaa)]" "$(rv_impl 'PRRT_bbb')"
+  rv_case "two threads, both reported"             implemented "[$(rv_open PRRT_a),$(rv_open PRRT_b)]" "$(rv_impl 'PRRT_a and PRRT_b')"
+  rv_case "two threads, only one reported"         invalid     "[$(rv_open PRRT_a),$(rv_open PRRT_b)]" "$(rv_impl 'PRRT_a')"
+  rv_case "a resolved thread is not expected"      implemented '[{"id":"PRRT_aaa","isResolved":true,"isOutdated":false}]' "$(rv_impl '')"
+  rv_case "implemented without the push"           invalid     "[]" '{"items":[{"type":"add_comment","item_number":181,"body":"**Review outcome:** implemented"}]}'
+  # Nothing addressed to this pull request at all. `map` over no comments is [], `add` on that is
+  # null, and `unique` dies: the run fails instead of reporting the output as unusable. This is
+  # the case the `// []` guards; the bracketed scan alone does not reach it.
+  rv_case "a comment aimed at another pull request" invalid    "[]" '{"items":[{"type":"add_comment","item_number":999,"body":"**Review outcome:** implemented"},{"type":"push_to_pull_request_branch","pr_number":181}]}'
+
+  rm -f "${rv_fixture}-threads.json" "${rv_fixture}-out.json"
+  if [ "$REVIEW_OK" -eq 1 ]; then PASS=$((PASS + 1)); else FAIL=$((FAIL + 1)); fi
+fi
+
 GATE_VALIDATOR="${HERE}/../validate-merge-gate-output/validate-merge-gate-output.sh"
 if [ -f "$GATE_VALIDATOR" ] && worker_installed merge-gate; then
   VALIDATOR_OK=1

package/loops/workflows/work-router.yml

@@ -566,6 +566,13 @@ jobs:
   # gate is about to invalidate. Serialising the belt means each gate sees a main that
   # only changes between gates, every merge re-arms the siblings through
   # detect-pr-conflicts's rescan, and the queue drains one pull request at a time.
+  #
+  # `cancel-in-progress: false` protects the RUNNING gate, not the waiting ones: GitHub keeps
+  # exactly one pending run per group and cancels the previously pending one when a new run
+  # arrives. That is fine for the path this belt is built for, where detect-pr-conflicts re-arms
+  # one sibling per merge. It is a trap for a person dispatching by hand: labelling four pull
+  # requests `merge-gate` in one go leaves one running, one pending and two silently cancelled,
+  # with nothing on the pull requests to say so. Dispatch one, let it finish, then the next.
   call-merge-gate:
     needs: classify
     if: needs.classify.outputs.route == 'merge-gate'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plainconceptsplatform/workflows",
-  "version": "0.20.1",
+  "version": "0.20.2",
   "description": "Install and update Platform GitHub agentic workflows.",
   "keywords": [
     "github-actions",