@plainconceptsplatform/workflows 0.17.0 → 0.19.2

package/dist/catalog-installation.js

@@ -306,18 +306,19 @@ async function preCommitHookUpdate(repositoryPath) {
     }
     const content = (await readFile(hookPath, "utf8"))
         .replace("pnpm exec if git diff --cached --name-only -- .github | grep -q .; then", "if git diff --cached --name-only -- .github | grep -q .; then");
-    if (content.includes("compile-agent-workflows")) {
-        const legacyLines = `${compileLine}\n${stageLine}\n${actionLockLine}\n`;
-        if (content.includes(managedLines))
-            return { target, content };
-        if (content.includes(legacyLines))
-            return { target, content: content.replace(legacyLines, managedLines) };
-        const suffix = content.endsWith("\n") || content === "" ? "" : "\n";
-        return { target, content: `${content}${suffix}${managedLines}` };
-    }
-    return { target, content: content.endsWith("\n") || content === ""
-            ? `${content}${managedLines}`
-            : `${content}\n${managedLines}` };
+    // Replace whatever managed block is there, never append beside it. The previous version
+    // recognised only two exact shapes -- the current block and the pre-`if` legacy lines -- and
+    // appended when it matched neither. A consumer holding an *older* wrapped block therefore
+    // gained a second one, so the compiler ran twice on every commit and one of the two staged a
+    // lock path that exists nowhere. All five consumers were carrying two blocks by the time this
+    // was noticed, and every future edit to `managedLines` would have added another. Nothing
+    // failed: running the compiler twice is only wasteful, so it never surfaced.
+    const managedBlock = /^[ \t]*if git diff --cached --name-only -- \.github \| grep -q \.; then\n(?:.*\n)*?[ \t]*fi\n?/gm;
+    const legacyLines = `${compileLine}\n${stageLine}\n${actionLockLine}\n`;
+    let stripped = content.replace(managedBlock, block => block.includes("compile-agent-workflows") ? "" : block);
+    stripped = stripped.split(legacyLines).join("");
+    const body = stripped.replace(/\n{3,}/g, "\n\n").replace(/\s+$/, "");
+    return { target, content: body === "" ? managedLines : `${body}\n${managedLines}` };
 }
 export async function runCompileIfAvailable(repositoryPath) {
     const script = join(repositoryPath, "scripts", "compile-agent-workflows.mjs");

package/dist/worker-env.js

@@ -120,26 +120,15 @@ export function mergeWorkerEnv(packageContent, consumerContent, baselineContent,
 function engineEndpoint(content) {
     return /^    OPENAI_BASE_URL: (.+)$/m.exec(content)?.[1];
 }
-// Which self-hosted pool a worker's agent jobs run on. gh-aw cannot share runs-on through an
-// import, so every worker names it. ubuntu-latest is excluded, being GitHub's own runner, used
-// by the deterministic jobs everywhere and chosen by nobody.
-function runnerPools(content) {
-    const found = new Set();
-    for (const match of content.matchAll(/^\s*runs-on(?:-slim)?: (\S+)\s*$/gm)) {
-        if (match[1] !== "ubuntu-latest")
-            found.add(match[1]);
-    }
-    return [...found];
-}
-function preserveRunnerPool(packageContent, consumerContent) {
-    const mine = runnerPools(consumerContent);
-    const theirs = runnerPools(packageContent);
-    // Only an unambiguous swap. A consumer naming several pools has drifted rather than
-    // decided, and guessing which it meant is worse than leaving the package's.
-    if (mine.length !== 1 || theirs.length !== 1 || mine[0] === theirs[0])
-        return packageContent;
-    return packageContent.replace(/^(\s*runs-on(?:-slim)?: )(\S+)(\s*)$/gm, (line, prefix, pool, tail) => pool === "ubuntu-latest" ? line : `${prefix}${mine[0]}${tail}`);
-}
+// The runner pool used to be preserved from the consumer here: a repository naming a single
+// non-ubuntu pool had every worker rewritten to it. That is how Pliny-Bot ended up running
+// triage, refine, implement, apply-review and audit on RunnerLandingZone while its merge-gate
+// and release stayed on agents-arc -- the pool was applied to the workers installed at the time
+// and never to the ones added later, and nothing reported the split. The pool is package-owned
+// now: the agent jobs belong on the Azure fleet (agents-arc, runner group `agentic`), and the
+// router and release worker name RunnerLandingZone. The route matrix asserts both, so a repo
+// cannot drift back without a red run. Per the standing rule for this package, anything a
+// consumer really must vary belongs in `env:` at the top of the file, not in `runs-on`.
 // GitHub evaluates no expression in a `workflow_run.workflows:` list or in a `cron:`, so the two
 // router values that are also needed there cannot be read from `env:` at those two lines. The
 // installer copies them in instead, which is what keeps the pair in step across an update; the
@@ -175,5 +164,5 @@ export function mergeWorker(packageContent, consumerContent, baselineContent) {
     if (endpoint !== undefined) {
         result = result.replace(/^    OPENAI_BASE_URL: .+$/m, `    OPENAI_BASE_URL: ${endpoint}`);
     }
-    return { content: preserveRunnerPool(result, consumerContent), report };
+    return { content: result, report };
 }

package/loops/actions/identify-gate-subject/action.yml

@@ -1,122 +1,134 @@
-# Managed by @plainconceptsplatform/workflows. Source: loops/actions/identify-gate-subject/action.yml. Update with workflows update --force; consumer edits may be overwritten.
-name: Identify gate subject
-description: Confirm the pull request is one we authored, resolve the issue it closes, and check that issue carries the required label.
-inputs:
-  token:
-    description: GitHub token with issues and pull-requests read access.
-    required: true
-  pr-number:
-    description: Pull request number to gate.
-    required: true
-  ci-conclusion:
-    description: Conclusion reported by the CI run that triggered this gate. If empty, fetches from the PR's latest CI run.
-    required: false
-    default: ''
-  linked-issue:
-    description: Issue the pull request closes, when the router already resolved it.
-    required: false
-    default: ''
-  require-label:
-    description: Label the closing issue must carry. Empty disables the check.
-    required: false
-    default: ''
-outputs:
-  found:
-    description: Whether a valid gate subject was found.
-    value: ${{ steps.identify.outputs.found }}
-  pr:
-    description: Pull request number.
-    value: ${{ steps.identify.outputs.pr }}
-  issue:
-    description: Issue number the pull request closes.
-    value: ${{ steps.identify.outputs.issue }}
-  conclusion:
-    description: CI conclusion, passed through unchanged or fetched from latest CI run.
-    value: ${{ steps.identify.outputs.conclusion }}
-  run-id:
-    description: CI run ID when fetched.
-    value: ${{ steps.identify.outputs.run-id }}
-runs:
-  using: composite
-  steps:
-    - name: Identify pull request and closing issue
-      id: identify
-      shell: bash
-      env:
-        GH_TOKEN: ${{ inputs.token }}
-        REPO: ${{ github.repository }}
-        PR_NUMBER: ${{ inputs.pr-number }}
-        CONCLUSION: ${{ inputs.ci-conclusion }}
-        LINKED_ISSUE: ${{ inputs.linked-issue }}
-        REQUIRE_LABEL: ${{ inputs.require-label }}
-      run: |
-        set -euo pipefail
-
-        none() {
-          echo "found=false" >> "$GITHUB_OUTPUT"
-          echo "$1"
-          exit 0
-        }
-
-        pr="$(gh pr view "$PR_NUMBER" --repo "$REPO" \
-          --json state,author,closingIssuesReferences,body)"
-
-        [ "$(jq -r '.state' <<<"$pr")" = "OPEN" ] || none "PR #$PR_NUMBER is not open"
-
-        # Use GitHub's bot flag because App login formats differ across APIs.
-        if [ "$(jq -r '.author.is_bot' <<<"$pr")" != "true" ]; then
-          none "PR #$PR_NUMBER was authored by $(jq -r '.author.login' <<<"$pr"), a human."
-        fi
-
-        issue="$LINKED_ISSUE"
-
-        if [ -z "$issue" ]; then
-          issue="$(jq -r '.closingIssuesReferences[0].number // empty' <<<"$pr")"
-        fi
-
-        if [ -z "$issue" ]; then
-          issue="$(jq -r '.body // ""' <<<"$pr" |
-            grep -oiE '(close[sd]?|fixe?[sd]?|resolve[sd]?) +#[0-9]+' |
-            grep -oE '[0-9]+' | head -n 1 || true)"
-        fi
-
-        [ -n "$issue" ] || none "PR #$PR_NUMBER does not close a numbered issue"
-
-        if [ -n "$REQUIRE_LABEL" ]; then
-          labels="$(gh issue view "$issue" --repo "$REPO" --json labels \
-            --jq '[.labels[].name]')"
-
-          if ! jq -e --arg name "$REQUIRE_LABEL" 'index($name)' >/dev/null <<<"$labels"; then
-            none "issue #$issue does not carry $REQUIRE_LABEL (has: $(jq -r 'join(", ")' <<<"$labels"))"
-          fi
-        fi
-
-        # Fetch CI conclusion if not provided (label-triggered runs)
-        ci_conclusion="$CONCLUSION"
-        ci_run_id=""
-        if [ -z "$ci_conclusion" ]; then
-          head_sha="$(gh pr view "$PR_NUMBER" --repo "$REPO" --json headRefOid --jq '.headRefOid')"
-          # A run keeps the name it had when it ran, so a repository whose CI was renamed still
-          # carries runs under the old casing. Fold the name before comparing.
-          ci_run="$(gh api "repos/$REPO/actions/runs?head_sha=$head_sha&per_page=100" \
-            --jq '[.workflow_runs[] | select((.name | ascii_downcase) == "app: ci" or (.name | ascii_downcase) == "ci")] | sort_by(.created_at) | last')"
-          
-          if [ -n "$ci_run" ] && [ "$ci_run" != "null" ]; then
-            ci_conclusion="$(jq -r '.conclusion // "pending"' <<<"$ci_run")"
-            ci_run_id="$(jq -r '.id' <<<"$ci_run")"
-            echo "::notice::Fetched CI status: $ci_conclusion (run $ci_run_id)"
-          else
-            ci_conclusion="unknown"
-            echo "::warning::No CI run found for PR #$PR_NUMBER"
-          fi
-        fi
-
-        {
-          echo "found=true"
-          echo "pr=$PR_NUMBER"
-          echo "issue=$issue"
-          echo "conclusion=$ci_conclusion"
-          echo "run-id=$ci_run_id"
-        } >> "$GITHUB_OUTPUT"
-
-        echo "PR #$PR_NUMBER closes #$issue; CI concluded $ci_conclusion"
+# Managed by @plainconceptsplatform/workflows. Source: loops/actions/identify-gate-subject/action.yml. Update with workflows update --force; consumer edits may be overwritten.
+name: Identify gate subject
+description: Confirm the pull request is one we authored, resolve the issue it closes, and check that issue carries the required label.
+inputs:
+  token:
+    description: GitHub token with issues and pull-requests read access.
+    required: true
+  pr-number:
+    description: Pull request number to gate.
+    required: true
+  ci-conclusion:
+    description: Conclusion reported by the CI run that triggered this gate. If empty, fetches from the PR's latest CI run.
+    required: false
+    default: ''
+  ci-run-id:
+    description: CI run ID reported by the run that triggered this gate. If empty, resolved from the PR's latest CI run.
+    required: false
+    default: ''
+  linked-issue:
+    description: Issue the pull request closes, when the router already resolved it.
+    required: false
+    default: ''
+  require-label:
+    description: Label the closing issue must carry. Empty disables the check.
+    required: false
+    default: ''
+outputs:
+  found:
+    description: Whether a valid gate subject was found.
+    value: ${{ steps.identify.outputs.found }}
+  pr:
+    description: Pull request number.
+    value: ${{ steps.identify.outputs.pr }}
+  issue:
+    description: Issue number the pull request closes.
+    value: ${{ steps.identify.outputs.issue }}
+  conclusion:
+    description: CI conclusion, passed through unchanged or fetched from latest CI run.
+    value: ${{ steps.identify.outputs.conclusion }}
+  run-id:
+    description: CI run ID when fetched.
+    value: ${{ steps.identify.outputs.run-id }}
+runs:
+  using: composite
+  steps:
+    - name: Identify pull request and closing issue
+      id: identify
+      shell: bash
+      env:
+        GH_TOKEN: ${{ inputs.token }}
+        REPO: ${{ github.repository }}
+        PR_NUMBER: ${{ inputs.pr-number }}
+        CONCLUSION: ${{ inputs.ci-conclusion }}
+        CI_RUN_ID: ${{ inputs.ci-run-id }}
+        LINKED_ISSUE: ${{ inputs.linked-issue }}
+        REQUIRE_LABEL: ${{ inputs.require-label }}
+      run: |
+        set -euo pipefail
+
+        none() {
+          echo "found=false" >> "$GITHUB_OUTPUT"
+          echo "$1"
+          exit 0
+        }
+
+        pr="$(gh pr view "$PR_NUMBER" --repo "$REPO" \
+          --json state,author,closingIssuesReferences,body)"
+
+        [ "$(jq -r '.state' <<<"$pr")" = "OPEN" ] || none "PR #$PR_NUMBER is not open"
+
+        # Use GitHub's bot flag because App login formats differ across APIs.
+        if [ "$(jq -r '.author.is_bot' <<<"$pr")" != "true" ]; then
+          none "PR #$PR_NUMBER was authored by $(jq -r '.author.login' <<<"$pr"), a human."
+        fi
+
+        issue="$LINKED_ISSUE"
+
+        if [ -z "$issue" ]; then
+          issue="$(jq -r '.closingIssuesReferences[0].number // empty' <<<"$pr")"
+        fi
+
+        if [ -z "$issue" ]; then
+          issue="$(jq -r '.body // ""' <<<"$pr" |
+            grep -oiE '(close[sd]?|fixe?[sd]?|resolve[sd]?) +#[0-9]+' |
+            grep -oE '[0-9]+' | head -n 1 || true)"
+        fi
+
+        [ -n "$issue" ] || none "PR #$PR_NUMBER does not close a numbered issue"
+
+        if [ -n "$REQUIRE_LABEL" ]; then
+          labels="$(gh issue view "$issue" --repo "$REPO" --json labels \
+            --jq '[.labels[].name]')"
+
+          if ! jq -e --arg name "$REQUIRE_LABEL" 'index($name)' >/dev/null <<<"$labels"; then
+            none "issue #$issue does not carry $REQUIRE_LABEL (has: $(jq -r 'join(", ")' <<<"$labels"))"
+          fi
+        fi
+
+        # The run ID is what lets the gate read the failing job and its logs, so it has to be
+        # resolved on every path -- not only the label-triggered one. It used to be set inside
+        # `if [ -z "$ci_conclusion" ]`, which meant the caller that *knew* the ID got an empty
+        # one: the router passes ci-conclusion and ci-run-id together, so the branch was skipped
+        # and the value discarded. The gate then wrote `failed-jobs.json` as `[]`, and the agent,
+        # with no failing job name and no logs, escalated to `review`. Pliny-Bot #129 and #131
+        # both stalled on a human that way while CI was legitimately red and remediable.
+        ci_conclusion="$CONCLUSION"
+        ci_run_id="$CI_RUN_ID"
+        if [ -z "$ci_conclusion" ] || [ -z "$ci_run_id" ]; then
+          head_sha="$(gh pr view "$PR_NUMBER" --repo "$REPO" --json headRefOid --jq '.headRefOid')"
+          # A run keeps the name it had when it ran, so a repository whose CI was renamed still
+          # carries runs under the old casing. Fold the name before comparing.
+          ci_run="$(gh api "repos/$REPO/actions/runs?head_sha=$head_sha&per_page=100"             --jq '[.workflow_runs[] | select((.name | ascii_downcase) == "app: ci" or (.name | ascii_downcase) == "ci")] | sort_by(.created_at) | last')"
+
+          if [ -n "$ci_run" ] && [ "$ci_run" != "null" ]; then
+            [ -n "$ci_conclusion" ] || ci_conclusion="$(jq -r '.conclusion // "pending"' <<<"$ci_run")"
+            [ -n "$ci_run_id" ] || ci_run_id="$(jq -r '.id' <<<"$ci_run")"
+            echo "::notice::Resolved CI status: $ci_conclusion (run $ci_run_id)"
+          elif [ -z "$ci_conclusion" ]; then
+            ci_conclusion="unknown"
+            echo "::warning::No CI run found for PR #$PR_NUMBER"
+          else
+            echo "::warning::CI concluded $ci_conclusion but no run was found for PR #$PR_NUMBER; the gate has no failure evidence"
+          fi
+        fi
+
+        {
+          echo "found=true"
+          echo "pr=$PR_NUMBER"
+          echo "issue=$issue"
+          echo "conclusion=$ci_conclusion"
+          echo "run-id=$ci_run_id"
+        } >> "$GITHUB_OUTPUT"
+
+        echo "PR #$PR_NUMBER closes #$issue; CI concluded $ci_conclusion"

