pr-shepherd 0.56.6 → 0.57.1

package/bin/api.d.mts

@@ -1,3 +1,9 @@
+import { type GithubTransport } from "./github/transport.mts";
+export type { GithubTransport } from "./github/transport.mts";
+import { type ApplyMergeResult } from "./commands/apply-merge.mts";
+import type { RestMergeAction, RestMergeStackGuard } from "./github/rest-merge.mts";
+export type { RestMergeStackGuard } from "./github/rest-merge.mts";
+import type { MergeMethod } from "./config/merge-method.mts";
 import { type JournalResult } from "./commands/journal/index.mts";
 import { type MarkFilesAsViewedResult } from "./commands/mark-files-as-viewed.mts";
 import { type ApplyQueueRemovalResult } from "./commands/apply-queue-removal.mts";
@@ -5,12 +11,14 @@ import type { ResolveResult } from "./comments/resolve.mts";
 import type { BuildSuggestionPatchesResult, CommitSuggestionResult, IterateCommandOptions, IterateResult, PollSummaryResult } from "./types.mts";
 import { type ShepherdJournalExtraction } from "./journal/index.mts";
 export interface CreatePrShepherdOptions {
+    /** GitHub transport retained for this client; individual calls may override it. */
+    transport?: GithubTransport;
     /** Working directory used for git, config, and classification-rule lookups. */
     cwd?: string;
 }
 /** A positive PR number, GitHub pull-request URL, or owner/repo#number reference. */
 export type PrReference = number | string;
