fix(agent): bound structured close reasons (#3213)

* fix(agent): bound structured close reasons

* fix(agent): surface closeReasons truncation on the real executor audit path

The executor's closeReasonsForAudit() pre-bounded the reason count
before buildAgentActionAudit() ever saw it, so closeReasonsTruncated
could never be set on a real close action -- only on a direct
buildAgentActionAudit() call with an unbounded array. Count-bounding
now happens exactly once, inside buildAgentActionAudit, so the
persisted audit row's closeReasonCount/closeReasonsTruncated reflect
the true original count regardless of caller. Also removes a
resulting dead ?? fallback that TypeScript's own narrowing already
made unreachable.

* fix(agent): bound close-reason count before per-reason string truncation

The prior fix restored truncation visibility but reintroduced the
original cost problem: closeReasonsForAudit mapped every reason
through boundAuditReason before any count cap ran, so an unbounded
closeReasons array still cost O(N) string-length work on the hot
executor path. Bound the count first (a cheap slice), map only the
bounded subset, and carry the true original count to
buildAgentActionAudit separately (as closeReasonCount) so the
persisted audit row still correctly flags truncation.

Author: JSONbored

src/services/agent-action-executor.ts

@@ -23,7 +23,7 @@ import { ensurePullRequestLabel, removePullRequestLabel } from "../github/labels
 import { closeIssue, closePullRequest, createIssueComment, createPullRequestReview, dismissLatestBotApproval, mergePullRequest, updatePullRequestBranch } from "../github/pr-actions";
 import { fetchPullRequestFreshness, pullRequestFreshnessDetail } from "../github/pr-freshness";
 import { isActingAutonomyLevel, resolveAutonomy } from "../settings/autonomy";
-import { buildAgentActionAudit, formatAgentPermissionDenial, isGlobalAgentPause, resolveAgentActionMode, resolveAgentPermissionReadiness, type AgentActionMode } from "../settings/agent-execution";
+import { boundStructuredCloseReasonsForPersistence, buildAgentActionAudit, formatAgentPermissionDenial, isGlobalAgentPause, resolveAgentActionMode, resolveAgentPermissionReadiness, type AgentActionMode } from "../settings/agent-execution";
 import type { PlannedAgentAction } from "../settings/agent-actions";
 import type { AgentActionClass, AgentPendingActionParams, AutonomyLevel, AutonomyPolicy } from "../types";
 import { errorMessage } from "../utils/json";
@@ -50,10 +50,18 @@ function boundAuditReason(detail: string): string {
   return detail.length > AUDIT_REASON_MAX_LENGTH ? `${detail.slice(0, AUDIT_REASON_MAX_LENGTH)}…` : detail;
 }
 
-function closeReasonsForAudit(action: PlannedAgentAction): string[] | undefined {
+function closeReasonsForAudit(action: PlannedAgentAction): { closeReasons: string[]; closeReasonCount: number } | undefined {
   if (action.actionClass !== "close") return undefined;
   const rawReasons = action.closeReasons?.length ? action.closeReasons : [action.reason];
-  return rawReasons.map((reason) => boundAuditReason(reason));
+  // Bound the COUNT first (a cheap slice) so the per-reason string truncation below only ever runs over the
+  // persisted subset, never a potentially unbounded array -- the ORIGINAL count is carried separately as
+  // closeReasonCount so buildAgentActionAudit can still flag truncation correctly even though closeReasons
+  // itself is already bounded by the time it gets there (#3213 review: an unbounded .map(boundAuditReason)
+  // here could exhaust Worker CPU/memory before any cap ran).
+  return {
+    closeReasons: boundStructuredCloseReasonsForPersistence(rawReasons).map((reason) => boundAuditReason(reason)),
+    closeReasonCount: rawReasons.length,
+  };
 }
 
 // The PR-visible action classes that require an elevated GitHub App write permission. Most use
@@ -238,7 +246,7 @@ export async function executeAgentMaintenanceActions(env: Env, ctx: AgentActionE
       outcomes.push({ actionClass: action.actionClass, outcome, detail: boundedDetail });
       return recordAuditEvent(
         env,
-        buildAgentActionAudit({ actionClass: action.actionClass, autonomyLevel, mode, outcome: auditOutcome, repoFullName: ctx.repoFullName, targetKey, actor: AGENT_ACTOR, reason: boundedDetail, closeReasons: closeReasonsForAudit(action) }),
+        buildAgentActionAudit({ actionClass: action.actionClass, autonomyLevel, mode, outcome: auditOutcome, repoFullName: ctx.repoFullName, targetKey, actor: AGENT_ACTOR, reason: boundedDetail, ...closeReasonsForAudit(action) }),
       );
     };
 
@@ -583,7 +591,7 @@ export async function executeIssueMaintenanceActions(env: Env, ctx: IssueActionE
       outcomes.push({ actionClass: action.actionClass, outcome, detail: boundedDetail });
       return recordAuditEvent(
         env,
-        buildAgentActionAudit({ actionClass: action.actionClass, autonomyLevel, mode, outcome: auditOutcome, repoFullName: ctx.repoFullName, targetKey, actor: AGENT_ACTOR, reason: boundedDetail, closeReasons: closeReasonsForAudit(action) }),
+        buildAgentActionAudit({ actionClass: action.actionClass, autonomyLevel, mode, outcome: auditOutcome, repoFullName: ctx.repoFullName, targetKey, actor: AGENT_ACTOR, reason: boundedDetail, ...closeReasonsForAudit(action) }),
       );
     };
 
@@ -747,7 +755,7 @@ export function actionParams(action: PlannedAgentAction): AgentPendingActionPara
     ...(action.reviewBody !== undefined ? { reviewBody: action.reviewBody } : {}),
     ...(action.mergeMethod !== undefined ? { mergeMethod: action.mergeMethod } : {}),
     ...(action.closeComment !== undefined ? { closeComment: action.closeComment } : {}),
-    ...(action.closeReasons !== undefined ? { closeReasons: action.closeReasons } : {}),
+    ...(action.closeReasons !== undefined ? { closeReasons: [...boundStructuredCloseReasonsForPersistence(action.closeReasons)] } : {}),
     ...(action.expectedHeadSha !== undefined ? { expectedHeadSha: action.expectedHeadSha } : {}),
     ...(action.dismissStaleApproval !== undefined ? { dismissStaleApproval: action.dismissStaleApproval } : {}),
     // Round-trip closeKind so a staged close's kind survives to accept-time — without it, the close-precision

src/settings/agent-execution.ts

@@ -11,6 +11,12 @@ import { isActingAutonomyLevel, resolveAutonomy } from "./autonomy";
 const PR_WRITE_ACTION_CLASSES: readonly AgentActionClass[] = ["review", "request_changes", "approve", "close", "update_branch"];
 const CONTENTS_WRITE_ACTION_CLASSES: readonly AgentActionClass[] = ["merge"];
 
+export const STRUCTURED_CLOSE_REASONS_MAX_COUNT = 20;
+
+export function boundStructuredCloseReasonsForPersistence<T>(closeReasons: readonly T[]): readonly T[] {
+  return closeReasons.length > STRUCTURED_CLOSE_REASONS_MAX_COUNT ? closeReasons.slice(0, STRUCTURED_CLOSE_REASONS_MAX_COUNT) : closeReasons;
+}
+
 export type AgentPermissionRequirement = { permission: string; requiredAccess: "write" };
 
 // Whether the agent actually executes an action, only logs what it WOULD do, or is halted entirely (#776).
@@ -56,8 +62,14 @@ export function buildAgentActionAudit(input: {
   actor?: string | null | undefined;
   reason?: string | null | undefined;
   closeReasons?: readonly string[] | null | undefined;
+  // The TRUE original count, when the caller has ALREADY bounded `closeReasons` itself for cost reasons
+  // (closeReasonsForAudit bounds the count before per-reason string truncation to avoid unbounded work on the
+  // hot path, #3213 review) -- falls back to closeReasons.length for a caller that passes the full array.
+  closeReasonCount?: number | undefined;
 }): AuditEventRecord {
-  const closeReasons = input.actionClass === "close" && input.closeReasons?.length ? [...input.closeReasons] : null;
+  const closeReasonCount = input.actionClass === "close" ? (input.closeReasonCount ?? input.closeReasons?.length ?? 0) : 0;
+  const closeReasons =
+    input.actionClass === "close" && input.closeReasons?.length ? [...boundStructuredCloseReasonsForPersistence(input.closeReasons)] : null;
   return {
     eventType: `agent.action.${input.actionClass}`,
     actor: input.actor ?? null,
@@ -69,7 +81,7 @@ export function buildAgentActionAudit(input: {
       actionClass: input.actionClass,
       autonomyLevel: input.autonomyLevel,
       mode: input.mode,
-      ...(closeReasons ? { closeReasons, closeReasonCount: closeReasons.length } : {}),
+      ...(closeReasons ? { closeReasons, closeReasonCount, ...(closeReasonCount > closeReasons.length ? { closeReasonsTruncated: true } : {}) } : {}),
     },
   };
 }

test/unit/agent-action-executor.test.ts

@@ -59,6 +59,7 @@ import {
   type IssueActionExecutionContext,
 } from "../../src/services/agent-action-executor";
 import type { PlannedAgentAction } from "../../src/settings/agent-actions";
+import { STRUCTURED_CLOSE_REASONS_MAX_COUNT } from "../../src/settings/agent-execution";
 import { AGENT_LABEL_PENDING_CLOSURE } from "../../src/review/linked-issue-hard-rules";
 import { clearProcessLocalGlobalAgentFrozenCacheForTest, getGlobalContributorBlacklist, isGlobalAgentFrozen, setGlobalAgentFrozen, upsertGlobalModerationConfig, upsertPullRequestFromGitHub } from "../../src/db/repositories";
 import * as repositoriesModule from "../../src/db/repositories";
@@ -136,6 +137,13 @@ describe("executeAgentMaintenanceActions (#778 gate stack)", () => {
     expect(replayed).toMatchObject({ actionClass: "close", requiresApproval: false, reason: "CI failed; blocker", closeComment: "closing", closeReasons: ["CI failed", "blocker"] });
   });
 
+  it("bounds structured closeReasons in approval-queue params", () => {
+    const closeReasons = Array.from({ length: STRUCTURED_CLOSE_REASONS_MAX_COUNT + 1 }, (_, index) => `blocker ${index}`);
+    const persisted = actionParams({ actionClass: "close", requiresApproval: true, reason: closeReasons.join("; "), closeComment: "closing", closeReasons });
+
+    expect(persisted.closeReasons).toEqual(closeReasons.slice(0, STRUCTURED_CLOSE_REASONS_MAX_COUNT));
+  });
+
   it("LIVE: executes each action class via its GitHub primitive and audits completed", async () => {
     const env = createTestEnv({});
     const outcomes = await executeAgentMaintenanceActions(env, ctx(), [label, requestChanges, approve, merge, close, updateBranch]);
@@ -223,6 +231,20 @@ describe("executeAgentMaintenanceActions (#778 gate stack)", () => {
     expect(metadata.closeReasons[1].length).toBeLessThan(longReason.length);
   });
 
+  it("bounds structured closeReasons count before storing audit metadata, and flags the real close-action audit row as truncated", async () => {
+    const env = createTestEnv({});
+    const closeReasons = Array.from({ length: STRUCTURED_CLOSE_REASONS_MAX_COUNT + 1 }, (_, index) => `blocker ${index}`);
+    const outcomes = await executeAgentMaintenanceActions(env, ctx(), [{ actionClass: "close", requiresApproval: false, reason: closeReasons.join("; "), closeComment: "closing", closeReasons }]);
+    expect(outcomes[0]?.outcome).toBe("completed");
+
+    const audit = await auditFor(env, "close");
+    const metadata = JSON.parse(audit?.metadata_json ?? "{}");
+    expect(metadata.closeReasons).toEqual(closeReasons.slice(0, STRUCTURED_CLOSE_REASONS_MAX_COUNT));
+    // The REAL count (before bounding), so an over-limit close is distinguishable from an exactly-at-limit one.
+    expect(metadata.closeReasonCount).toBe(STRUCTURED_CLOSE_REASONS_MAX_COUNT + 1);
+    expect(metadata.closeReasonsTruncated).toBe(true);
+  });
+
   it("#label-scoping: a label action's autonomyClass (not the literal actionClass) governs the durable re-check", async () => {
     const env = createTestEnv({});
     // autonomy.label is OFF; autonomy.close is ON — a label authorized via autonomyClass: "close" must still

test/unit/agent-execution.test.ts

@@ -4,6 +4,7 @@ import {
   agentRequiresContentsWrite,
   agentRequiresPrWrite,
   buildAgentActionAudit,
+  STRUCTURED_CLOSE_REASONS_MAX_COUNT,
   formatAgentPermissionDenial,
   isGlobalAgentPause,
   requiredAgentActionPermissions,
@@ -119,6 +120,22 @@ describe("buildAgentActionAudit", () => {
       closeReasons: [],
     });
     expect(emptyCloseAudit.metadata).not.toHaveProperty("closeReasons");
+
+    const manyCloseReasons = Array.from({ length: STRUCTURED_CLOSE_REASONS_MAX_COUNT + 1 }, (_, index) => `blocker ${index}`);
+    const truncatedCloseAudit = buildAgentActionAudit({
+      actionClass: "close",
+      autonomyLevel: "auto",
+      mode: "live",
+      outcome: "completed",
+      repoFullName: "owner/repo",
+      reason: "many blockers",
+      closeReasons: manyCloseReasons,
+    });
+    expect(truncatedCloseAudit.metadata).toMatchObject({
+      closeReasons: manyCloseReasons.slice(0, STRUCTURED_CLOSE_REASONS_MAX_COUNT),
+      closeReasonCount: manyCloseReasons.length,
+      closeReasonsTruncated: true,
+    });
   });
 });