package/loops/actions/require-open-issue/action.yml

@@ -0,0 +1,59 @@
+# Managed by @plainconceptsplatform/workflows. Source: loops/actions/require-open-issue/action.yml. Update with `workflows update --force`; consumer edits may be overwritten.
+name: Require an open issue
+description: Report whether the issue is still open, read now rather than from the event that started the run.
+inputs:
+  token:
+    description: GitHub token with issues read access.
+    required: true
+  issue-number:
+    description: Issue to check.
+    required: true
+outputs:
+  open:
+    description: '"true" when the issue is still open, "false" when it is closed or unreadable.'
+    value: ${{ steps.check.outputs.open }}
+runs:
+  using: composite
+  steps:
+    # The classifier already refuses a closed issue, but it can only read
+    # `github.event.issue.state`, which is the state at the moment the event fired and is absent
+    # altogether on a workflow_dispatch. This fleet queues for a runner for ten minutes and more,
+    # so an issue can be closed between the event and the pickup. Numa #659: a comment at
+    # 09:02:22 dispatched refine, the issue was closed a second later, the run reached this point
+    # at 09:15:53 and refined a closed issue for thirty-eight minutes, ending by labelling it
+    # `refined`, `implement` and `sp-5`. Every job reported success.
+    - name: Read the issue state now
+      id: check
+      shell: bash
+      env:
+        GH_TOKEN: ${{ inputs.token }}
+        REPO: ${{ github.repository }}
+        ISSUE: ${{ inputs.issue-number }}
+      run: |
+        set -uo pipefail
+        if [ -z "${ISSUE:-}" ]; then
+          echo "open=true" >> "$GITHUB_OUTPUT"
+          echo "No issue number given; nothing to check."
+          exit 0
+        fi
+        # Three tries: a transient API failure must not park work a person then has to restart.
+        # Defaulting to open on an unreadable issue keeps the worker's existing behaviour, which
+        # is the safer side of this check -- it costs a wasted run, never a lost one.
+        state=""
+        for _ in 1 2 3; do
+          if state=$(gh issue view "$ISSUE" --repo "$REPO" --json state --jq '.state'); then break; fi
+          sleep 5
+        done
+        case "${state:-}" in
+          CLOSED|closed)
+            echo "open=false" >> "$GITHUB_OUTPUT"
+            echo "::notice::Issue #${ISSUE} was closed after this run was dispatched; stopping before any work is done."
+            ;;
+          "")
+            echo "open=true" >> "$GITHUB_OUTPUT"
+            echo "::warning::Could not read the state of issue #${ISSUE} after three tries; continuing."
+            ;;
+          *)
+            echo "open=true" >> "$GITHUB_OUTPUT"
+            ;;
+        esac

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

