@plainconceptsplatform/workflows 0.1.0

package/loops/actions/add-issue-labels/action.yml

@@ -0,0 +1,29 @@
+name: Add issue labels
+description: Add one or more labels to an issue or pull request.
+inputs:
+  token:
+    description: GitHub token used by github-script.
+    required: true
+  issue-number:
+    description: Issue or pull request number.
+    required: true
+  labels:
+    description: Newline-delimited labels to add.
+    required: true
+runs:
+  using: composite
+  steps:
+    - name: Add labels
+      uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+      env:
+        ISSUE_NUMBER: ${{ inputs.issue-number }}
+        LABELS: ${{ inputs.labels }}
+      with:
+        github-token: ${{ inputs.token }}
+        script: |
+          const labels = process.env.LABELS.split(/\r?\n/).filter(Boolean);
+          await github.rest.issues.addLabels({
+            ...context.repo,
+            issue_number: Number(process.env.ISSUE_NUMBER),
+            labels,
+          });

package/loops/actions/agent-output.cjs

@@ -0,0 +1,16 @@
+const fs = require('fs');
+
+// Every apply-agent-* action reads the same artifact the same way: a missing file means the
+// agent produced nothing, which is a normal outcome rather than a failure.
+function readAgentItems(outputFile, type) {
+  if (!outputFile || !fs.existsSync(outputFile)) {
+    return [];
+  }
+
+  const parsed = JSON.parse(fs.readFileSync(outputFile, 'utf8'));
+  const items = Array.isArray(parsed.items) ? parsed.items : [];
+
+  return type ? items.filter((item) => item.type === type) : items;
+}
+
+module.exports = { readAgentItems };

package/loops/actions/apply-agent-bundle/action.yml

@@ -0,0 +1,23 @@
+name: Apply agent bundle
+description: Fast-forward an intended branch to the single commit exported by a verified git bundle.
+inputs:
+  bundle-file:
+    description: Path to the git bundle from the agent artifact.
+    required: true
+  target-branch:
+    description: Branch that must fast-forward to the bundle commit.
+    required: true
+  base-branch:
+    description: Existing branch used only when target-branch does not exist.
+    required: false
+    default: ''
+runs:
+  using: composite
+  steps:
+    - name: Fast-forward branch from bundle
+      shell: bash
+      env:
+        BUNDLE_FILE: ${{ inputs.bundle-file }}
+        TARGET_BRANCH: ${{ inputs.target-branch }}
+        BASE_BRANCH: ${{ inputs.base-branch }}
+      run: bash "$GITHUB_ACTION_PATH/apply-bundle.sh" "$BUNDLE_FILE" "$TARGET_BRANCH" "$BASE_BRANCH"

package/loops/actions/apply-agent-bundle/apply-bundle.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+BUNDLE_FILE=$1
+TARGET_BRANCH=$2
+BASE_BRANCH=${3:-}
+
+fail() {
+  echo "::error::$1"
+  exit 1
+}
+
+[ -f "$BUNDLE_FILE" ] || fail "Git bundle not found: $BUNDLE_FILE"
+git check-ref-format --branch "$TARGET_BRANCH" >/dev/null || fail "Invalid target branch: $TARGET_BRANCH"
+
+if [ -n "$BASE_BRANCH" ]; then
+  git check-ref-format --branch "$BASE_BRANCH" >/dev/null || fail "Invalid base branch: $BASE_BRANCH"
+fi
+
+git bundle verify "$BUNDLE_FILE"
+mapfile -t BUNDLE_HEADS < <(git bundle list-heads "$BUNDLE_FILE")
+[ "${#BUNDLE_HEADS[@]}" -eq 1 ] || fail "Git bundle must expose exactly one ref"
+
+read -r BUNDLE_TIP BUNDLE_REF <<< "${BUNDLE_HEADS[0]}"
+if [ -z "$BUNDLE_TIP" ] || [ -z "$BUNDLE_REF" ]; then
+  fail "Git bundle ref is invalid"
+fi
+
+if git ls-remote --exit-code --heads origin "refs/heads/$TARGET_BRANCH" >/dev/null; then
+  git fetch --no-tags origin "refs/heads/$TARGET_BRANCH:refs/remotes/origin/$TARGET_BRANCH"
+  TARGET_TIP=$(git rev-parse "refs/remotes/origin/$TARGET_BRANCH")
+else
+  [ -n "$BASE_BRANCH" ] || fail "Target branch does not exist and no base branch was supplied"
+  git fetch --no-tags origin "refs/heads/$BASE_BRANCH:refs/remotes/origin/$BASE_BRANCH"
+  TARGET_TIP=$(git rev-parse "refs/remotes/origin/$BASE_BRANCH")
+fi
+
+git fetch --no-tags "$BUNDLE_FILE" "$BUNDLE_REF"
+[ "$(git cat-file -t "$BUNDLE_TIP")" = commit ] || fail "Git bundle ref must point directly to a commit"
+[ "$(git rev-parse FETCH_HEAD)" = "$BUNDLE_TIP" ] || fail "Fetched bundle commit did not match listed bundle ref"
+
+git merge-base --is-ancestor "$TARGET_TIP" "$BUNDLE_TIP" || fail "Git bundle cannot fast-forward $TARGET_BRANCH"
+git switch --detach "$TARGET_TIP"
+git merge --ff-only "$BUNDLE_TIP"
+git push origin "HEAD:refs/heads/$TARGET_BRANCH"

