@plainconceptsplatform/workflows 0.16.4 → 0.19.2

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

@@ -814,6 +814,54 @@ if worker_installed merge-gate; then
 fi
 
 if worker_installed implement; then
+  # "No pull request" has two causes and they need different words. gh-aw pushes through the
+  # GraphQL signed-commits API, which rebases onto the current parent, so a `main` that moved
+  # under a long run conflicts; gh-aw then keeps the work by filing the patch as an issue rather
+  # than dropping it. Numa #657 hit this: a 50 KB patch that passed every validation gate, filed
+  # as issue #658, while the worker told the reader "nothing landed" and flagged a retry that
+  # would conflict the same way. The two paths must stay distinguishable, and both must be driven
+  # by a job output rather than by parsing prose.
+  #
+  # The discriminator is the item counter. `code_push_failure_count` looks like the right signal
+  # and is not: the deliberate reproduction on dogfood #10 filed the patch as #11 and still
+  # reported `Status: success`, `Successful: 1` and a resolved `GH_AW_CODE_PUSH_FAILURE_COUNT: 0`,
+  # so a worker gated on that count posts "nothing landed" over the top of a patch that exists.
+  # `create_pull_request` is the only safe output implement permits, so one succeeded item with
+  # no pull request number means the push fell back; nothing produced leaves the counter at 0.
+  PUSH_FALLBACK_OK=1
+  if ! grep -qF 'process_safe_outputs_items_succeeded' "$IMPLEMENT_WORKER_MD"; then
+    PUSH_FALLBACK_OK=0
+    echo "FAIL: implement does not read process_safe_outputs_items_succeeded, so a conflicted push reads as 'nothing landed'" >&2
+  fi
+  # Regating on the count that gh-aw leaves at 0 through a fallback is the specific regression.
+  # Matched on the `if:` line only: the comment above the branch names the count to explain why
+  # it is the wrong signal, and a bare symbol grep would fire on that prose instead of the guard.
+  if [ "$(count -cE '^ *if:.*code_push_failure_count' "$IMPLEMENT_WORKER_MD")" -ne 0 ]; then
+    PUSH_FALLBACK_OK=0
+    echo "FAIL: implement gates a no-pull-request path on code_push_failure_count, which is 0 when gh-aw files the patch as an issue" >&2
+  fi
+  for needed in 'PUSH_CONFLICT_COMMENT' 'NO_PULL_REQUEST_COMMENT'; do
+    grep -qF "env.${needed}" "$IMPLEMENT_WORKER_MD" || {
+      PUSH_FALLBACK_OK=0
+      echo "FAIL: implement no longer says env.${needed} on any path" >&2
+    }
+  done
+  # Collapsing them back into one message is the regression this guards: each is defined once in
+  # the env block and printed on exactly one path, so two usages of either means the conditions
+  # have been merged or duplicated.
+  if [ "$(count -cF 'env.PUSH_CONFLICT_COMMENT' "$IMPLEMENT_WORKER_MD")" -ne 1 ] ||
+     [ "$(count -cF 'env.NO_PULL_REQUEST_COMMENT' "$IMPLEMENT_WORKER_MD")" -ne 1 ]; then
+    PUSH_FALLBACK_OK=0
+    echo "FAIL: implement should print each no-pull-request message on exactly one path" >&2
+  fi
+  # And the two paths must be mutually exclusive, or a conflicted push gets both comments.
+  if [ "$(count -cF "process_safe_outputs_items_succeeded != '0'" "$IMPLEMENT_WORKER_MD")" -lt 2 ] ||
+     [ "$(count -cF "process_safe_outputs_items_succeeded == '0'" "$IMPLEMENT_WORKER_MD")" -lt 2 ]; then
+    PUSH_FALLBACK_OK=0
+    echo "FAIL: the conflicted-push and no-patch paths in implement are not mutually exclusive" >&2
+  fi
+  if [ "$PUSH_FALLBACK_OK" -eq 1 ]; then PASS=$((PASS + 1)); else FAIL=$((FAIL + 1)); fi
+
   # A provider outage kills a run in a couple of minutes with no answer, and the same issue used
   # to be handed to a human for it. The implement worker retries those and only those: a run that
   # worked for half an hour and then failed produced an answer that was wrong, and repeating it
@@ -1118,6 +1166,56 @@ if [ -f "$AUDIT_CLOSE_YML" ] && worker_installed audit; then
   if [ "$AC_OK" -eq 1 ]; then PASS=$((PASS + 1)); else FAIL=$((FAIL + 1)); fi
 fi
 