package/loops/workflows/agent-release.md

@@ -29,8 +29,8 @@ on:
         type: string
         default: "auto"
 
-runs-on: agents-arc
-runs-on-slim: agents-arc
+runs-on: RunnerLandingZone
+runs-on-slim: RunnerLandingZone
 
 secrets:
   OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
@@ -98,7 +98,7 @@ jobs:
       always() &&
       needs.agent.result == 'success' &&
       needs.safe_outputs.result == 'success'
-    runs-on: agents-arc
+    runs-on: RunnerLandingZone
     permissions:
       contents: write
     steps:
@@ -205,7 +205,7 @@ jobs:
     if: >
       always() &&
       (needs.agent.result != 'success' || needs.safe_outputs.result != 'success')
-    runs-on: agents-arc
+    runs-on: RunnerLandingZone
     permissions:
       contents: read
     steps:

package/loops/workflows/agent-triage.md

@@ -70,9 +70,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
@@ -296,7 +328,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

package/loops/workflows/work-router.yml

@@ -242,7 +242,7 @@ permissions:
 jobs:
   # Public repositories must check repository permission before an event can start a model.
   authorize:
-    runs-on: ubuntu-latest
+    runs-on: RunnerLandingZone
     timeout-minutes: 5
     permissions:
       contents: read