package/loops/actions/apply-agent-comments/action.yml

@@ -0,0 +1,41 @@
+name: Apply agent comments
+description: Post every add_comment item from agent_output.json.
+inputs:
+  output-file:
+    description: Path to agent_output.json.
+    required: true
+  token:
+    description: GitHub token with issues:write and pull-requests:write.
+    required: true
+runs:
+  using: composite
+  steps:
+    - name: Post comments
+      uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+      env:
+        AGENT_OUTPUT_LIB: ${{ github.action_path }}/../agent-output.cjs
+        OUTPUT_FILE: ${{ inputs.output-file }}
+      with:
+        github-token: ${{ inputs.token }}
+        script: |
+          const { readAgentItems } = require(process.env.AGENT_OUTPUT_LIB);
+          const items = readAgentItems(process.env.OUTPUT_FILE, 'add_comment');
+
+          let posted = 0;
+
+          for (const item of items) {
+            if (!item.item_number) {
+              core.warning(`add_comment item has no item_number, skipping: ${JSON.stringify(item)}`);
+              continue;
+            }
+
+            await github.rest.issues.createComment({
+              ...context.repo,
+              issue_number: Number(item.item_number),
+              body: item.body,
+            });
+
+            posted += 1;
+          }
+
+          core.info(`Posted ${posted} comment(s).`);

package/loops/actions/apply-agent-labels/action.yml

@@ -0,0 +1,54 @@
+name: Apply agent labels
+description: Apply every add_labels and remove_labels item from agent_output.json.
+inputs:
+  output-file:
+    description: Path to agent_output.json.
+    required: true
+  token:
+    description: GitHub token with issues:write.
+    required: true
+runs:
+  using: composite
+  steps:
+    - name: Apply label changes
+      uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+      env:
+        AGENT_OUTPUT_LIB: ${{ github.action_path }}/../agent-output.cjs
+        OUTPUT_FILE: ${{ inputs.output-file }}
+      with:
+        github-token: ${{ inputs.token }}
+        script: |
+          const { readAgentItems } = require(process.env.AGENT_OUTPUT_LIB);
+          const items = readAgentItems(process.env.OUTPUT_FILE)
+            .filter((item) => item.type === 'add_labels' || item.type === 'remove_labels');
+
+          let added = 0;
+          let removed = 0;
+
+          for (const item of items) {
+            const labels = (item.labels ?? []).map((label) => label.name).filter(Boolean);
+
+            if (!item.item_number || labels.length === 0) {
+              core.warning(`${item.type} item is not actionable, skipping: ${JSON.stringify(item)}`);
+              continue;
+            }
+
+            const issue_number = Number(item.item_number);
+
+            if (item.type === 'add_labels') {
+              await github.rest.issues.addLabels({ ...context.repo, issue_number, labels });
+              added += labels.length;
+              continue;
+            }
+
+            for (const name of labels) {
+              try {
+                await github.rest.issues.removeLabel({ ...context.repo, issue_number, name });
+                removed += 1;
+              } catch (error) {
+                if (error.status !== 404) throw error;
+              }
+            }
+          }
+
+          core.info(`Added ${added} label(s), removed ${removed}.`);

package/loops/actions/apply-agent-output/action.yml