+echo "── Merge gate validator ──────────────────────────────────────────────────"
+
+# The validator decides whether a gate run merges, remediates, parks, or is thrown away, and
+# until now nothing executed it -- this file only read it. Its `remediated` rule was changed on
+# reasoning alone, and the worker has not run in production since, so these fixtures are the only
+# evidence the change is right. Executing the real script is the same technique that finally
+# caught the belt's jq bug, which every reading assertion had walked past.
+GATE_VALIDATOR="${HERE}/../validate-merge-gate-output/validate-merge-gate-output.sh"
+if [ -f "$GATE_VALIDATOR" ] && worker_installed merge-gate; then
+  VALIDATOR_OK=1
+  gate_fixture="${TMPDIR:-/tmp}/route-matrix-gate-$$.json"
+
+  gate_case() {
+    local name="$1" want="$2" json="$3" conclusion="$4"
+    printf '%s' "$json" > "$gate_fixture"
+    local got
+    got=$(bash "$GATE_VALIDATOR" "$gate_fixture" 7 "$conclusion" 2>&1)
+    if [ "$got" != "$want" ]; then
+      VALIDATOR_OK=0
+      echo "FAIL: the merge-gate validator called '${name}' ${got}, expected ${want}" >&2
+    fi
+  }
+
+  gate_verdict='{"type":"add_comment","item_number":7,"body":"<!-- agent-merge-gate -->\n**Verdict:** VERB"}'
+  gate_push='{"type":"push_to_pull_request_branch","pr_number":9}'
+  gate_items() { printf '{"items":[%s]}' "$1"; }
+  gate_comment() { printf '%s' "${gate_verdict/VERB/$1}"; }
+
+  gate_case "merge on green with no push"        merge      "$(gate_items "$(gate_comment merge)")" success
+  gate_case "merge on a failed CI run"           invalid    "$(gate_items "$(gate_comment merge)")" failure
+  gate_case "merge carrying a push"              invalid    "$(gate_items "$(gate_comment merge),${gate_push}")" success
+  # The case the rule exists for. A conflicting pull request has no merge ref, so GitHub never
+  # runs CI on that head and the belt falls back to the branch's last verdict, usually success.
+  # Requiring conclusion == failure here discarded the resolved merge commit the agent had just
+  # pushed, and the belt re-dispatched on the same verdict up to six times.
+  gate_case "remediated with one push, CI green" remediated "$(gate_items "$(gate_comment remediated),${gate_push}")" success
+  gate_case "remediated with one push, CI red"   remediated "$(gate_items "$(gate_comment remediated),${gate_push}")" failure
+  gate_case "remediated with no push"            invalid    "$(gate_items "$(gate_comment remediated)")" failure
+  gate_case "remediated with two pushes"         invalid    "$(gate_items "$(gate_comment remediated),${gate_push},${gate_push}")" failure
+  gate_case "review with no push"                review     "$(gate_items "$(gate_comment review)")" failure
+  gate_case "review carrying a push"             invalid    "$(gate_items "$(gate_comment review),${gate_push}")" failure
+  gate_case "a verdict aimed at another issue"   invalid    '{"items":[{"type":"add_comment","item_number":99,"body":"<!-- agent-merge-gate -->\n**Verdict:** merge"}]}' success
+  gate_case "no verdict in the output"           invalid    '{"items":[{"type":"add_comment","item_number":7,"body":"just a note"}]}' success
+  gate_case "an empty item list"                 invalid    '{"items":[]}' success
+  gate_case "output that is not an item list"    invalid    '{"nope":true}' success
+
+  rm -f "$gate_fixture"
+  if [ "$VALIDATOR_OK" -eq 1 ]; then PASS=$((PASS + 1)); else FAIL=$((FAIL + 1)); fi
+fi
+
 echo "── Merge gate park ───────────────────────────────────────────────────────"
 
 # A gate verdict parks the code it was given on. Both dispatch paths -- detect-pr-conflicts and
@@ -1392,6 +1490,230 @@ else
   printf '%s\n' "$password_hits" >&2
 fi
 