@@ -345,7 +345,7 @@ jobs:
           esac
 
   classify:
-    runs-on: ubuntu-latest
+    runs-on: RunnerLandingZone
     timeout-minutes: 5
     permissions:
       contents: read
@@ -402,7 +402,7 @@ jobs:
   check-implement-pr:
     needs: [classify, authorize]
     if: needs.classify.outputs.route == 'implement' && needs.authorize.outputs.trusted == 'true'
-    runs-on: ubuntu-latest
+    runs-on: RunnerLandingZone
     timeout-minutes: 3
     permissions:
       contents: read
@@ -493,7 +493,7 @@ jobs:
   dispatch-triage:
     needs: [classify, authorize]
     if: needs.classify.outputs.route == 'triage' && needs.authorize.outputs.is_outside_collaborator == 'true'
-    runs-on: ubuntu-latest
+    runs-on: RunnerLandingZone
     timeout-minutes: 5
     permissions:
       actions: write
@@ -621,7 +621,7 @@ jobs:
     if: >
       needs.classify.outputs.route == 'bot-approve' &&
         (github.actor == 'app/github-actions' || github.actor == 'platform-devbox[bot]')
-    runs-on: ubuntu-latest
+    runs-on: RunnerLandingZone
     timeout-minutes: 5
     permissions:
       actions: write