@@ -0,0 +1,107 @@
+name: Apply agent output
+description: Download the agent artifact and apply its safe outputs in one fixed order, so every worker concludes the same way.
+inputs:
+  token:
+    description: GitHub token the writes are made with.
+    required: true
+  artifact-name:
+    description: >-
+      Name of the agent artifact. Callers pass the activation job's artifact_prefix output
+      followed by "agent"; gh-aw derives that prefix from the workflow's inputs, so it is
+      non-empty for every workflow_call worker and the bare name never resolves.
+    required: true
+  merge-pull-request:
+    description: Apply merge_pull_request items.
+    required: false
+    default: 'false'
+  push-to-branch:
+    description: Apply push_to_pull_request_branch items.
+    required: false
+    default: 'false'
+  close-issues:
+    description: Apply close_issue items.
+    required: false
+    default: 'false'
+  create-issues:
+    description: Apply create_issue items.
+    required: false
+    default: 'false'
+  update-issues:
+    description: Apply update_issue items.
+    required: false
+    default: 'false'
+  apply-labels:
+    description: Apply add_labels and remove_labels items.
+    required: false
+    default: 'true'
+  fallback-issue-number:
+    description: Issue an update_issue item targets when it names none.
+    required: false
+    default: ''
+outputs:
+  item-count:
+    description: Number of items the agent produced.
+    value: ${{ steps.output.outputs.item-count }}
+  first-issue-number:
+    description: Issue number of the first issue created, or empty.
+    value: ${{ steps.create-issues.outputs.first-issue-number }}
+runs:
+  using: composite
+  steps:
+    - name: Download agent output
+      id: output
+      uses: ./.github/actions/download-agent-output
+      with:
+        artifact-name: ${{ inputs.artifact-name }}
+
+    - name: Merge pull request
+      if: inputs.merge-pull-request == 'true' && steps.output.outputs.item-count != '0'
+      uses: ./.github/actions/merge-agent-pr
+      with:
+        output-file: ${{ steps.output.outputs.output-file }}
+        token: ${{ inputs.token }}
+
+    - name: Push to pull request branch
+      if: inputs.push-to-branch == 'true' && steps.output.outputs.item-count != '0'
+      uses: ./.github/actions/push-agent-branch
+      with:
+        output-file: ${{ steps.output.outputs.output-file }}
+        bundle-file: ${{ steps.output.outputs.bundle-file }}
+        token: ${{ inputs.token }}
+
+    - name: Close issues
+      if: inputs.close-issues == 'true' && steps.output.outputs.item-count != '0'
+      uses: ./.github/actions/close-agent-issues
+      with:
+        output-file: ${{ steps.output.outputs.output-file }}
+        token: ${{ inputs.token }}
+
+    - name: Update issues
+      if: inputs.update-issues == 'true' && steps.output.outputs.item-count != '0'
+      uses: ./.github/actions/update-agent-issues
+      with:
+        output-file: ${{ steps.output.outputs.output-file }}
+        token: ${{ inputs.token }}
+        fallback-issue-number: ${{ inputs.fallback-issue-number }}
+
+    - name: Create issues
+      id: create-issues
+      if: inputs.create-issues == 'true' && steps.output.outputs.item-count != '0'
+      uses: ./.github/actions/create-agent-issues
+      with:
+        output-file: ${{ steps.output.outputs.output-file }}
+        token: ${{ inputs.token }}
+
+    - name: Post agent comments
+      if: steps.output.outputs.item-count != '0'
+      uses: ./.github/actions/apply-agent-comments
+      with:
+        output-file: ${{ steps.output.outputs.output-file }}
+        token: ${{ inputs.token }}
+
+    - name: Apply agent label changes
+      if: inputs.apply-labels == 'true' && steps.output.outputs.item-count != '0'
+      uses: ./.github/actions/apply-agent-labels
+      with:
+        output-file: ${{ steps.output.outputs.output-file }}
+        token: ${{ inputs.token }}

package/loops/actions/audit-close/action.yml