+echo "── Stale dispatch and empty runs ─────────────────────────────────────────"
+
+# A route dispatched while an issue was open must not execute after it is closed. The classifier
+# refuses a closed issue, but it can only read `github.event.issue.state`: the state when the
+# event fired, and absent altogether on a workflow_dispatch. This fleet queues for a runner for
+# ten minutes and more. Numa #659 was closed one second after a comment dispatched refine; the run
+# reached `reserve` thirteen minutes later, took the reservation, and refined a closed issue for
+# thirty-eight minutes, ending by labelling it `refined`, `implement` and `sp-5`. Every job
+# reported success. Asserted per worker because the gate is three lines in each and none of them
+# failing produces a red run.
+STALE_DISPATCH_OK=1
+for route in refine implement triage apply-review; do
+  worker_md="${WORKFLOWS_DIR}/agent-${route}.md"
+  [ -f "$worker_md" ] || continue
+  if ! grep -q '^  still_open:' "$worker_md"; then
+    STALE_DISPATCH_OK=0
+    echo "FAIL: agent-${route} has no still_open job; a route dispatched before the issue closed would run on it anyway" >&2
+    continue
+  fi
+  # The reservation must be gated, or bot-working lands on a closed issue, and the agent must be
+  # gated through the worker's own `if:`. Two distinct call sites.
+  if [ "$(count -cF "needs.still_open.outputs.open == 'true'" "$worker_md")" -lt 2 ]; then
+    STALE_DISPATCH_OK=0
+    echo "FAIL: agent-${route} does not gate both the reservation and the agent on still_open" >&2
+  fi
+  # The gate job must carry no `needs:` of its own. gh-aw hoists exactly those custom jobs into
+  # the activation job's dependencies, which is what lets the top-level `if:` read their outputs;
+  # a gate job that gained a dependency would stop being hoisted and the clause would silently
+  # evaluate to empty, which is always true. Asserted on the job block, not on the file, because
+  # `needs: [still_open]` also appears on the reserve job and a file-wide search for it passed
+  # for two workers that never declared anything.
+  # activation must be given the dependency, or the top-level `if:` reads an empty value and the
+  # clause is false: the agent never runs at all. gh-aw does not hoist this job, and the entry
+  # lives at two spaces under `on:`, which is where gh-aw reads activation's dependency list.
+  # Matched inside the `on:` block, because the same text appears on the reserve job and a
+  # file-wide search for it passed for two workers that had declared nothing.
+  on_block=$(awk '/^on:/{f=1; next} f && /^[a-z][a-z-]*:/{exit} f' "$worker_md")
+  if ! printf '%s
+' "$on_block" | grep -qE '^  needs: \[.*still_open'; then
+    STALE_DISPATCH_OK=0
+    echo "FAIL: agent-${route} does not list still_open under on.needs, so activation reads an empty value and the agent never runs" >&2
+  fi
+  gate_block=$(awk '/^  still_open:/{f=1; next} f && /^  [a-z_]+:/{exit} f' "$worker_md")
+  if printf '%s
+' "$gate_block" | grep -qE '^    needs:'; then
+    STALE_DISPATCH_OK=0
+    echo "FAIL: agent-${route}'s still_open job declares needs:, so gh-aw will not hoist it and the top-level if: reads an empty value" >&2
+  fi
+done
+if [ "$STALE_DISPATCH_OK" -eq 1 ]; then PASS=$((PASS + 1)); else FAIL=$((FAIL + 1)); fi
+
+# An audit that emitted neither a report nor a noop used to end green: `conclude` requires a
+# processed item, and a skipped job is not a failure. A whole agent run produced nothing and said
+# nothing. Both halves of the condition are asserted: the count alone would fire on a legitimate
+# `noop` if noop does not increment it, and the noop_message alone would miss the empty run.
+if worker_installed audit; then
+  AUDIT_EMPTY_OK=1
+  AUDIT_WORKER_MD="${WORKFLOWS_DIR}/agent-audit.md"
+  grep -q '^  empty_run:' "$AUDIT_WORKER_MD" ||
+    { AUDIT_EMPTY_OK=0; echo "FAIL: the audit has no empty_run job; a run that files nothing reports success" >&2; }
+  grep -qF "process_safe_outputs_processed_count == '0'" "$AUDIT_WORKER_MD" ||
+    { AUDIT_EMPTY_OK=0; echo "FAIL: the audit's empty_run does not test the processed count" >&2; }
+  # empty_run must not depend on gh-aw's `conclusion` job. That job needs every custom job in the
+  # worker, so naming it is a cycle and the whole workflow fails to compile -- which is how the
+  # first attempt at this was caught. It also means `noop_message`, the one output that would say
+  # a clean audit deliberately filed nothing, cannot be read from here.
+  if grep -qE '^    needs: \[.*conclusion' "$AUDIT_WORKER_MD"; then
+    AUDIT_EMPTY_OK=0
+    echo "FAIL: the audit's empty_run depends on the conclusion job, which is a dependency cycle and will not compile" >&2
+  fi
+  if [ "$AUDIT_EMPTY_OK" -eq 1 ]; then PASS=$((PASS + 1)); else FAIL=$((FAIL + 1)); fi
+fi
+
+echo "── Runner pools ──────────────────────────────────────────────────────────"
+
+# Where every job runs, stated once and asserted, because GitHub gives a wrong pool no error: a
+# job addressed to a label no runner carries simply queues, and a job addressed to the wrong pool
+# runs in the wrong place. The pool was a preserved consumer value until 0.19.0, and that is how
+# one repository came to run triage, refine, implement, apply-review and audit on
+# RunnerLandingZone while merge-gate and release stayed on agents-arc: the override reached the
+# workers installed at the time and never the ones added later. Nothing reported the split.
+#
+#   agent jobs of every worker except release  ->  agents-arc          (the Azure fleet in
+#                                                                       agentrunner-pro-rg-01,
+#                                                                       runner group `agentic`)
+#   agent-release.md and work-router.yml       ->  RunnerLandingZone
+#   ubuntu-latest                              ->  GitHub's own runner, chosen by nobody, left
+#                                                  wherever the package already has it
+AGENT_POOL="agents-arc"
+PLUMBING_POOL="RunnerLandingZone"
+POOL_OK=1
+
+# `|| true` on both greps: a file naming no pool at all, or only ubuntu-latest, makes grep exit 1,
+# and under `set -o pipefail` that aborts the whole matrix instead of failing this one assertion.
+# A router mutated to ubuntu-latest everywhere did exactly that: the suite died without printing,
+# so the mutation looked caught when in fact nothing had been checked.
+pools_named() {
+  { grep -hoE '^[[:space:]]*runs-on(-slim)?: [^[:space:]]+' "$1" 2>/dev/null || true; } \
+    | sed 's/.*: //' | { grep -v '^ubuntu-latest$' || true; } | sort -u
+}
+
+for worker_md in "${WORKFLOWS_DIR}"/agent-*.md; do
+  [ -f "$worker_md" ] || continue
+  worker_name="$(basename "$worker_md" .md)"
+  want="$AGENT_POOL"
+  [ "$worker_name" = "agent-release" ] && want="$PLUMBING_POOL"
+  got="$(pools_named "$worker_md" | tr '\n' ' ' | sed 's/ $//')"
+  if [ "$got" != "$want" ]; then
+    POOL_OK=0
+    echo "FAIL: ${worker_name} names runner pool(s) '${got}' but must name only '${want}'" >&2
+  fi
+done
+
+router_pools="$(pools_named "$ROUTER_YML" | tr '\n' ' ' | sed 's/ $//')"
+if [ "$router_pools" != "$PLUMBING_POOL" ]; then
+  POOL_OK=0
+  echo "FAIL: the router names runner pool(s) '${router_pools}' but must name only '${PLUMBING_POOL}'" >&2
+fi
+
+# And the pool must not be reintroduced as a per-consumer value: that is the mechanism that let
+# the split happen, and it left no trace anywhere.
+if [ -d "${HERE}/../../../cli/src" ] && grep -rqE 'preserveRunnerPool|runnerPools' "${HERE}/../../../cli/src" 2>/dev/null; then
+  POOL_OK=0
+  echo "FAIL: the installer preserves a consumer's runner pool again; the pool is the package's to set" >&2
+fi
+
+if [ "$POOL_OK" -eq 1 ]; then PASS=$((PASS + 1)); else FAIL=$((FAIL + 1)); fi
+
+echo "── Worker input wiring ───────────────────────────────────────────────────"
+
+# A worker that declares a workflow_call input and never reads it is the shape of the worst
+# outage this pipeline has had. The router resolved the CI run ID, passed it as `ci-run-id`, and
+# the merge gate declared the input and then called identify-gate-subject without it -- so
+# `RUN_ID` was always empty, the evidence step wrote `failed-jobs.json` as `[]`, and the agent,
+# holding no failing job name and no logs, chose `review` every time CI went red. Pliny-Bot #129,
+# #130 and #131 all ended up waiting on a human with CI legitimately red and remediable, and the
+# housekeeping digest reported it as work needing a person. Nothing went red: every job succeeded
+# at doing nothing. This asserts the class, because reading each worker by hand is how it was
+# missed for as long as it was.
+#
+# `agent-audit:trigger-kind` is exempt and stays listed rather than deleted: it is a
+# workflow_dispatch choice a person picks on the router, threaded through for symmetry, with no
+# behaviour attached at the far end. Removing it would take a dispatch option away from people,
+# so it is recorded as known-inert instead. Any *other* unread input fails.
+DEAD_INPUT_EXEMPT="agent-audit:trigger-kind"
+INPUT_WIRING_OK=1
+for worker_md in "${WORKFLOWS_DIR}"/agent-*.md; do
+  [ -f "$worker_md" ] || continue
+  worker_name="$(basename "$worker_md" .md)"
+  # The declared inputs: the `inputs:` mapping under `on: workflow_call:`, whose keys sit at six
+  # spaces. Stop at the first line indented less than that which is not blank.
+  declared=$(awk '
+    /^on:/           { in_on = 1; next }
+    in_on && /^[a-z#]/ { exit }
+    in_on && /^  workflow_call:/ { in_wc = 1; next }
+    in_wc && /^    inputs:/ { in_inputs = 1; next }
+    in_inputs && /^    [a-z]/ { in_inputs = 0 }
+    in_inputs && /^      [a-z0-9_-]+:[[:space:]]*$/ {
+      gsub(/[ :]/, "", $0); print $0
+    }
+  ' "$worker_md")
+  for input_name in $declared; do
+    case "${worker_name}:${input_name}" in
+      "$DEAD_INPUT_EXEMPT") continue ;;
+    esac
+    if [ "$(count -cE "inputs\.${input_name}([^a-zA-Z0-9_-]|\$)" "$worker_md")" -eq 0 ]; then
+      INPUT_WIRING_OK=0
+      echo "FAIL: ${worker_name} declares the input '${input_name}' and never reads it; the router's value is discarded and the job succeeds at doing nothing" >&2
+    fi
+  done
+done
+if [ "$INPUT_WIRING_OK" -eq 1 ]; then PASS=$((PASS + 1)); else FAIL=$((FAIL + 1)); fi
+
+# The belt dispatches one gate per tick and stops. The gate's concurrency group holds a single
+# pending run, so GitHub cancels every earlier pending dispatch in it -- `cancel-in-progress:
+# false` only protects a run that has already started. A loop without this `break` dispatched one
+# gate per eligible pull request, ran the last, and discarded the rest with no comment, no
+# recorded attempt, and nothing on the pull request to show it had been skipped. Asserted because
+# removing the break produces no error anywhere: the extra dispatches all return 204.
+BELT_ONE_PER_TICK_OK=1
+belt_dispatch_block=$(awk '
+  /Dispatching Merge Gate for PR/ { found = 1 }
+  found { print }
+  found && /^ *done$/ { exit }
+' "$ROUTER_YML")
+if [ -z "$belt_dispatch_block" ]; then
+  BELT_ONE_PER_TICK_OK=0
+  echo "FAIL: the merge belt's gate dispatch could not be located, so its one-per-tick guard cannot be checked" >&2
+elif ! printf '%s\n' "$belt_dispatch_block" | grep -qE '^ *break$'; then
+  BELT_ONE_PER_TICK_OK=0
+  echo "FAIL: the merge belt dispatches a gate per eligible pull request and never breaks; only the last stays pending and the rest are cancelled in silence" >&2
+fi
+# And the group it relies on must still be the serialising one.
+# Anchored to the whole line: a substring search matched `merge-belt-renamed` and stayed green
+# through a mutation that removed the serialisation the break depends on.
+grep -qE '^ *group: merge-belt *$' "$ROUTER_YML" ||
+  { BELT_ONE_PER_TICK_OK=0; echo "FAIL: the merge gate is no longer serialised on the merge-belt concurrency group" >&2; }
+if [ "$BELT_ONE_PER_TICK_OK" -eq 1 ]; then PASS=$((PASS + 1)); else FAIL=$((FAIL + 1)); fi
+
+# The specific wiring that broke, asserted end to end: the router resolves the run ID, the gate
+# forwards it, and the action seeds from it rather than only from its own lookup.
+if worker_installed merge-gate; then
+  GATE_RUN_ID_OK=1
+  grep -Fq 'ci-run-id: ${{ needs.classify.outputs.ci-run-id }}' "$ROUTER_YML" ||
+    { GATE_RUN_ID_OK=0; echo "FAIL: the router no longer passes ci-run-id to the merge gate" >&2; }
+  grep -Fq 'ci-run-id: ${{ inputs.ci-run-id }}' "$MERGE_GATE_WORKER_MD" ||
+    { GATE_RUN_ID_OK=0; echo "FAIL: the merge gate does not forward ci-run-id to identify-gate-subject, so it has no CI failure evidence" >&2; }
+  GATE_SUBJECT_ACTION="${HERE}/../identify-gate-subject/action.yml"
+  if [ -f "$GATE_SUBJECT_ACTION" ]; then
+    grep -Fq 'ci_run_id="$CI_RUN_ID"' "$GATE_SUBJECT_ACTION" ||
+      { GATE_RUN_ID_OK=0; echo "FAIL: identify-gate-subject does not seed the run ID from its input, so a caller that knows it is ignored" >&2; }
+    # The regression: resolving the ID only when the conclusion is missing.
+    # Anchored to the start of the line: the repaired code keeps an `elif [ -z "$ci_conclusion" ]`
+    # branch for the caller that genuinely has no verdict, and a fixed-string search matched that
+    # `elif` as a substring -- the same way this file's own explanatory comments have tripped
+    # three earlier assertions.
+    if [ "$(count -cE '^ *if \[ -z "\$ci_conclusion" \]; then' "$GATE_SUBJECT_ACTION")" -ne 0 ]; then
+      GATE_RUN_ID_OK=0
+      echo "FAIL: identify-gate-subject resolves the CI run only when the conclusion is unknown; a router that passes both gets an empty run ID" >&2
+    fi
+  fi
+  if [ "$GATE_RUN_ID_OK" -eq 1 ]; then PASS=$((PASS + 1)); else FAIL=$((FAIL + 1)); fi
+fi
+
 echo
 if [ "$FAIL" -eq 0 ]; then
   echo "Route matrix: ${PASS} passed"

package/loops/workflows/agent-apply-review.md

@@ -49,7 +49,37 @@ on:
 
 # Rung 4. Router has classified the event; this job validates PR ownership and checks for
 # substantive feedback. A custom job, not `on.steps`, because the prompt needs these values.
+  # The gate job that the top-level `if:` reads. gh-aw folds that `if:` into the generated
+  # activation job but gives activation no dependency on the job, so the reference resolves
+  # to '' and the clause is false -- the agent would never run. The package's own validator
+  # catches it after compilation; this is the line it asks for, the same one the merge gate
+  # uses for protected_changes.
+  needs: [still_open]
 jobs:
+  # A route dispatched while the issue was open must not execute after it has been closed. The
+  # classifier can only see `github.event.issue.state`, which is the state when the event fired
+  # and is absent on a workflow_dispatch, and this fleet queues for a runner for ten minutes and
+  # more. Numa #659 was closed one second after a comment dispatched refine; the run reached
+  # `reserve` thirteen minutes later and refined a closed issue to completion. Read now, once,
+  # and gate both the reservation and the agent on it.
+  still_open:
+    runs-on: agents-arc
+    permissions:
+      contents: read
+      issues: read
+    outputs:
+      open: ${{ steps.state.outputs.open }}
+    steps:
+      - name: Checkout workflow actions
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+      - name: Read the issue state
+        id: state
+        uses: ./.github/actions/require-open-issue
+        with:
+          token: ${{ github.token }}
+          issue-number: ${{ inputs.issue-number }}
   subject:
     runs-on: agents-arc
     permissions:
@@ -118,8 +148,8 @@ jobs:
            echo "PR #$PR has $unresolved unresolved thread(s)"
 
   reserve:
-    needs: subject
-    if: needs.subject.outputs.found == 'true' && needs.subject.outputs.issue != ''
+    needs: [subject, still_open]
+    if: needs.subject.outputs.found == 'true' && needs.subject.outputs.issue != '' && needs.still_open.outputs.open == 'true'
     runs-on: agents-arc
     permissions:
       contents: read
@@ -290,7 +320,7 @@ jobs:
             ${{ env.INCOMPLETE_COMMENT }}
             [View this workflow run](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }})
 
-if: needs.subject.outputs.found == 'true'
+if: needs.subject.outputs.found == 'true' && needs.still_open.outputs.open == 'true'
 
 runs-on: agents-arc
 runs-on-slim: agents-arc

package/loops/workflows/agent-audit.md

@@ -119,6 +119,42 @@ jobs:
             bug
             refine
 
+  # An audit that produced nothing reported success. The whole run -- a full agent, its tokens,
+  # its half hour -- ended with `conclude` skipped, because that job requires a processed item,
+  # and a skipped job leaves the run green. Numa's audit on 2026-09-10 did exactly that:
+  # `agent_output.json` 24 bytes, `safe-output-items.jsonl` empty, every job success, no report
+  # filed and nothing anywhere saying so. The next scheduled audit would have looked identical.
+  #
+  # This fires when the agent succeeded and the safe-outputs handler processed nothing at all.
+  #
+  # Step 6 of the prompt gives a clean codebase its own outcome -- call `noop` and stop -- and
+  # that outcome must not be reported as a failure. `noop` is a registered safe output here
+  # (`noop: max 1`), so the handler receives it as a message and the processed count is not zero,
+  # which keeps a deliberately empty audit out of this branch. That is read from the handler
+  # configuration rather than observed in a run: no audit in these repositories has yet emitted a
+  # noop. The direct signal, `noop_message`, belongs to gh-aw's `conclusion` job, and that job
+  # depends on every custom job here, so naming it is a dependency cycle and the worker will not
+  # compile -- the first version of this job was rejected for exactly that.
+  #
+  # If a genuinely clean audit ever fails here, that is the assumption breaking, and the fix is to
+  # carry the noop through a job this one can depend on rather than to widen the condition.
+  empty_run:
+    needs: [agent, safe_outputs]
+    if: >
+      needs.agent.result == 'success' &&
+      needs.safe_outputs.outputs.process_safe_outputs_processed_count == '0'
+    runs-on: agents-arc
+    permissions:
+      contents: read
+    steps:
+      - name: Report an audit that produced no outcome
+        env:
+          RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+        run: |
+          set -euo pipefail
+          echo "::error::The audit agent finished without emitting a report or a noop. The prompt requires one of the two: create_issue with the findings, or noop when the codebase is clean. Nothing was filed and no reason was given, so this run is a failure rather than a clean audit. The next scheduled audit will try again. ${RUN_URL}"
+          exit 1
+
 safe-outputs:
   # A failed run is already a red run. An issue per failure buries the real backlog
   # under noise nobody closes.

package/loops/workflows/agent-implement.md

@@ -17,6 +17,13 @@ env:
   STALLED_LABEL: stalled
   PR_PENDING_LABEL: pr-pending
   NO_PULL_REQUEST_COMMENT: "The implementation run finished without producing a pull request. Nothing was lost, but nothing landed either: the issue keeps `implement` and is flagged for a retry."
+  # Said when the agent DID write the code and the push failed. gh-aw pushes through the GraphQL
+  # signed-commits API, which rebases onto the current parent, so a `main` that moved under a long
+  # run conflicts; gh-aw keeps the work by filing the patch as an issue rather than dropping it,
+  # and comments the link on this issue itself. Telling someone "nothing landed" over the top of
+  # that sends them to reimplement work that already exists. One line: the compiler flattens a
+  # multi-line env value.
+  PUSH_CONFLICT_COMMENT: "The implementation produced a patch, but pushing it failed: it no longer applies to `main`, which moved while this ran. gh-aw filed the patch as a separate issue rather than losing it, and linked it in its own comment above. The work is there and needs rebasing onto current `main`, not writing again."
   GIT_AUTHOR_NAME: "github-actions[bot]"
   GIT_AUTHOR_EMAIL: "github-actions[bot]@users.noreply.github.com"
   GIT_COMMITTER_NAME: "github-actions[bot]"
@@ -70,7 +77,37 @@ on:
         required: false
         type: string
         default: '0'
+  # The gate job that the top-level `if:` reads. gh-aw folds that `if:` into the generated
+  # activation job but gives activation no dependency on the job, so the reference resolves
+  # to '' and the clause is false -- the agent would never run. The package's own validator
+  # catches it after compilation; this is the line it asks for, the same one the merge gate
+  # uses for protected_changes.
+  needs: [still_open]
 jobs:
+  # A route dispatched while the issue was open must not execute after it has been closed. The
+  # classifier can only see `github.event.issue.state`, which is the state when the event fired
+  # and is absent on a workflow_dispatch, and this fleet queues for a runner for ten minutes and
+  # more. Numa #659 was closed one second after a comment dispatched refine; the run reached
+  # `reserve` thirteen minutes later and refined a closed issue to completion. Read now, once,
+  # and gate both the reservation and the agent on it.
+  still_open:
+    runs-on: agents-arc
+    permissions:
+      contents: read
+      issues: read
+    outputs:
+      open: ${{ steps.state.outputs.open }}
+    steps:
+      - name: Checkout workflow actions
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+      - name: Read the issue state
+        id: state
+        uses: ./.github/actions/require-open-issue
+        with:
+          token: ${{ github.token }}
+          issue-number: ${{ inputs.issue-number }}
   eligibility:
     runs-on: agents-arc
     permissions:
@@ -107,8 +144,8 @@ jobs:
           echo "eligible=true" >> "$GITHUB_OUTPUT"
 
   reserve:
-    needs: [eligibility]
-    if: needs.eligibility.outputs.eligible == 'true'
+    needs: [eligibility, still_open]
+    if: needs.eligibility.outputs.eligible == 'true' && needs.still_open.outputs.open == 'true'
     runs-on: agents-arc
     permissions:
       contents: read
@@ -227,8 +264,43 @@ jobs:
       # comment, and no bot-working — which also hid it from the hourly stale-reservation sweep.
       # Comments do not re-trigger implement, so nothing on any path would ever look at it again.
       # It was the only failure in the fleet that signalled nobody at all.
+      #
+      # There are two ways to reach "no pull request", and telling a person they are the same
+      # thing wastes their time. gh-aw pushes through the GraphQL signed-commits API, which
+      # rebases the commit range onto the current parent; when `main` has moved under a long run
+      # the rebase conflicts, and gh-aw keeps the work by filing the patch as an issue instead of
+      # dropping it, commenting the link on this issue itself. Saying "nothing landed" over the
+      # top of that is false: the patch exists and needs rebasing, not reimplementing. Seen on
+      # Numa #657, where the same change had landed on main by hand while the agent was writing
+      # it, and reproduced deliberately on dogfood #10 -> #11.
+      #
+      # The signal is the item counter, not `code_push_failure_count`. gh-aw treats the fallback
+      # as a *successful* outcome for the item -- the dogfood run logged `Status: success`,
+      # `Successful: 1` and a resolved `GH_AW_CODE_PUSH_FAILURE_COUNT: 0` while filing #11 -- so
+      # gating on that count posted the wrong message. `create_pull_request` is the only safe
+      # output this worker permits, so one succeeded item with no pull request number can only
+      # mean the push fell back to an issue. Nothing produced at all leaves the counter at 0.
+      - name: Flag a patch that could not be pushed
+        if: needs.safe_outputs.outputs.created_pr_number == '' && needs.safe_outputs.outputs.process_safe_outputs_items_succeeded != '0' && needs.safe_outputs.outputs.process_safe_outputs_items_succeeded != ''
+        uses: ./.github/actions/add-issue-labels
+        with:
+          token: ${{ steps.app-token.outputs.token }}
+          issue-number: ${{ inputs.issue-number }}
+          labels: |-
+            ${{ env.REVIEW_LABEL }}
+            ${{ env.STALLED_LABEL }}
+      - name: Say where the patch went
+        if: needs.safe_outputs.outputs.created_pr_number == '' && needs.safe_outputs.outputs.process_safe_outputs_items_succeeded != '0' && needs.safe_outputs.outputs.process_safe_outputs_items_succeeded != ''
+        uses: ./.github/actions/create-issue-comment
+        with:
+          token: ${{ steps.app-token.outputs.token }}
+          issue-number: ${{ inputs.issue-number }}
+          body: |
+            ${{ env.IMPLEMENT_MARKER }}
+            ${{ env.PUSH_CONFLICT_COMMENT }}
+            [View this workflow run](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }})
       - name: Flag a run that produced no pull request