-type IterateOptions = Omit<IterateCommandOptions, "format" | "prNumber" | "targetRepository" | "persistSeen" | "fingerprintCache" | "deferQuotaWarning" | "quotaWarningMinimumPollIntervalMinutes">;
+type IterateOptions = Omit<IterateCommandOptions, "format" | "prNumber" | "targetRepository" | "persistSeen" | "fingerprintCache" | "stallDeadlineSink" | "deferQuotaWarning" | "quotaWarningMinimumPollIntervalMinutes">;
 export type SingleIterateInput = IterateOptions & {
     pr?: PrReference;
     prs?: never;
@@ -34,6 +42,7 @@ export interface ReviewMutationsOperation {
     dismissReviewIds?: string[];
     /** Required when replying to a thread or dismissing a review. */
     message?: string;
+    /** `HEAD` (this checkout's commit) or a full SHA the PR head must match before mutating. */
     requireSha?: string;
 }
 export interface MarkFilesViewedOperation {
@@ -54,14 +63,25 @@ export interface AcknowledgeQueueRemovalOperation {
     queueCommitOid: string;
     removedAtUnix: number;
 }
+export interface MergeOperation {
+    type: "merge";
+    requireSha: string;
+    mergeAction: RestMergeAction;
+    mergeMethod?: MergeMethod;
+    expectedStack?: RestMergeStackGuard;
+}
 /** Operations run in this exact list order after validation. */
-export type ApplyOperation = ReviewMutationsOperation | MarkFilesViewedOperation | AppendJournalOperation | AcknowledgeQueueRemovalOperation;
+export type ApplyOperation = MergeOperation | ReviewMutationsOperation | MarkFilesViewedOperation | AppendJournalOperation | AcknowledgeQueueRemovalOperation;
 export interface ApplyInput {
+    transport?: GithubTransport;
     /** PR shared by every operation in this ordered apply request. */
     pr?: PrReference;
     operations: ApplyOperation[];
 }
 export type ApplyOperationResult = {
+    type: "merge";
+    result: ApplyMergeResult;
+} | {
     type: "review_mutations";
     result: ResolveResult;
 } | {
@@ -78,6 +98,7 @@ export interface ApplyResult {
     operations: ApplyOperationResult[];
 }
 export interface BuildSuggestionPatchInput {
+    transport?: GithubTransport;
     pr?: PrReference;
     threadId: string;
     message: string;
@@ -89,10 +110,12 @@ export interface SuggestionPatchInput {
     description?: string;
 }
 export interface BuildSuggestionPatchesInput {
+    transport?: GithubTransport;
     pr?: PrReference;
     suggestions: SuggestionPatchInput[];
 }
 export interface GetJournalInput {
+    transport?: GithubTransport;
     pr: PrReference;
 }
 export interface PrShepherd {
@@ -120,4 +143,3 @@ export declare class PartialApplyError extends Error {
  * read/plan, ordered apply, and suggestion-patch operations.
  */
 export declare function createPrShepherd(options?: CreatePrShepherdOptions): PrShepherd;
-export {};

package/bin/api.mjs

@@ -1,9 +1,10 @@
 /* eslint-disable max-lines */
 import { resolve } from "node:path";
+import { createGithubTransportRunner } from "./github/transport.mjs";
+import { runApplyMerge, validateApplyMergeOptions, } from "./commands/apply-merge.mjs";
 import { runCommitSuggestion } from "./commands/commit-suggestion.mjs";
 import { runSuggestionPatches } from "./commands/suggestion-patches.mjs";
-import { runIterate } from "./commands/iterate/index.mjs";
-import { runPollSummary } from "./commands/poll-summary.mjs";
+import { runIterateForMode, runPollSummaryForMode } from "./commands/event-mode.mjs";
 import { runJournal } from "./commands/journal/index.mjs";
 import { validateJournalItem } from "./commands/journal/transform.mjs";
 import { runMarkFilesAsViewed, } from "./commands/mark-files-as-viewed.mjs";
@@ -12,6 +13,7 @@ import { applyQueueRemovalAck, } from "./commands/apply-queue-removal.mjs";
 import { runWithExecutionCwd } from "./execution-context.mjs";
 import { parsePrReference, normalizeRepositoryIdentity, resolveParsedPrTarget, } from "./pr-reference.mjs";
 import { getPullRequestBody, getRepoInfo } from "./github/client.mjs";
+import { getLocalHeadSha } from "./commands/suggestion-patch-git.mjs";
 import { extractShepherdJournal } from "./journal/index.mjs";
 /** Raised before any API mutation when an input cannot be validated. */
 export class PrShepherdValidationError extends Error {
@@ -38,22 +40,26 @@ export class PartialApplyError extends Error {
  */
 export function createPrShepherd(options = {}) {
     const cwd = options.cwd === undefined ? undefined : resolve(options.cwd);
+    const transportRunner = createGithubTransportRunner(options.transport);
+    function runInClient(input, work) {
+        return runWithExecutionCwd(cwd, () => transportRunner(work, input?.transport));
+    }
     function iterate(input = {}) {
-        return runWithExecutionCwd(cwd, async () => {
+        return runInClient(input, async () => {
             validateIterateSelectors(input);
             if ("prs" in input || "stack" in input) {
                 const target = await resolveAggregateIterateInput(input);
-                return runPollSummary(target);
+                return runPollSummaryForMode(target);
             }
             const { pr: _pr, ...iterateOptions } = input;
             const target = resolvePrReference(input.pr);
-            return runIterate({ ...iterateOptions, ...target, format: "json" });
+            return runIterateForMode({ ...iterateOptions, ...target, format: "json" });
         });
     }
     return Object.freeze({
         iterate,
         getJournal(input) {
-            return runWithExecutionCwd(cwd, async () => {
+            return runInClient(input, async () => {
                 const { prNumber, targetRepository } = resolvePrReference(input.pr);
                 if (!prNumber)
                     throw new PrShepherdValidationError("getJournal requires a PR reference");
@@ -63,7 +69,7 @@ export function createPrShepherd(options = {}) {
             });
         },
         apply(input) {
-            return runWithExecutionCwd(cwd, async () => {
+            return runInClient(input, async () => {
                 validateApplyInput(input);
                 const { prNumber, targetRepository } = resolvePrReference(input.pr);
                 const results = [];
@@ -71,16 +77,32 @@ export function createPrShepherd(options = {}) {
                     const operation = input.operations[index];
                     try {
                         switch (operation.type) {
+                            case "merge": {
+                                const result = await runApplyMerge({
+                                    prNumber,
+                                    targetRepository,
+                                    requireSha: operation.requireSha,
+                                    mergeAction: operation.mergeAction,
+                                    mergeMethod: operation.mergeMethod,
+                                    expectedStack: operation.expectedStack,
+                                });
+                                results.push({ type: operation.type, result });
+                                break;
+                            }
                             case "review_mutations": {
                                 const { type: _type, message, ...options } = operation;
                                 const result = await runResolveMutate({
                                     ...options,
+                                    // `HEAD` names this checkout's commit, the same form the printed CLI command uses.
+                                    requireSha: options.requireSha === "HEAD" ? await getLocalHeadSha() : options.requireSha,
                                     prNumber,
                                     targetRepository,
                                     dismissMessage: message,
                                     format: "json",
                                 });
                                 results.push({ type: operation.type, result });
+                                if (result.sessionRefusal)
+                                    return { operations: results };
                                 break;
                             }
                             case "mark_files_viewed": {
@@ -130,7 +152,7 @@ export function createPrShepherd(options = {}) {
         buildSuggestionPatch(input) {
             validateSuggestionPatchInput(input);
             const { pr: _pr, ...options } = input;
-            return runWithExecutionCwd(cwd, async () => {
+            return runInClient(input, async () => {
                 const target = resolvePrReference(input.pr);
                 return runCommitSuggestion({ ...options, ...target, format: "json" });
             });
@@ -138,7 +160,7 @@ export function createPrShepherd(options = {}) {
         buildSuggestionPatches(input) {
             validateSuggestionPatchesInput(input);
             const { pr: _pr, ...options } = input;
-            return runWithExecutionCwd(cwd, async () => {
+            return runInClient(input, async () => {
                 const target = resolvePrReference(input.pr);
                 return runSuggestionPatches({ ...options, ...target, format: "json" });
             });
@@ -190,15 +212,29 @@ function validateApplyInput(input) {
     if (!input || !Array.isArray(input.operations) || input.operations.length === 0) {
         throw new PrShepherdValidationError("apply requires a non-empty operations array");
     }
-    for (const operation of input.operations)
+    const parsed = validatePrReference(input.pr);
+    for (const operation of input.operations) {
         validateOperation(operation);
-    validatePrReference(input.pr);
+        if (operation.type === "merge" &&
+            operation.expectedStack !== undefined &&
+            parsed.number !== undefined &&
+            operation.expectedStack.prefix.at(-1)?.pr !== parsed.number)
+            throw new PrShepherdValidationError("expectedStack prefix must end at the requested PR");
+    }
 }
 function validateOperation(operation) {
     if (!operation || typeof operation !== "object") {
         throw new PrShepherdValidationError("apply operation must be an object");
     }
     switch (operation.type) {
+        case "merge":
+            try {
+                validateApplyMergeOptions(operation);
+            }
+            catch (error) {
+                throw new PrShepherdValidationError(error instanceof Error ? error.message : String(error));
+            }
+            return;
         case "review_mutations":
             validateReviewMutations(operation);
             return;
@@ -254,8 +290,10 @@ function validateReviewMutations(operation) {
     if (operation.message !== undefined && typeof operation.message !== "string") {
         throw new PrShepherdValidationError("review_mutations.message must be a string");
     }
-    if (operation.requireSha !== undefined && !/^[0-9a-f]{40}$/.test(operation.requireSha)) {
-        throw new PrShepherdValidationError("review_mutations.requireSha must be a full 40-character lowercase hex SHA");
+    if (operation.requireSha !== undefined &&
+        operation.requireSha !== "HEAD" &&
+        !/^[0-9a-f]{40}$/.test(operation.requireSha)) {
+        throw new PrShepherdValidationError("review_mutations.requireSha must be HEAD or a full 40-character lowercase hex SHA");
     }
 }
 function validateMarkFilesViewed(operation) {

package/bin/checks/classify.d.mts

@@ -21,6 +21,7 @@ import type { CheckRun, ClassifiedCheck } from "../types.mts";
  */
 export declare function classifyChecks(checks: CheckRun[], opts?: {
     additionalRelevantEvents?: string[];
+    requiredContexts?: readonly string[];
 }): ClassifiedCheck[];
 export interface CiVerdict {
     /** True when all relevant (non-filtered, non-skipped, non-ignored) checks passed. */

package/bin/checks/classify.mjs

@@ -30,7 +30,7 @@ export function classifyChecks(checks, opts = {}) {
     const isIgnored = buildMatcher(config.ignoreChecks ?? []);
     const isProtected = buildMatcher(config.actions.neverCancelRuns ?? []);
     const protectedRunIds = buildProtectedRunIds(checks, isProtected);
-    const supersededIndices = buildSupersededIndices(checks);
+    const supersededIndices = buildSupersededIndices(checks, opts.requiredContexts);
     return checks.map((c, index) => {
         if (isIgnored(c.name) && !isProtectedCheck(c, protectedRunIds)) {
             return { ...c, category: "ignored" };

package/bin/checks/conclusions.d.mts

@@ -4,8 +4,12 @@ import type { CheckConclusion, ViewerAuthorization } from "../types.mts";
  * (`actions: write`, which rides with push access). The rerun runs against the base
  * repo where the run lives, so `repositoryPermission` — not `headRepositoryPermission`,
  * which covers fork push access — is the right field to gate on.
+ *
+ * REST exposes no viewer capability fields, so on a REST snapshot an unknown role does not deny
+ * the rerun: the recommended `gh run rerun` is attempted and GitHub's response decides. A role
+ * GitHub did report still gates the rerun.
  */
-export declare function canRerunWorkflows(auth: ViewerAuthorization | undefined): boolean;
+export declare function canRerunWorkflows(auth: ViewerAuthorization | undefined, transport?: "rest"): boolean;
 /** Failing-check rows for formatter/instructions — excludes annotation-only carriers. */
 export declare function isFailingAgentCheck(check: {
     conclusion: CheckConclusion;

package/bin/checks/conclusions.mjs

@@ -6,10 +6,16 @@ const RERUN_CAPABLE_PERMISSIONS = new Set(["WRITE", "MAINTAIN", "ADMIN"]);
  * (`actions: write`, which rides with push access). The rerun runs against the base
  * repo where the run lives, so `repositoryPermission` — not `headRepositoryPermission`,
  * which covers fork push access — is the right field to gate on.
+ *
+ * REST exposes no viewer capability fields, so on a REST snapshot an unknown role does not deny
+ * the rerun: the recommended `gh run rerun` is attempted and GitHub's response decides. A role
+ * GitHub did report still gates the rerun.
  */
-export function canRerunWorkflows(auth) {
+export function canRerunWorkflows(auth, transport) {
     const permission = auth?.repositoryPermission;
-    return permission != null && RERUN_CAPABLE_PERMISSIONS.has(permission);
+    if (permission === undefined)
+        return transport === "rest";
+    return permission !== null && RERUN_CAPABLE_PERMISSIONS.has(permission);
 }
 /** True for conclusions that belong under `## Failing checks` (not success/skipped/neutral). */
 function isFailingCheckConclusion(conclusion) {

package/bin/checks/superseded.d.mts

@@ -3,6 +3,12 @@ import type { CheckRun } from "../types.mts";
 /**
  * A later-created run supersedes an older cancellation as before. GitHub can start
  * check jobs out of run-ID order, so a lower-ID run can also cover a cancellation
- * when its matching successful job actually started and completed later.
+ * when its matching successful job actually started and completed later. Cancelled
+ * wrappers can report completion before start; compare both observed boundaries
+ * without treating that reversed interval as a successful execution.
+ *
+ * The lower-ID form never covers a required context: GitHub's required gate reads the
+ * latest (highest-ID) run, so that cancellation still fails it (github/gh-stack#466).
+ * Neither does a newer run that lacks the context, for the same reason.
  */
-export declare function buildSupersededIndices(checks: CheckRun[]): Set<number>;
+export declare function buildSupersededIndices(checks: CheckRun[], requiredContexts?: readonly string[]): Set<number>;

package/bin/checks/superseded.mjs

@@ -17,7 +17,7 @@ function numericRunId(check) {
     const id = Number(check.runId);
     return Number.isSafeInteger(id) ? id : undefined;
 }
-function validTimes(check) {
+function validTimes(check, requireOrdered = true) {
     const { startedAtUnix: start, completedAtUnix: completion } = check;
     return (typeof start === "number" &&
         Number.isFinite(start) &&
@@ -25,14 +25,21 @@ function validTimes(check) {
         typeof completion === "number" &&
         Number.isFinite(completion) &&
         completion > 0 &&
-        completion >= start);
+        (!requireOrdered || completion >= start));
 }
 /**
  * A later-created run supersedes an older cancellation as before. GitHub can start
  * check jobs out of run-ID order, so a lower-ID run can also cover a cancellation
- * when its matching successful job actually started and completed later.
+ * when its matching successful job actually started and completed later. Cancelled
+ * wrappers can report completion before start; compare both observed boundaries
+ * without treating that reversed interval as a successful execution.
+ *
+ * The lower-ID form never covers a required context: GitHub's required gate reads the
+ * latest (highest-ID) run, so that cancellation still fails it (github/gh-stack#466).
+ * Neither does a newer run that lacks the context, for the same reason.
  */
-export function buildSupersededIndices(checks) {
+export function buildSupersededIndices(checks, requiredContexts = []) {
+    const required = new Set(requiredContexts.map((context) => context.trim()));
     const maxRunIdByGroup = new Map();
     const runIds = checks.map(numericRunId);
     checks.forEach((check, index) => {
@@ -52,14 +59,18 @@ export function buildSupersededIndices(checks) {
         const runId = runIds[index];
         if (group === undefined || runId === undefined)
             return;
+        const isRequired = required.has(cancelled.name.trim());
         if (maxRunIdByGroup.get(group) > runId) {
-            superseded.add(index);
+            // A required context is covered only by a newer run of the same context.
+            if (!isRequired || hasNewerSameName(checks, runIds, cancelled, group, runId))
+                superseded.add(index);
             return;
         }
-        if (cancelled.status !== "COMPLETED" ||
+        if (isRequired ||
+            cancelled.status !== "COMPLETED" ||
             !cancelled.workflowId ||
             cancelled.event === null ||
-            !validTimes(cancelled))
+            !validTimes(cancelled, false))
             return;
         const covered = checks.some((success, candidateIndex) => {
             const candidateRunId = runIds[candidateIndex];
@@ -81,3 +92,9 @@ export function buildSupersededIndices(checks) {
     });
     return superseded;
 }
+function hasNewerSameName(checks, runIds, cancelled, group, runId) {
+    return checks.some((check, index) => runIds[index] !== undefined &&
+        runIds[index] > runId &&
+        check.name.trim() === cancelled.name.trim() &&
+        groupKeyOf(check) === group);
+}

package/bin/classify/loader.d.mts

@@ -6,5 +6,7 @@ export interface LoadedRule {
 }
 export declare function discoverRuleFiles(cwd: string): string[];
 export declare function loadRules(files: string[]): Promise<LoadedRule[]>;
+/** Local `.pr-shepherd/classification/` rules followed by the enabled bundled rules. */
+export declare function loadClassifyRules(cwd: string, standardRuleNames?: readonly string[]): Promise<LoadedRule[]>;
 /** Reset the rule cache — for use in tests. */
 export declare function _resetRuleCache(): void;

package/bin/classify/loader.mjs

@@ -10,6 +10,7 @@ import { readdirSync, statSync } from "node:fs";
 import { join, dirname, extname, basename } from "node:path";
 import { homedir } from "node:os";
 import { pathToFileURL } from "node:url";
+import { STANDARD_RULES } from "./standard/index.mjs";
 const CLASSIFICATION_DIR = ".pr-shepherd/classification";
 const VALID_EXTENSIONS = new Set([".ts", ".mts", ".mjs", ".js"]);
 export function discoverRuleFiles(cwd) {
@@ -60,6 +61,20 @@ export async function loadRules(files) {
     ruleCache.set(cacheKey, rules);
     return rules;
 }
+/** Bundled rules enabled by `classify.standard`, named `standard:<rule>`. */
+function standardRules(names) {
+    return names.flatMap((name) => {
+        const rule = STANDARD_RULES[name];
+        return rule === undefined
+            ? []
+            : [{ name: `standard:${name}`, file: `pr-shepherd:standard/${name}`, rule }];
+    });
+}
+/** Local `.pr-shepherd/classification/` rules followed by the enabled bundled rules. */
+export async function loadClassifyRules(cwd, standardRuleNames = []) {
+    const local = await loadRules(discoverRuleFiles(cwd));
+    return [...local, ...standardRules(standardRuleNames)];
+}
 /** Reset the rule cache — for use in tests. */
 export function _resetRuleCache() {
     ruleCache.clear();

package/bin/classify/standard/author.d.mts

@@ -0,0 +1,3 @@
+import type { ClassifyItem, ClassifyItemKind } from "../types.mts";
+/** True when GitHub reports a bot author whose normalized login is one of `logins`. */
+export declare function isBotItem(item: ClassifyItem, logins: readonly string[], kinds: readonly ClassifyItemKind[]): boolean;

package/bin/classify/standard/author.mjs

@@ -0,0 +1,10 @@
+/** Lowercased login without the REST `[bot]` suffix, so GraphQL and REST logins compare equal. */
+function normalizeLogin(login) {
+    return login.toLowerCase().replace(/\[bot\]$/, "");
+}
+/** True when GitHub reports a bot author whose normalized login is one of `logins`. */
+export function isBotItem(item, logins, kinds) {
+    return (item.authorType === "Bot" &&
+        kinds.includes(item.kind) &&
+        logins.includes(normalizeLogin(item.author)));
+}

package/bin/classify/standard/codecov-report.d.mts

@@ -0,0 +1,4 @@
+import type { ClassifyRule } from "../types.mts";
+/** Codecov's coverage report comment. Coverage gates still report through their status checks. */
+declare const rule: ClassifyRule;
+export default rule;

package/bin/classify/standard/codecov-report.mjs

@@ -0,0 +1,10 @@
+import { isBotItem } from "./author.mjs";
+/** Codecov's coverage report comment. Coverage gates still report through their status checks. */
+const rule = (item) => {
+    if (!isBotItem(item, ["codecov"], ["pr-comment"]))
+        return null;
+    if (!/^#{1,6}\s*\[?Codecov\b/i.test(item.body.trimStart()))
+        return null;
+    return { autoResolve: true, suppress: true, reason: "Codecov coverage report" };
+};
+export default rule;

package/bin/classify/standard/coderabbit-notices.d.mts

@@ -0,0 +1,8 @@
+import type { ClassifyRule } from "../types.mts";
+/**
+ * CodeRabbit progress, rate-limit, review-skipped and draft notices, plus its "Action not
+ * completed" command replies. The summarize comment is later edited in place into the PR
+ * walkthrough, so the rule only hides it from agent output and never minimizes it.
+ */
+declare const rule: ClassifyRule;
+export default rule;

package/bin/classify/standard/coderabbit-notices.mjs

@@ -0,0 +1,38 @@
+import { isBotItem } from "./author.mjs";
+const NOTICE_ENVELOPE = /^<!-- This is an auto-generated comment: (rate limited|skip review|review in progress) by coderabbit.ai -->\n([\s\S]*?)\n<!-- end of auto-generated comment: \1 by coderabbit.ai -->$/;
+const COMMAND_REPLY = /^<!-- This is an auto-generated reply by CodeRabbit -->\n<!-- CodeRabbit review command invocation: v2:[a-f0-9]+ -->\n<details>\n<summary>⚠️ Action not completed<\/summary>\n\n(?:Review rate limited\.|Review skipped: \d+ files exceed the limit of \d+\.)\n\n(?:> Note: CodeRabbit is an incremental review system and does not re-review already reviewed commits\. This command is applicable only when automatic reviews are paused\.|---\n\nYour included review limit is currently reached under our \[Fair Usage Limits Policy\]\(https:\/\/docs.coderabbit.ai\/management\/plans#fair-usage-limits-policy\)\. This review may still proceed through usage-based billing if eligible\. Your next included review will be available in \d+ minutes?\.)\n\n<\/details>$/;
+/** Strips CodeRabbit's footer and header blocks so only the notice envelope remains. */
+function stripChrome(body) {
+    return body
+        .trim()
+        .replace(/\n<!-- tips_start -->[\s\S]*?<!-- tips_end -->$/, "")
+        .trim()
+        .replace(/\n<!-- autopilot:start -->[\s\S]*?<!-- autopilot:end -->$/, "")
+        .trim()
+        .replace(/^<!-- This is an auto-generated comment: summarize by coderabbit.ai -->\s*/, "")
+        .replace(/^<!-- review_stack_entry_start -->[\s\S]*?<!-- review_stack_entry_end -->\s*/, "");
+}
+function isQuotedNotice(quoted) {
+    const onlyQuotedLines = quoted.split("\n").every((line) => !line.trim() || line.startsWith(">"));
+    if (!onlyQuotedLines)
+        return false;
+    return (quoted.includes("> ## Review limit reached\n") ||
+        quoted.includes("> ## Draft PR not reviewed\n") ||
+        quoted.includes("> ## Review skipped\n") ||
+        quoted.includes("> Currently processing new changes in this PR. This may take a few minutes, please wait..."));
+}
+/**
+ * CodeRabbit progress, rate-limit, review-skipped and draft notices, plus its "Action not
+ * completed" command replies. The summarize comment is later edited in place into the PR
+ * walkthrough, so the rule only hides it from agent output and never minimizes it.
+ */
+const rule = (item) => {
+    if (!isBotItem(item, ["coderabbitai"], ["pr-comment"]))
+        return null;
+    const body = stripChrome(item.body);
+    const quoted = body.match(NOTICE_ENVELOPE)?.[2]?.trim();
+    if (!(quoted && isQuotedNotice(quoted)) && !COMMAND_REPLY.test(body))
+        return null;
+    return { suppress: true, reason: "CodeRabbit progress, review-limit, or skipped-review notice" };
+};
+export default rule;

package/bin/classify/standard/codex-notices.d.mts

@@ -0,0 +1,8 @@
+import type { ClassifyRule } from "../types.mts";
+/**
+ * Codex quota notices, the review-activity status table, and no-findings notices on conversation
+ * comments. Each pattern matches the whole comment, so a notice with any appended finding stays
+ * visible. Review summaries and inline comments are left for the normal review path.
+ */
+declare const rule: ClassifyRule;
+export default rule;

package/bin/classify/standard/codex-notices.mjs

@@ -0,0 +1,34 @@
+import { isBotItem } from "./author.mjs";
+const QUOTA_NOTICES = [
+    /^You have reached your Codex usage limits for security reviews\. Please try again later\.$/,
+    /^You have reached your Codex usage limits for code reviews\. You can see your limits in the \[Codex usage dashboard\]\(https:\/\/chatgpt.com\/codex\/cloud\/settings\/usage\)\.(?:\nTo continue using code reviews, add credits to your account and enable them for code reviews in your \[settings\]\(https:\/\/chatgpt.com\/codex\/cloud\/settings\/code-review\)\.)?$/,
+    /^Codex usage limits have been reached for code reviews\. Please check with the admins of this repo to increase the limits by adding credits\.\nRepo admins can enable using credits for code reviews in their \[settings\]\(https:\/\/chatgpt.com\/codex\/cloud\/settings\/code-review\)\.$/,
+    /^Codex usage limits have been reached\. Please try again later\.$/,
+];
+const ABOUT_BLOCK = /\n\n<details> <summary>ℹ️ About Codex (?:in GitHub|security reviews in GitHub)<\/summary>[\s\S]*?<\/details>$/;
+const ACTIVITY_SUMMARY = /^<!-- codex-pull-request-review-summary -->\n(?:<!-- codex-security-review:v1 \{[^\n]*\} -->\n)?\n?## Codex Review Summary\n\nThis comment shows the latest Codex review activity on this pull request\.\n\n\| Review \| Status \| Commit \| Review trigger \|\n\| --- \| --- \| --- \| --- \|\n(?:\|[^\n]+\|\n?)+$/;
+const CLEAN_REVIEW = /^Codex Review: Didn't find any major issues\. (?:Bravo\.|Breezy!|Hooray!|:\+1:)\n\n\*\*Reviewed commit:\*\* `[a-f0-9]+`$/;
+const CLEAN_SECURITY = /^### 🛡️ Codex Security Review(?: · _Automatically triggered_)?\n\nSecurity review completed\. No security issues were found in this pull request\.\n\n\*\*Reviewed commit:\*\* `[a-f0-9]+`\n\n\[View security finding report\]\(https:\/\/chatgpt.com\/codex\/cloud\/tasks\/[a-zA-Z0-9_]+\)\n\n_Only the user who started this review can view the report in Codex\._$/;
+/**
+ * Codex quota notices, the review-activity status table, and no-findings notices on conversation
+ * comments. Each pattern matches the whole comment, so a notice with any appended finding stays
+ * visible. Review summaries and inline comments are left for the normal review path.
+ */
+const rule = (item) => {
+    if (!isBotItem(item, ["chatgpt-codex-connector"], ["pr-comment"]))
+        return null;
+    const body = item.body.trim();
+    if (QUOTA_NOTICES.some((notice) => notice.test(body))) {
+        return { autoResolve: true, suppress: true, reason: "Codex usage-limit notice" };
+    }
+    // Strip only the trailing About block; extra findings after it stay visible.
+    const content = body.replace(ABOUT_BLOCK, "").trim();
+    if (ACTIVITY_SUMMARY.test(content)) {
+        return { autoResolve: true, suppress: true, reason: "Codex review-activity table" };
+    }
+    if (CLEAN_REVIEW.test(content) || CLEAN_SECURITY.test(content)) {
+        return { autoResolve: true, suppress: true, reason: "Codex no-findings notice" };
+    }
+    return null;
+};
+export default rule;

package/bin/classify/standard/dependabot-notices.d.mts

@@ -0,0 +1,4 @@
+import type { ClassifyRule } from "../types.mts";
+/** Dependabot's replies that report no change to make. */
+declare const rule: ClassifyRule;
+export default rule;

package/bin/classify/standard/dependabot-notices.mjs

@@ -0,0 +1,15 @@
+import { isBotItem } from "./author.mjs";
+const NOTICES = [
+    /^Looks like this PR is already up-to-date with [^\s!]+! If you'd still like to recreate it from scratch, overwriting any edits, you can request `@dependabot recreate`\.$/,
+    /^Looks like these dependencies are updatable in another way, so this is no longer needed\.$/,
+];
+/** Dependabot's replies that report no change to make. */
+const rule = (item) => {
+    if (!isBotItem(item, ["dependabot"], ["pr-comment"]))
+        return null;
+    const body = item.body.trim();
+    if (!NOTICES.some((notice) => notice.test(body)))
+        return null;
+    return { autoResolve: true, suppress: true, reason: "Dependabot no-op reply" };
+};
+export default rule;

package/bin/classify/standard/gemini-notices.d.mts

@@ -0,0 +1,4 @@
+import type { ClassifyRule } from "../types.mts";
+/** Gemini Code Assist daily-quota and review-limit notices on conversation comments. A heading means a real review. */
+declare const rule: ClassifyRule;
+export default rule;

package/bin/classify/standard/gemini-notices.mjs

@@ -0,0 +1,13 @@
+import { isBotItem } from "./author.mjs";
+/** Gemini Code Assist daily-quota and review-limit notices on conversation comments. A heading means a real review. */
+const rule = (item) => {
+    if (!isBotItem(item, ["gemini-code-assist"], ["pr-comment"]))
+        return null;
+    if (/^#{1,6}\s/m.test(item.body))
+        return null;
+    if (!/You have reached your daily quota limit|Review limit reached/i.test(item.body)) {
+        return null;
+    }
+    return { autoResolve: true, suppress: true, reason: "Gemini quota or review-limit notice" };
+};
+export default rule;

package/bin/classify/standard/index.d.mts

@@ -0,0 +1,7 @@
+import type { ClassifyRule } from "../types.mts";
+/**
+ * Bundled classification rules that `classify.standard` can enable by name.
+ * Each rule matches conversation comments (`pr-comment`) only.
+ */
+export declare const STANDARD_RULES: Readonly<Record<string, ClassifyRule>>;
+export declare const STANDARD_RULE_NAMES: readonly string[];

package/bin/classify/standard/index.mjs

@@ -0,0 +1,21 @@
+import coderabbitNotices from "./coderabbit-notices.mjs";
+import codecovReport from "./codecov-report.mjs";
+import codexNotices from "./codex-notices.mjs";
+import dependabotNotices from "./dependabot-notices.mjs";
+import geminiNotices from "./gemini-notices.mjs";
+import kiloNoIssues from "./kilo-no-issues.mjs";
+import sourceryNotices from "./sourcery-notices.mjs";
+/**
+ * Bundled classification rules that `classify.standard` can enable by name.
+ * Each rule matches conversation comments (`pr-comment`) only.
+ */
+export const STANDARD_RULES = {
+    "coderabbit-notices": coderabbitNotices,
+    "codecov-report": codecovReport,
+    "codex-notices": codexNotices,
+    "dependabot-notices": dependabotNotices,
+    "gemini-notices": geminiNotices,
+    "kilo-no-issues": kiloNoIssues,
+    "sourcery-notices": sourceryNotices,
+};
+export const STANDARD_RULE_NAMES = Object.keys(STANDARD_RULES);

package/bin/classify/standard/kilo-no-issues.d.mts

@@ -0,0 +1,4 @@
+import type { ClassifyRule } from "../types.mts";
+/** Kilo Code conversation comment whose status line reads "No Issues Found" and that carries no findings. */
+declare const rule: ClassifyRule;
+export default rule;