@@ -678,7 +678,7 @@ jobs:
           github.event.pull_request.head.repo.full_name == github.repository
         )
       )
-    runs-on: ubuntu-latest
+    runs-on: RunnerLandingZone
     timeout-minutes: 10
     permissions:
       contents: read
@@ -871,7 +871,7 @@ jobs:
   reconcile-bot-pr-runs:
     needs: classify
     if: needs.classify.outputs.route == 'reconcile-bot-pr-runs'
-    runs-on: ubuntu-latest
+    runs-on: RunnerLandingZone
     timeout-minutes: 5
     permissions:
       contents: read
@@ -1079,12 +1079,26 @@ jobs:
                 -f "inputs[ci-conclusion]=$ci_conclusion" \
                 -f "inputs[ci-run-id]=$ci_run_id" \
                 -f "inputs[attempts_so_far]=$attempts"
+
+              # One gate per tick, because that is all the concurrency group can hold. The gate
+              # runs in `merge-belt`, and GitHub keeps only the most recent *pending* run in a
+              # group -- `cancel-in-progress: false` does not change that, it only protects a run
+              # that has already started. A tick that dispatched three gates therefore ran the
+              # last and silently cancelled the other two: no comment, no attempt recorded, and
+              # nothing on the pull request to say it had been passed over. Seen on Pliny-Bot,
+              # where dispatching a gate for PR #135 cancelled the one queued for PR #136.
+              #
+              # Stopping here loses nothing: every pull request eligible this tick is still
+              # eligible next tick, and a run that never started consumes no attempt. The belt
+              # now does one thing and says so, instead of appearing to start work it discarded.
+              echo "One gate dispatched this tick; any other eligible pull request waits for the next one."
+              break
             done
 
   audit-close:
     needs: classify
     if: needs.classify.outputs.route == 'audit-close'