-        if: needs.safe_outputs.outputs.created_pr_number == ''
+        if: needs.safe_outputs.outputs.created_pr_number == '' && (needs.safe_outputs.outputs.process_safe_outputs_items_succeeded == '0' || needs.safe_outputs.outputs.process_safe_outputs_items_succeeded == '')
         uses: ./.github/actions/add-issue-labels
         with:
           token: ${{ steps.app-token.outputs.token }}
@@ -237,7 +309,7 @@ jobs:
             ${{ env.REVIEW_LABEL }}
             ${{ env.STALLED_LABEL }}
       - name: Say so on the issue
-        if: needs.safe_outputs.outputs.created_pr_number == ''
+        if: needs.safe_outputs.outputs.created_pr_number == '' && (needs.safe_outputs.outputs.process_safe_outputs_items_succeeded == '0' || needs.safe_outputs.outputs.process_safe_outputs_items_succeeded == '')
         uses: ./.github/actions/create-issue-comment
         with:
           token: ${{ steps.app-token.outputs.token }}
@@ -436,7 +508,7 @@ jobs:
     needs: [eligibility]
     if: needs.eligibility.outputs.eligible == 'true'
 
-if: inputs.issue-number != ''
+if: inputs.issue-number != '' && needs.still_open.outputs.open == 'true'
 
 runs-on: agents-arc
 runs-on-slim: agents-arc