@@ -0,0 +1,103 @@
+name: Close audit reports
+description: Close open audit reports once every issue they reference is closed.
+inputs:
+  token:
+    description: GitHub token with issues write access.
+    required: true
+runs:
+  using: composite
+  steps:
+    - name: Close every report whose referenced issues are all closed
+      uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+      with:
+        github-token: ${{ inputs.token }}
+        script: |
+          const reports = await github.paginate(github.rest.issues.listForRepo, {
+            ...context.repo,
+            state: 'open',
+            labels: 'audit',
+            per_page: 100,
+          });
+
+          if (reports.length === 0) {
+            core.info('No open audit reports.');
+            return;
+          }
+
+          // Skip `owner/repo#12` and `abc#12`: only a bare `#12` references this repository.
+          const referencedIssues = (body) => {
+            const matches = (body ?? '').matchAll(/(?:^|[^A-Za-z0-9_/])#(\d+)/g);
+            return [...new Set([...matches].map((match) => Number(match[1])))];
+          };
+
+          let closed = 0;
+          let keptOpen = 0;
+
+          for (const report of reports.sort((a, b) => a.number - b.number)) {
+            const refs = referencedIssues(report.body).filter((n) => n !== report.number);
+
+            const stillOpen = [];
+            const unknown = [];
+            let closedRefs = 0;
+            let resolved = 0;
+
+            for (const ref of refs) {
+              let state;
+
+              try {
+                ({ data: { state } } = await github.rest.issues.get({
+                  ...context.repo,
+                  issue_number: ref,
+                }));
+              } catch (error) {
+                if (error.status === 404) {
+                  core.info(`#${report.number}: ignoring #${ref}, not an issue in this repository`);
+                  continue;
+                }
+                unknown.push(ref);
+                resolved += 1;
+                continue;
+              }
+
+              resolved += 1;
+              if (state === 'closed') closedRefs += 1;
+              else stillOpen.push(ref);
+            }
+
+            if (stillOpen.length > 0) {
+              core.info(`#${report.number}: kept open, still-open references: ${stillOpen.join(', ')}`);
+              keptOpen += 1;
+              continue;
+            }
+
+            if (unknown.length > 0) {
+              core.info(`#${report.number}: kept open, undetermined references: ${unknown.join(', ')}`);
+              keptOpen += 1;
+              continue;
+            }
+
+            const reason = resolved === 0
+              ? 'This report references no issues.'
+              : `All ${closedRefs} referenced issue(s) are closed.`;
+
+            await github.rest.issues.createComment({
+              ...context.repo,
+              issue_number: report.number,
+              body: `Closed automatically by \`Work Router: audit-close\`. ${reason}`,
+            });
+
+            await github.rest.issues.update({
+              ...context.repo,
+              issue_number: report.number,
+              state: 'closed',
+              state_reason: 'completed',
+            });
+
+            core.info(`#${report.number}: closed. ${reason}`);
+            closed += 1;
+          }
+
+          await core.summary
+            .addHeading('Audit close', 2)
+            .addList([`Reports closed: ${closed}`, `Reports left open: ${keptOpen}`])
+            .write();

package/loops/actions/classify-route/action.yml

@@ -0,0 +1,90 @@
+name: Classify route
+description: Classify the triggering event into exactly one route, and resolve the issue a gated pull request closes.
+inputs:
+  token:
+    description: GitHub token with pull-requests read access.
+    required: true
+outputs:
+  route:
+    description: The single route this event selects, or `none`.
+    value: ${{ steps.classify.outputs.route }}
+  issue-number:
+    description: Issue number the route operates on.
+    value: ${{ steps.classify.outputs.issue-number }}
+  pr-number:
+    description: Pull request number the route operates on.
+    value: ${{ steps.classify.outputs.pr-number }}
+  linked-issue:
+    description: Issue the pull request closes. Empty for routes that do not target one.
+    value: ${{ steps.linked-issue.outputs.issue }}
+  ci-conclusion:
+    description: Conclusion reported by the CI run that triggered a merge-gate route.
+    value: ${{ steps.classify.outputs.ci-conclusion }}
+  ci-run-id:
+    description: Workflow run ID of that CI run.
+    value: ${{ steps.classify.outputs.ci-run-id }}
+  refine-mode:
+    description: first or rerefine.
+    value: ${{ steps.classify.outputs.refine-mode }}
+  direct-mode:
+    description: first or continue.
+    value: ${{ steps.classify.outputs.direct-mode }}
+  trigger-kind:
+    description: scheduled or manual.
+    value: ${{ steps.classify.outputs.trigger-kind }}
+runs:
+  using: composite
+  steps:
+    - name: Classify the event
+      id: classify
+      shell: bash
+      env:
+        EVENT: ${{ github.event_name }}
+        ACTION: ${{ github.event.action }}
+        LABEL: ${{ github.event.label.name }}
+        ISSUE_LABELS: ${{ toJSON(github.event.issue.labels.*.name) }}
+        EVENT_ISSUE_NUMBER: ${{ github.event.issue.number }}
+        EVENT_PR_NUMBER: ${{ github.event.pull_request.number }}
+        COMMENT_ON_PR: ${{ github.event.issue.pull_request != '' }}
+        COMMENT_SENDER_TYPE: ${{ github.event.comment.user.type }}
+        RUN_PR_NUMBER: ${{ github.event.workflow_run.pull_requests[0].number }}
+        RUN_CONCLUSION: ${{ github.event.workflow_run.conclusion }}
+        RUN_ID: ${{ github.event.workflow_run.id }}
+        SCHEDULE: ${{ github.event.schedule }}
+        OPERATION: ${{ github.event.inputs.operation }}
+        INPUT_ISSUE_NUMBER: ${{ github.event.inputs.issue-number }}
+        INPUT_PR_NUMBER: ${{ github.event.inputs.pr-number }}
+        INPUT_MODE: ${{ github.event.inputs.mode }}
+        INPUT_CI_CONCLUSION: ${{ github.event.inputs.ci-conclusion }}
+        INPUT_CI_RUN_ID: ${{ github.event.inputs.ci-run-id }}
+        INPUT_TRIGGER_KIND: ${{ github.event.inputs.trigger-kind }}
+      run: |
+        set -euo pipefail
+
+        bash "${GITHUB_ACTION_PATH}/classify-route.sh" | tee "$RUNNER_TEMP/route.env"
+        cat "$RUNNER_TEMP/route.env" >> "$GITHUB_OUTPUT"
+
+        route="$(sed -n 's/^route=//p' "$RUNNER_TEMP/route.env")"
+        reason="$(sed -n 's/^error=//p' "$RUNNER_TEMP/route.env")"
+
+        if [ "$route" = "none" ] && [ -n "$reason" ]; then
+          echo "::notice::No route for this event: $reason"
+        fi
+
+    - name: Resolve the issue the pull request closes
+      id: linked-issue
+      if: steps.classify.outputs.route == 'merge-gate' || steps.classify.outputs.route == 'apply-review'
+      shell: bash
+      env:
+        GH_TOKEN: ${{ inputs.token }}
+        REPO: ${{ github.repository }}
+        PR_NUMBER: ${{ steps.classify.outputs.pr-number }}
+      run: |
+        set -euo pipefail
+
+        issue="$(gh pr view "$PR_NUMBER" --repo "$REPO" \
+          --json closingIssuesReferences \
+          --jq '.closingIssuesReferences[0].number // empty')"
+
+        echo "issue=${issue}" >> "$GITHUB_OUTPUT"
+        echo "Pull request #${PR_NUMBER} closes issue #${issue:-<none>}"

package/loops/actions/classify-route/classify-route.sh

@@ -0,0 +1,172 @@
+#!/usr/bin/env bash
+# Classify one GitHub event into exactly one route. Pure: no network, no gh calls, so
+# verify-route-matrix.sh can source this file and exercise the same code the router runs.
+#
+# Reads the event facts from the environment and writes `key=value` lines to stdout.
+# The caller appends them to $GITHUB_OUTPUT.
+
+set -euo pipefail
+
+readonly AUDIT_CRON="17 1 * * 1"
+readonly AUDIT_CLOSE_CRON="43 3 * * *"
+readonly CLEANUP_ARTIFACTS_CRON="0 6 * * *"
+readonly STALE_RECOVERY_CRON="0 */2 * * *"
+# Daily, but it proposes far less often than daily: the worker holds one open
+# proposal at a time and skips while that slot is filled. The cron is a heartbeat,
+# the queue is the pacing.
+readonly PROPOSE_CRON="29 7 * * *"
+
+has_label() {
+  jq -e --arg name "$1" 'index($name)' >/dev/null 2>&1 <<<"${ISSUE_LABELS:-[]}"
+}
+
+is_issue_number() {
+  [[ "${1:-}" =~ ^[1-9][0-9]*$ ]]
+}
+
+classify_route() {
+  local route="none" error=""
+  local issue_number="" pr_number="" ci_conclusion="" ci_run_id=""
+  local refine_mode="" direct_mode="" trigger_kind=""
+
+  case "${EVENT:-}" in
+    issues)
+      if [ "${ACTION:-}" = "labeled" ]; then
+        case "${LABEL:-}" in
+          refine)
+            route="refine"
+            refine_mode="first"
+            issue_number="${EVENT_ISSUE_NUMBER:-}"
+            ;;
+          implement)
+            route="implement"
+            issue_number="${EVENT_ISSUE_NUMBER:-}"
+            ;;
+          direct)
+            route="direct"
+            direct_mode="first"
+            issue_number="${EVENT_ISSUE_NUMBER:-}"
+            ;;
+        esac
+      fi
+      ;;
+
+    issue_comment)
+      if [ "${COMMENT_ON_PR:-false}" = "true" ]; then
+        route="apply-review"
+        pr_number="${EVENT_ISSUE_NUMBER:-}"
+      elif [ "${COMMENT_SENDER_TYPE:-}" = "Bot" ]; then
+        error="comment authored by a bot"
+      elif has_label direct; then
+        route="direct"
+        direct_mode="continue"
+        issue_number="${EVENT_ISSUE_NUMBER:-}"
+      elif ! has_label refine; then
+        error="issue does not carry the refine or direct label"
+      else
+        route="refine"
+        refine_mode="rerefine"
+        issue_number="${EVENT_ISSUE_NUMBER:-}"
+      fi
+      ;;
+
+    pull_request_review_comment | pull_request_review)
+      route="apply-review"
+      pr_number="${EVENT_PR_NUMBER:-}"
+      ;;
+
+    pull_request_target)
+      route="bot-approve"
+      ;;
+
+    workflow_run)
+      if is_issue_number "${RUN_PR_NUMBER:-}"; then
+        route="merge-gate"
+        pr_number="${RUN_PR_NUMBER}"
+        ci_conclusion="${RUN_CONCLUSION:-}"
+        ci_run_id="${RUN_ID:-}"
+      else
+        error="CI run has no attached pull request"
+      fi
+      ;;
+
+    schedule)
+      trigger_kind="scheduled"
+      case "${SCHEDULE:-}" in
+        "$AUDIT_CRON") route="audit" ;;
+        "$AUDIT_CLOSE_CRON") route="audit-close" ;;
+        "$CLEANUP_ARTIFACTS_CRON") route="cleanup-artifacts" ;;
+        "$STALE_RECOVERY_CRON") route="stale-recovery" ;;
+        "$PROPOSE_CRON") route="propose" ;;
+        *) error="no route for cron '${SCHEDULE:-}'" ;;
+      esac
+      ;;
+
+    workflow_dispatch)
+      trigger_kind="manual"
+      case "${OPERATION:-}" in
+        refine | implement | direct)
+          if is_issue_number "${INPUT_ISSUE_NUMBER:-}"; then
+            route="${OPERATION}"
+            issue_number="${INPUT_ISSUE_NUMBER}"
+            if [ "$OPERATION" = "refine" ]; then
+              refine_mode="${INPUT_MODE:-first}"
+            elif [ "$OPERATION" = "direct" ]; then
+              direct_mode="${INPUT_MODE:-first}"
+            fi
+          else
+            error="operation '${OPERATION}' needs a positive issue-number, got '${INPUT_ISSUE_NUMBER:-}'"
+          fi
+          ;;
+        apply-review)
+          if is_issue_number "${INPUT_PR_NUMBER:-}"; then
+            route="apply-review"
+            pr_number="${INPUT_PR_NUMBER}"
+          else
+            error="operation 'apply-review' needs a positive pr-number, got '${INPUT_PR_NUMBER:-}'"
+          fi
+          ;;
+        merge-gate)
+          if is_issue_number "${INPUT_PR_NUMBER:-}"; then
+            route="merge-gate"
+            pr_number="${INPUT_PR_NUMBER}"
+            ci_conclusion="${INPUT_CI_CONCLUSION:-}"
+            ci_run_id="${INPUT_CI_RUN_ID:-}"
+          else
+            error="operation 'merge-gate' needs a positive pr-number, got '${INPUT_PR_NUMBER:-}'"
+          fi
+          ;;
+        audit | propose)
+          route="${OPERATION}"
+          trigger_kind="${INPUT_TRIGGER_KIND:-manual}"
+          ;;
+        audit-close | cleanup-artifacts | stale-recovery | validate)
+          route="${OPERATION}"
+          ;;
+        *)
+          error="unknown operation '${OPERATION:-}'"
+          ;;
+      esac
+      ;;
+
+    *)
+      error="unsupported event '${EVENT:-}'"
+      ;;
+  esac
+
+  cat <<EOF
+route=${route}
+issue-number=${issue_number}
+pr-number=${pr_number}
+ci-conclusion=${ci_conclusion}
+ci-run-id=${ci_run_id}
+refine-mode=${refine_mode}
+direct-mode=${direct_mode}
+trigger-kind=${trigger_kind}
+error=${error}
+EOF
+}
+
+if [ "${BASH_SOURCE[0]}" = "$0" ]; then
+  classify_route
+fi