-    runs-on: ubuntu-latest
+    runs-on: RunnerLandingZone
     timeout-minutes: 15
     concurrency:
       group: audit-close
@@ -1109,7 +1123,7 @@ jobs:
   cleanup-artifacts:
     needs: classify
     if: needs.classify.outputs.route == 'cleanup-artifacts' && !github.event.repository.fork
-    runs-on: ubuntu-latest
+    runs-on: RunnerLandingZone
     timeout-minutes: 15
     concurrency:
       group: cleanup-artifacts
@@ -1133,7 +1147,7 @@ jobs:
   housekeeping:
     needs: classify
     if: needs.classify.outputs.route == 'housekeeping' && !github.event.repository.fork
-    runs-on: ubuntu-latest
+    runs-on: RunnerLandingZone
     timeout-minutes: 15
     concurrency:
       group: housekeeping
@@ -1172,7 +1186,7 @@ jobs:
   validate:
     needs: classify
     if: needs.classify.outputs.route == 'validate'
-    runs-on: ubuntu-latest
+    runs-on: RunnerLandingZone
     timeout-minutes: 10
     permissions:
       contents: read

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plainconceptsplatform/workflows",
-  "version": "0.17.0",
+  "version": "0.19.2",
   "description": "Install and update Platform GitHub agentic workflows.",
   "keywords": [
     "github-actions",
@@ -26,7 +26,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsc --project tsconfig.build.json",
+    "build": "tsc --project tsconfig.build.json && node ./scripts/copy-loops.mjs",
     "test": "vitest run",
     "typecheck": "tsc --noEmit --project tsconfig.json",
     "release": "pnpm build && pnpm test && npm publish --access public",