package/loops/workflows/agent-merge-gate.md

@@ -114,6 +114,7 @@ jobs:
           token: ${{ github.token }}
           pr-number: ${{ inputs.pr-number }}
           ci-conclusion: ${{ inputs.ci-conclusion }}
+          ci-run-id: ${{ inputs.ci-run-id }}
           linked-issue: ${{ inputs.linked-issue }}
           require-label: ${{ env.IMPLEMENT_LABEL }}
       - name: Block a pull request with requested changes

package/loops/workflows/agent-refine.md

@@ -76,9 +76,41 @@ on:
         required: false
         type: string
         default: first
+  # The gate job that the top-level `if:` reads. gh-aw folds that `if:` into the generated
+  # activation job but gives activation no dependency on the job, so the reference resolves
+  # to '' and the clause is false -- the agent would never run. The package's own validator
+  # catches it after compilation; this is the line it asks for, the same one the merge gate
+  # uses for protected_changes.
+  needs: [still_open]
 
 jobs:
+  # A route dispatched while the issue was open must not execute after it has been closed. The
+  # classifier can only see `github.event.issue.state`, which is the state when the event fired
+  # and is absent on a workflow_dispatch, and this fleet queues for a runner for ten minutes and
+  # more. Numa #659 was closed one second after a comment dispatched refine; the run reached
+  # `reserve` thirteen minutes later and refined a closed issue to completion. Read now, once,
+  # and gate both the reservation and the agent on it.
+  still_open:
+    runs-on: agents-arc
+    permissions:
+      contents: read
+      issues: read
+    outputs:
+      open: ${{ steps.state.outputs.open }}
+    steps:
+      - name: Checkout workflow actions
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+      - name: Read the issue state
+        id: state
+        uses: ./.github/actions/require-open-issue
+        with:
+          token: ${{ github.token }}
+          issue-number: ${{ inputs.issue-number }}
   reserve:
+    needs: [still_open]
+    if: needs.still_open.outputs.open == 'true'
     runs-on: agents-arc
     permissions:
       contents: read
@@ -364,7 +396,7 @@ jobs:
             ${{ env.INCOMPLETE_COMMENT }}
             [View this workflow run](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }})
 
-if: inputs.issue-number != ''
+if: inputs.issue-number != '' && needs.still_open.outputs.open == 'true'
 
 runs-on: agents-arc
 runs-on-slim: agents-arc