chore: sync actions from gh-aw@v0.74.6 (#108)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

Author: github-actions[bot]

.github/aw/compat.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "./compat.schema.json",
+  "agent-compat-v1": {
+    "cache-ttl-days": 14,
+    "copilot": [
+      {
+        "min-gh-aw": "0.72.0",
+        "max-gh-aw": "*",
+        "min-agent": "1.0.21",
+        "max-agent": "1.0.48",
+        "open": true
+      },
+      {
+        "min-gh-aw": "0.0.1",
+        "max-gh-aw": "0.71.99",
+        "min-agent": "0.0.0",
+        "max-agent": "1.0.21"
+      }
+    ]
+  }
+}

.github/aw/compat.schema.json

@@ -0,0 +1,71 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://github.com/github/gh-aw/.github/aw/compat.schema.json",
+  "title": "gh-aw agent compatibility matrix",
+  "description": "Pins agentic CLI versions to gh-aw release ranges. Consumed by the setup action to install a known-good agent version per gh-aw release. See ADR for the design rationale.",
+  "type": "object",
+  "required": ["agent-compat-v1"],
+  "additionalProperties": false,
+  "properties": {
+    "$schema": {
+      "type": "string"
+    },
+    "agent-compat-v1": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "cache-ttl-days": {
+          "type": "integer",
+          "minimum": 1,
+          "description": "How long the setup action may cache the resolved agent install before re-fetching this matrix."
+        },
+        "copilot": {
+          "$ref": "#/definitions/agentRows"
+        },
+        "claude": {
+          "$ref": "#/definitions/agentRows"
+        }
+      }
+    }
+  },
+  "definitions": {
+    "semver": {
+      "type": "string",
+      "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+(?:-[0-9A-Za-z.-]+)?$"
+    },
+    "ghAwBound": {
+      "oneOf": [
+        { "$ref": "#/definitions/semver" },
+        { "type": "string", "enum": ["*"] }
+      ]
+    },
+    "agentRows": {
+      "type": "array",
+      "minItems": 1,
+      "items": { "$ref": "#/definitions/row" }
+    },
+    "row": {
+      "type": "object",
+      "required": ["min-gh-aw", "max-gh-aw", "min-agent", "max-agent"],
+      "additionalProperties": false,
+      "properties": {
+        "min-gh-aw": { "$ref": "#/definitions/semver" },
+        "max-gh-aw": { "$ref": "#/definitions/ghAwBound" },
+        "min-agent": { "$ref": "#/definitions/semver" },
+        "max-agent": { "$ref": "#/definitions/semver" },
+        "open": {
+          "type": "boolean",
+          "default": true,
+          "description": "When true (the default), the setup action's weekly release process may continue bumping max-agent for this row. Set to false to freeze during rollback or quarantine. Permitted only on the catch-all row (max-gh-aw == \"*\"); bounded rows are closed-by-construction."
+        }
+      },
+      "if": {
+        "properties": { "max-gh-aw": { "const": "*" } }
+      },
+      "then": {},
+      "else": {
+        "not": { "required": ["open"] }
+      }
+    }
+  }
+}

setup/js/add_comment.cjs

@@ -682,18 +682,59 @@ async function main(config = {}) {
       core.warning("Ignoring empty discussion reply_to_id after normalization");
     }
 
+    // add_comment uses snake_case fields. camelCase and kebab-case aliases are
+    // accepted for compatibility with forwarded/legacy payload variants.
+    const explicitCommentIdRaw = message.comment_id ?? message.commentId ?? message["comment-id"];
+    const rawTarget = message.target;
+    const allowedTargets = ["status"];
+    if (rawTarget !== undefined && !allowedTargets.includes(rawTarget)) {
+      return {
+        success: false,
+        error: `target must be one of: [${allowedTargets.join(", ")}]`,
+      };
+    }
+    const isStatusCommentTarget = rawTarget === "status";
+    const statusCommentIdRaw = process.env.GH_AW_COMMENT_ID || "";
+    let commentIdToReuse = null;
+    if (explicitCommentIdRaw !== undefined && explicitCommentIdRaw !== null && String(explicitCommentIdRaw).trim() !== "") {
+      commentIdToReuse = Number(explicitCommentIdRaw);
+      if (!Number.isInteger(commentIdToReuse) || commentIdToReuse <= 0) {
+        return {
+          success: false,
+          error: "comment_id must be a positive integer",
+        };
+      }
+    } else if (isStatusCommentTarget) {
+      const parsedStatusCommentId = Number(statusCommentIdRaw);
+      if (Number.isInteger(parsedStatusCommentId) && parsedStatusCommentId > 0) {
+        commentIdToReuse = parsedStatusCommentId;
+      } else {
+        core.info("target=status was requested but no reusable status comment id was available; creating a new comment");
+      }
+    }
+
     try {
       // Hide older comments if enabled AND append-only-comments is not enabled
       // When append-only-comments is true, we want to keep all comments visible
-      if (hideOlderCommentsEnabled && !appendOnlyComments && workflowId) {
-        await hideOlderComments(githubClient, repoParts.owner, repoParts.repo, itemNumber, workflowId, isDiscussion);
-      } else if (hideOlderCommentsEnabled && appendOnlyComments) {
-        core.info("Skipping hide-older-comments because append-only-comments is enabled");
+      if (hideOlderCommentsEnabled) {
+        if (commentIdToReuse !== null) {
+          core.info("Skipping hide-older-comments because an existing comment is being updated");
+        } else if (appendOnlyComments) {
+          core.info("Skipping hide-older-comments because append-only-comments is enabled");
+        } else if (workflowId) {
+          await hideOlderComments(githubClient, repoParts.owner, repoParts.repo, itemNumber, workflowId, isDiscussion);
+        }
       }
 
       /** @type {{ id: string | number, html_url: string }} */
       let comment;
       if (isDiscussion) {
+        if (commentIdToReuse !== null) {
+          return {
+            success: false,
+            error: "comment_id and target=status are only supported for issue and pull request comments",
+          };
+        }
         // When triggered by a discussion_comment event (without explicit item_number),
         // reply as a threaded comment to the triggering comment instead of posting top-level.
         // GitHub Discussions only supports two nesting levels, so if the triggering comment is
@@ -729,6 +770,15 @@ async function main(config = {}) {
             body: processedBody,
           });
           comment = data;
+        } else if (commentIdToReuse !== null) {
+          core.info(`Updating existing comment ID: ${commentIdToReuse}`);
+          const { data } = await githubClient.rest.issues.updateComment({
+            owner: repoParts.owner,
+            repo: repoParts.repo,
+            comment_id: commentIdToReuse,
+            body: processedBody,
+          });
+          comment = data;
         } else {
           if (shouldReplyToTriggeringPRReviewComment) {
             core.warning("Triggering PR review comment ID is missing or invalid; falling back to top-level PR comment");

setup/js/model_multipliers.json

@@ -131,6 +131,7 @@
     "gemini-3.1-flash-lite-preview": 0.1,
     "gemini-3.1-flash-image-preview": 0.33,
     "gemini-3.1-flash-tts-preview": 0.1,
+    "gemini-3.5-flash": 14.0,
     "gemini-2.5-computer-use-preview": 0.2,
     "gemini-2.5-computer-use-preview-10-2025": 0.2,
     "gemini-robotics-er-1.5-preview": 0.2,

setup/js/package.json

@@ -7,13 +7,13 @@
     "@actions/github-script": "github:actions/github-script#v9.0.0",
     "@actions/glob": "^0.7.0",
     "@actions/io": "^3.0.2",
-    "@types/node": "^25.7.0",
+    "@types/node": "^25.9.1",
     "@vitest/coverage-v8": "^4.1.4",
     "@vitest/ui": "^4.1.6",
     "minimatch": ">=3.1.3",
     "prettier": "^3.8.3",
     "typescript": "^6.0.3",
-    "vite": "^8.0.12",
+    "vite": "^8.0.13",
     "vitest": "^4.1.6"
   },
   "overrides": {

setup/js/parse_mcp_gateway_log.cjs

@@ -4,7 +4,7 @@
 const fs = require("fs");
 const { getErrorMessage } = require("./error_helpers.cjs");
 const { displayDirectories } = require("./display_file_helpers.cjs");
-const { ERR_PARSE } = require("./error_codes.cjs");
+const { ERR_PARSE, ERR_SYSTEM } = require("./error_codes.cjs");
 const { computeEffectiveTokens, getTokenClassWeights, formatET } = require("./effective_tokens.cjs");
 
 /**
@@ -711,6 +711,10 @@ async function main() {
     } else if (fs.existsSync(rpcMessagesPath)) {
       rpcMessagesContent = fs.readFileSync(rpcMessagesPath, "utf8");
       core.info(`Found rpc-messages.jsonl (${rpcMessagesContent.length} bytes)`);
+      if (rpcMessagesContent.length === 0) {
+        core.setFailed(`${ERR_SYSTEM}: rpc-messages.jsonl is present but zero bytes — MCP telemetry capture failed (server may not have started or crashed before any RPC)`);
+        return;
+      }
       difcFilteredEvents = parseGatewayJsonlForDifcFiltered(rpcMessagesContent);
       tokenSteeringEvents = parseGatewayJsonlForTokenSteering(rpcMessagesContent);
       effectiveTokensRateLimitError ||= hasEffectiveTokensRateLimitError([rpcMessagesContent]);

setup/js/pr_review_buffer.cjs

@@ -235,8 +235,12 @@ function createReviewBuffer() {
     }
 
     if (!reviewContext) {
-      core.warning("No review context set - cannot submit review");
-      return { success: false, error: "No review context available" };
+      core.info("No review context set - skipping PR review submission");
+      return {
+        success: true,
+        skipped: true,
+        reason: "No review context available",
+      };
     }
 
     const { repo, repoParts, pullRequestNumber, pullRequest } = reviewContext;

setup/js/route_slash_command.cjs

@@ -2,6 +2,7 @@
 /// <reference types="@actions/github-script" />
 
 const { REACTION_MAP } = require("./add_reaction.cjs");
+const { extractWorkflowId } = require("./generate_footer.cjs");
 // Keep this aligned with the current default stable GitHub REST API version used by workflows.
 // Update when GitHub advances the recommended version to avoid sunset/deprecation warnings.
 const GITHUB_API_VERSION = "2022-11-28";
@@ -19,12 +20,25 @@ function resolveBodyText() {
     pull_request: context.payload?.pull_request?.body ?? "",
     issue_comment: context.payload?.comment?.body ?? "",
     pull_request_review_comment: context.payload?.comment?.body ?? "",
+    pull_request_review: context.payload?.review?.body ?? "",
     discussion: context.payload?.discussion?.body ?? "",
     discussion_comment: context.payload?.comment?.body ?? "",
   };
   return bodyByEvent[context.eventName] ?? "";
 }
 
+function isPRClosedAtStart() {
+  const pullRequestState = context.payload?.pull_request?.state;
+  if (pullRequestState === "closed") {
+    return true;
+  }
+  const issueState = context.payload?.issue?.state;
+  if (context.payload?.issue?.pull_request && issueState === "closed") {
+    return true;
+  }
+  return false;
+}
+
 function resolveDispatchRef() {
   if (process.env.GITHUB_HEAD_REF) {
     return `refs/heads/${process.env.GITHUB_HEAD_REF}`;
@@ -194,10 +208,8 @@ async function dispatchWorkflow(workflowId, ref, inputs) {
       workflow_id: workflowId,
       ref,
       inputs,
-      request: {
-        headers: {
-          "X-GitHub-Api-Version": GITHUB_API_VERSION,
-        },
+      headers: {
+        "X-GitHub-Api-Version": GITHUB_API_VERSION,
       },
     });
   } catch (error) {
@@ -211,12 +223,18 @@ async function main() {
 
   const slashRouteMap = JSON.parse(process.env.GH_AW_SLASH_ROUTING || "{}");
   const labelRouteMap = JSON.parse(process.env.GH_AW_LABEL_ROUTING || "{}");
+  const reviewerRoutes = JSON.parse(process.env.GH_AW_REVIEWER_ROUTING || "[]");
   core.info(`Configured centralized slash commands: ${Object.keys(slashRouteMap).length}.`);
   core.info(`Configured decentralized label commands: ${Object.keys(labelRouteMap).length}.`);
+  core.info(`Configured pull-request reviewer workflows: ${Array.isArray(reviewerRoutes) ? reviewerRoutes.length : 0}.`);
 
   const identifier = eventIdentifier();
   const { buildAwContext } = require("./aw_context.cjs");
   const ref = resolveDispatchRef();
+  if (isPRClosedAtStart()) {
+    core.info("Pull request is closed at workflow start; skipping centralized routing.");
+    return;
+  }
 
   if (context.payload?.action === "labeled") {
     const labelName = context.payload?.label?.name ?? "";
@@ -254,6 +272,46 @@ async function main() {
     return;
   }
 
+  if ((context.eventName === "pull_request" || context.eventName === "pull_request_review") && Array.isArray(reviewerRoutes) && reviewerRoutes.length > 0) {
+    const matches = reviewerRoutes.filter(route => Array.isArray(route.events) && route.events.includes(context.eventName));
+    if (matches.length > 0) {
+      let selected = matches;
+      if (context.eventName === "pull_request") {
+        if (!["ready_for_review", "review_requested"].includes(context.payload?.action ?? "")) {
+          selected = [];
+        }
+      } else if (context.eventName === "pull_request_review") {
+        const action = context.payload?.action ?? "";
+        if (action !== "submitted") {
+          selected = [];
+        } else {
+          const workflowId = extractWorkflowId(context.payload?.review?.body ?? "");
+          if (workflowId) {
+            selected = selected.filter(route => route.workflow === workflowId);
+          } else {
+            selected = [];
+            core.info("No workflow marker found in pull request review body; skipping reviewer dispatch.");
+          }
+        }
+      }
+      if (selected.length > 0) {
+        core.info(`Matched reviewer routes on '${context.eventName}': ${selected.map(route => route.workflow).join(", ")}.`);
+        for (const route of selected) {
+          const awContext = {
+            ...buildAwContext(),
+            command_name: "",
+            reviewer_lifecycle_event: context.eventName,
+          };
+          core.info(`Dispatching reviewer workflow '${route.workflow}.lock.yml'.`);
+          await dispatchWorkflow(`${route.workflow}.lock.yml`, ref, {
+            aw_context: JSON.stringify(awContext),
+          });
+        }
+        core.info("Completed reviewer lifecycle routing.");
+      }
+    }
+  }
+
   const text = resolveBodyText();
   core.info(`Resolved payload text length: ${String(text).length}.`);
   const firstWord = String(text).trim().split(/\s+/)[0] ?? "";