pr-shepherd 1.0.0 → 1.1.0

package/bin/github/poll-summary-row-error.mjs

@@ -0,0 +1,74 @@
+import { GitHubRequestError } from "./errors.mjs";
+import { hydratePollSummaryChecks } from "./poll-summary-check-hydration.mjs";
+import { refreshUnknownSummaryMergeability } from "./poll-summary-mergeability.mjs";
+import { pollCommandFields } from "./poll-summary-command.mjs";
+import { normalizePollSummaryState } from "./poll-summary-route.mjs";
+import { rateLimitKind } from "./rate-limit-kind.mjs";
+import { isGithubReadFallbackError } from "./transport.mjs";
+import { formatPrUrl } from "../pr-reference.mjs";
+/**
+ * Whether one PR's failed read becomes a row. Throttles, credential failures, and
+ * errors that switch transport describe the whole tick, so they still reject it.
+ */
+function isIsolatableRowError(error) {
+    if (isGithubReadFallbackError(error))
+        return false;
+    if (!(error instanceof GitHubRequestError))
+        return true;
+    return error.status !== 401 && rateLimitKind(error) === null;
+}
+/** Hydrate each PR's checks and mergeability; one PR's unreadable checks must not fail its siblings. */
+export async function hydrateRowsIsolated(raws, repo) {
+    const failures = new Map();
+    for (const raw of raws) {
+        try {
+            await hydratePollSummaryChecks(raw, repo);
+            await refreshUnknownSummaryMergeability(raw, repo);
+        }
+        catch (error) {
+            if (!isIsolatableRowError(error))
+                throw error;
+            failures.set(raw.number, error);
+        }
+    }
+    return failures;
+}
+/** A non-terminal row whose `pollCommand` runs the authoritative one-PR session. */
+function readFailureRow(raw, repo, opts, error) {
+    const repoName = `${repo.owner}/${repo.name}`;
+    return {
+        pr: raw.number,
+        repo: repoName,
+        ...(raw.transport && { transport: raw.transport }),
+        title: raw.title,
+        url: raw.url || formatPrUrl(repoName, raw.number),
+        action: "triage",
+        reasons: ["summary-read-failed"],
+        error: error instanceof Error ? error.message : String(error),
+        state: normalizePollSummaryState(raw.state),
+        mergeable: raw.mergeable,
+        mergeStateStatus: raw.mergeStateStatus,
+        headRefName: raw.headRefName,
+        headRefOid: raw.headRefOid,
+        baseRefName: raw.baseRefName,
+        ...(raw.isDraft && { isDraft: true }),
+        ...pollCommandFields(repoName, raw.number, raw.isDraft, opts),
+    };
+}
+/**
+ * Summarize each PR, turning an isolatable failure into a row. `failures` holds
+ * PRs whose chunk-time hydration already failed. A fatal error, or no readable
+ * row at all, rejects the tick with the first such error.
+ */
+export async function summarizeRowsIsolated(raws, failures, repo, opts, summarize) {
+    const settled = await Promise.allSettled(raws.map((raw) => failures.has(raw.number) ? Promise.reject(failures.get(raw.number)) : summarize(raw)));
+    const rejected = settled.filter((entry) => entry.status === "rejected");
+    const fatal = rejected.find((entry) => !isIsolatableRowError(entry.reason));
+    if (fatal)
+        throw fatal.reason;
+    if (rejected.length === settled.length)
+        throw rejected[0].reason;
+    return settled.map((entry, index) => entry.status === "fulfilled"
+        ? entry.value
+        : readFailureRow(raws[index], repo, opts, entry.reason));
+}

package/bin/github/poll-summary-rule-auto-resolve.d.mts

@@ -0,0 +1,32 @@
+import type { ClassifyAction } from "../classify/types.mts";
+import { type SeenMarker } from "../state/seen-comments.mts";
+import type { PollSummaryRuleAutoResolve } from "../types.mts";
+import type { RawSummaryPr } from "./poll-summary-raw.mts";
+export interface SummaryStateKey {
+    owner: string;
+    repo: string;
+    pr: number;
+}
+export interface SummaryRuleActions {
+    comments: ReadonlyMap<string, ClassifyAction>;
+    summaries: ReadonlyMap<string, ClassifyAction>;
+    threads: ReadonlyMap<string, ClassifyAction>;
+}
+export interface SummaryAutoResolve {
+    /** Items whose mutation GitHub confirmed this tick. */
+    confirmed: ReadonlySet<string>;
+    /** Items Shepherd may mutate whose mutation was not confirmed; the full check still has work. */
+    unconfirmed: ReadonlySet<string>;
+    report?: PollSummaryRuleAutoResolve;
+}
+/**
+ * Apply the rule-driven auto-resolve the one-PR check performs: minimize matching PR comments and
+ * COMMENTED review summaries, resolve matching unresolved threads. Capability, denial, and marker
+ * handling mirror `check.mts`; a denied item is left to the normal first-look gate.
+ */
+export declare function applySummaryRuleAutoResolve(input: {
+    raw: RawSummaryPr;
+    actions: SummaryRuleActions;
+    seen: Map<string, SeenMarker>;
+    key: SummaryStateKey;
+}): Promise<SummaryAutoResolve>;

package/bin/github/poll-summary-rule-auto-resolve.mjs

@@ -0,0 +1,119 @@
+import { normalizeAuthorType } from "../comments/authors.mjs";
+import { buildRuleAutoResolveReport } from "../commands/rule-auto-resolve-format.mjs";
+import { applySuppressedRuleAutoResolve } from "../commands/rule-auto-resolve.mjs";
+import { markSeen, mutationWasDenied } from "../state/seen-comments.mjs";
+import { threadTranscriptBodies } from "../threads/transcript.mjs";
+import { canGenerateGithubMutation } from "./mutation-policy.mjs";
+const NONE = { confirmed: new Set(), unconfirmed: new Set() };
+function matchesAutoResolve(action) {
+    return action?.suppress === true && action.autoResolve === true;
+}
+function toReviewThread(thread) {
+    const root = thread.comments.nodes[0];
+    return {
+        id: thread.id,
+        ...(thread.isResolved !== undefined && { isResolved: thread.isResolved }),
+        ...(thread.isOutdated !== undefined && { isOutdated: thread.isOutdated }),
+        ...(thread.viewerCanResolve !== undefined && { viewerCanResolve: thread.viewerCanResolve }),
+        path: thread.path ?? root?.path ?? null,
+        line: thread.line ?? null,
+        startLine: thread.startLine ?? null,
+        author: root?.author?.login ?? "unknown",
+        authorType: normalizeAuthorType(root?.author?.__typename, root?.author?.login),
+        body: root?.body ?? "",
+        url: root?.url ?? "",
+    };
+}
+/** The transcript the full check hashes is complete only when the window holds every comment. */
+function threadDenied(thread, seen) {
+    const transcript = threadTranscriptBodies(thread.comments.nodes.map((comment) => comment.body));
+    return thread.comments.pageInfo.hasPreviousPage
+        ? seen.get(thread.id)?.deniedMutationBodyHash !== undefined
+        : mutationWasDenied(thread.id, transcript, seen);
+}
+/** Patch the read to match GitHub so a stack handoff does not replay the mutation. */
+function patchRaw(raw, confirmed) {
+    for (const comment of [...raw.comments.nodes, ...raw.reviews.nodes])
+        if (confirmed.has(comment.id))
+            comment.isMinimized = true;
+    for (const thread of raw.reviewThreads.nodes)
+        if (confirmed.has(thread.id))
+            thread.isResolved = true;
+}
+/**
+ * Apply the rule-driven auto-resolve the one-PR check performs: minimize matching PR comments and
+ * COMMENTED review summaries, resolve matching unresolved threads. Capability, denial, and marker
+ * handling mirror `check.mts`; a denied item is left to the normal first-look gate.
+ */
+export async function applySummaryRuleAutoResolve(input) {
+    const { raw, actions, seen, key } = input;
+    const comments = raw.comments.nodes.filter((comment) => !comment.isMinimized &&
+        matchesAutoResolve(actions.comments.get(comment.id)) &&
+        !mutationWasDenied(comment.id, comment.body, seen) &&
+        canGenerateGithubMutation(comment.viewerCanMinimize, "minimize"));
+    const summaries = raw.reviews.nodes.filter((review) => !review.isMinimized &&
+        matchesAutoResolve(actions.summaries.get(review.id)) &&
+        !mutationWasDenied(review.id, review.body, seen) &&
+        canGenerateGithubMutation(review.viewerCanMinimize, "minimize"));
+    const threads = raw.reviewThreads.nodes.filter((thread) => thread.isResolved === false &&
+        thread.isOutdated !== true &&
+        matchesAutoResolve(actions.threads.get(thread.id)) &&
+        !threadDenied(thread, seen) &&
+        canGenerateGithubMutation(thread.viewerCanResolve, "resolve"));
+    if (comments.length + summaries.length + threads.length === 0)
+        return NONE;
+    // The full check marks every non-denied suppressed item before it mutates, whatever the outcome.
+    await Promise.allSettled([
+        ...[...comments, ...summaries].map((item) => markSeen(key, item.id, item.body)),
+        ...threads
+            .filter((thread) => !thread.comments.pageInfo.hasPreviousPage)
+            .map((thread) => markSeen(key, thread.id, threadTranscriptBodies(thread.comments.nodes.map((comment) => comment.body)))),
+    ]);
+    const reviewThreads = threads.map(toReviewThread);
+    const reasonOf = (id, map) => {
+        const reason = map.get(id)?.reason;
+        return [id, reason ? [reason] : []];
+    };
+    const ruleReasons = new Map([
+        ...comments.map((item) => reasonOf(item.id, actions.comments)),
+        ...summaries.map((item) => reasonOf(item.id, actions.summaries)),
+        ...threads.map((item) => reasonOf(item.id, actions.threads)),
+    ]);
+    const partition = {
+        suppressedCommentIds: new Set(comments.map((item) => item.id)),
+        suppressedThreadIds: new Set(threads.map((item) => item.id)),
+        suppressedReviewSummaryIds: new Set(summaries.map((item) => item.id)),
+        suppressedChangesRequestedIds: new Set(),
+        ruleAutoResolveCommentIds: comments.map((item) => item.id),
+        ruleAutoResolveThreadIds: threads.map((item) => item.id),
+        ruleAutoResolveReviewSummaryIds: summaries.map((item) => item.id),
+        ruleReasons,
+    };
+    const applied = await applySuppressedRuleAutoResolve({
+        enabled: true,
+        partition,
+        batch: { comments, reviewSummaries: summaries, reviewThreads },
+    });
+    const confirmed = new Set([
+        ...applied.autoMinimized.map((item) => item.id),
+        ...applied.autoResolved.map((thread) => thread.id),
+    ]);
+    patchRaw(raw, confirmed);
+    const full = buildRuleAutoResolveReport({
+        threads: applied.autoResolved,
+        minimized: applied.autoMinimized,
+        errors: applied.autoResolveErrors,
+        errorReasons: applied.errorReasons,
+    });
+    const report = full && {
+        ...full,
+        ...(full.threads && {
+            threads: full.threads.map((thread) => ({
+                id: thread.id,
+                ...(thread.url && { url: thread.url }),
+            })),
+        }),
+    };
+    const unconfirmed = [...ruleReasons.keys()].filter((id) => !confirmed.has(id));
+    return { confirmed, unconfirmed: new Set(unconfirmed), ...(report && { report }) };
+}

package/bin/github/poll-summary-rule-handoff.d.mts

@@ -0,0 +1,7 @@
+import type { PollSummaryItem } from "../types.mts";
+import type { RawSummaryPr } from "./poll-summary-raw.mts";
+/**
+ * A stack handoff clones the read before rows are evaluated. Reflect the rule-driven mutations the
+ * rows confirmed so the one-PR session that consumes the handoff does not repeat them.
+ */
+export declare function patchHandoffLayers(layers: RawSummaryPr[], items: PollSummaryItem[]): void;

package/bin/github/poll-summary-rule-handoff.mjs

@@ -0,0 +1,20 @@
+/**
+ * A stack handoff clones the read before rows are evaluated. Reflect the rule-driven mutations the
+ * rows confirmed so the one-PR session that consumes the handoff does not repeat them.
+ */
+export function patchHandoffLayers(layers, items) {
+    for (const item of items) {
+        const report = item.ruleAutoResolve;
+        const layer = layers.find((candidate) => candidate.number === item.pr);
+        if (!report || !layer)
+            continue;
+        const minimized = new Set(report.minimized?.map((entry) => entry.id));
+        const resolved = new Set(report.threads?.map((thread) => thread.id));
+        for (const node of [...layer.comments.nodes, ...layer.reviews.nodes])
+            if (minimized.has(node.id))
+                node.isMinimized = true;
+        for (const thread of layer.reviewThreads.nodes)
+            if (resolved.has(thread.id))
+                thread.isResolved = true;
+    }
+}

package/bin/github/poll-summary-rule-items.d.mts

@@ -0,0 +1,20 @@
+import { applyRules } from "../classify/apply.mts";
+import type { ClassifyAction, ClassifyItem } from "../classify/types.mts";
+import type { RawAuthor } from "./poll-summary-raw.mts";
+type Rules = Parameters<typeof applyRules>[0];
+export interface RuleSource {
+    id: string;
+    body: string;
+    author: RawAuthor | null;
+    authorAssociation?: string;
+    url?: string;
+    path?: string | null;
+}
+/** The rule action for one compact item, built like the full check builds its rule items. */
+export declare function summaryRuleAction(rules: Rules, kind: ClassifyItem["kind"], raw: RuleSource | undefined, id?: string, path?: string | null, body?: string): ClassifyAction;
+/**
+ * An auto-resolve match is hidden only once its mutation is confirmed or the item is already
+ * resolved; until then it stays visible so the full check can run or surface it.
+ */
+export declare function ruleHides(action: ClassifyAction, kind: ClassifyItem["kind"], autoResolveSatisfied: boolean): boolean;
+export {};

package/bin/github/poll-summary-rule-items.mjs

@@ -0,0 +1,28 @@
+import { applyRules } from "../classify/apply.mjs";
+import { normalizeAuthorType } from "../comments/authors.mjs";
+/** The rule action for one compact item, built like the full check builds its rule items. */
+export function summaryRuleAction(rules, kind, raw, id = raw?.id ?? "unknown", path, body = raw?.body ?? "") {
+    const item = {
+        kind,
+        id,
+        author: raw?.author?.login ?? "unknown",
+        authorType: normalizeAuthorType(raw?.author?.__typename, raw?.author?.login),
+        ...(raw?.authorAssociation !== undefined && { authorAssociation: raw.authorAssociation }),
+        body,
+        // A changes-requested rule item carries no URL, as in the full check.
+        ...(kind === "review-thread" ? { url: raw?.url ?? "" } : {}),
+        ...(kind !== "review-thread" && kind !== "changes-requested" && raw?.url
+            ? { url: raw.url }
+            : {}),
+        ...(kind === "review-thread" && { path }),
+    };
+    return applyRules(rules, item);
+}
+/**
+ * An auto-resolve match is hidden only once its mutation is confirmed or the item is already
+ * resolved; until then it stays visible so the full check can run or surface it.
+ */
+export function ruleHides(action, kind, autoResolveSatisfied) {
+    return (action.suppress === true &&
+        (action.autoResolve !== true || kind === "changes-requested" || autoResolveSatisfied));
+}

package/bin/github/poll-summary.mjs

@@ -8,11 +8,13 @@ import { missingRepositoryError } from "./errors.mjs";
 import { hydratePollSummaryChecks } from "./poll-summary-check-hydration.mjs";
 import { refreshUnknownSummaryMergeability } from "./poll-summary-mergeability.mjs";
 import { summarizePollSummaryPr } from "./poll-summary-projector.mjs";
+import { hydrateRowsIsolated, summarizeRowsIsolated, } from "./poll-summary-row-error.mjs";
 import { trunkRequiredContexts } from "./poll-summary-unreported.mjs";
 import { loadStackSizeHint, storeStackSizeHint } from "./stack-size-hint.mjs";
 import { POLL_SUMMARY_FRAGMENT } from "./queries.mjs";
 import { stackAncestryGaps } from "./stack-read.mjs";
 import { readGraphqlStackSummary } from "./poll-summary-stack-page.mjs";
+import { patchHandoffLayers } from "./poll-summary-rule-handoff.mjs";
 import { stackHandoffSource } from "./stack-handoff.mjs";
 const MAX_EXPLICIT_PRS_PER_QUERY = 50;
 async function fetchSelectedPollSummary(opts, repo) {
@@ -23,21 +25,27 @@ async function fetchSelectedPollSummary(opts, repo) {
         throw new ShepherdError("Aggregate poll requires at least two PRs or a stack PR", EXIT.USAGE);
     }
     const raw = [];
+    const failures = new Map();
     let viewerCanAdminister;
     for (let offset = 0; offset < requested.length; offset += MAX_EXPLICIT_PRS_PER_QUERY) {
         const chunk = requested.slice(offset, offset + MAX_EXPLICIT_PRS_PER_QUERY);
         const fetched = await fetchExplicitChunk(chunk, repo);
         viewerCanAdminister = fetched.viewerCanAdminister;
         raw.push(...fetched.prs);
+        for (const [pr, error] of fetched.failures ?? [])
+            failures.set(pr, error);
     }
     return {
         selection: { kind: "prs", requested },
-        prs: await Promise.all(raw.map((pr) => summarizePollSummaryPr(pr, repo, opts, viewerCanAdminister))),
+        // One explicit PR's failed read becomes a row; stack selections stay fail-closed.
+        prs: await summarizeRowsIsolated(raw, failures, repo, opts, (pr) => summarizePollSummaryPr(pr, repo, opts, viewerCanAdminister, undefined, null, true)),
     };
 }
 /** Fresh, read-only snapshot used to bind a one-PR READY receipt to stack routing. */
 export async function fetchRawSummaryPr(pr, repo) {
     const fetched = await fetchExplicitChunk([pr], repo);
+    if (fetched.failures?.has(pr))
+        throw fetched.failures.get(pr);
     return fetched.prs[0];
 }
 async function fetchGraphqlExplicitChunk(prs, repo) {
@@ -60,11 +68,8 @@ async function fetchGraphqlExplicitChunk(prs, repo) {
             throw new ShepherdError(`PR #${pr} not found`, EXIT.UNAVAILABLE);
         return raw;
     });
-    for (const raw of rawPrs) {
-        await hydratePollSummaryChecks(raw, repo);
-        await refreshUnknownSummaryMergeability(raw, repo);
-    }
-    return { prs: rawPrs, viewerCanAdminister: result.data.repository.viewerCanAdminister };
+    const failures = await hydrateRowsIsolated(rawPrs, repo);
+    return { prs: rawPrs, viewerCanAdminister: result.data.repository.viewerCanAdminister, failures };
 }
 async function fetchExplicitChunk(prs, repo) {
     return githubOperation("PollSummary", () => runWithGithubTransport("graphql", () => fetchGraphqlExplicitChunk(prs, repo)), async () => ({
@@ -101,9 +106,12 @@ async function fetchStackSummary(opts, repo) {
     const handoffSource = getGithubTransport() === "rest" ? undefined : stackHandoffSource(read);
     const stackAncestry = stackAncestryGaps(ordered);
     const required = await trunkRequiredContexts(ordered, repo);
+    const prs = await Promise.all(ordered.map((pr) => summarizePollSummaryPr(pr, repo, opts, viewerCanAdminister, required, viewerLogin, true)));
+    if (handoffSource)
+        patchHandoffLayers(handoffSource.layers, prs);
     return {
         selection: { kind: "stack", anchor, stackNumber, stackSize },
-        prs: await Promise.all(ordered.map((pr) => summarizePollSummaryPr(pr, repo, opts, viewerCanAdminister, required, viewerLogin))),
+        prs,
         ...(stackAncestry.length > 0 && { stackAncestry }),
         ...(allowedMergeMethods && { allowedMergeMethods }),
         ...(handoffSource && { handoffSource }),

package/bin/github/rest-reader-core.mjs

@@ -101,7 +101,9 @@ function nextRestPage(link, original) {
     if (!match)
         malformedRest(`invalid pagination link for ${original}`);
     const url = new URL(match[1], "https://api.github.com");
-    if (url.origin !== "https://api.github.com" || url.pathname !== original.split("?")[0])
+    const originalPath = original.split("?")[0];
+    if (url.origin !== "https://api.github.com" ||
+        !samePaginationResource(url.pathname, originalPath))
         malformedRest(`unsafe pagination link for ${original}`);
     if (url.searchParams.get("per_page") !== "100")
         malformedRest(`changed page size for ${original}`);
@@ -113,7 +115,16 @@ function nextRestPage(link, original) {
                 JSON.stringify(source.searchParams.getAll(key)))
             malformedRest(`changed pagination filter for ${original}`);
     }
-    return `${url.pathname}${url.search}`;
+    // Rebuild on the requested path so the repository id in a /repositories/{id} link is never trusted.
+    return `${originalPath}${url.search}`;
+}
+/** GitHub may link `/repos/{owner}/{repo}/…` pages through `/repositories/{id}/…`. */
+function samePaginationResource(linkPath, originalPath) {
+    if (linkPath === originalPath)
+        return true;
+    const linkSuffix = /^\/repositories\/\d+(\/.*)$/.exec(linkPath)?.[1];
+    const originalSuffix = /^\/repos\/[^/]+\/[^/]+(\/.*)$/.exec(originalPath)?.[1];
+    return linkSuffix !== undefined && linkSuffix === originalSuffix;
 }
 /** A pull request whose mergeability GitHub is still computing must be re-read, never replayed. */
 function isSettledBody(body) {

package/bin/github/rest-summary-read.mjs

@@ -99,7 +99,7 @@ export function restSummary(data, pull, feedback, checks, baseRef) {
                             nodes: checks.suites.map((suite) => ({
                                 status: suite.status.toUpperCase(),
                                 conclusion: suite.conclusion?.toUpperCase() ?? null,
-                                workflowRun: checks.workflowRuns.find((run) => run.check_suite_id === suite.id) ?? null,
+                                workflowRun: restSuiteWorkflowRun(checks.workflowRuns.find((run) => run.check_suite_id === suite.id)),
                             })),
                         },
                     },
@@ -110,3 +110,14 @@ export function restSummary(data, pull, feedback, checks, baseRef) {
         transportUnavailable: data.transportUnavailable,
     };
 }
+/** The GraphQL `workflowRun` shape, so summary readers see one suite format on either transport. */
+function restSuiteWorkflowRun(run) {
+    if (!run)
+        return null;
+    return {
+        databaseId: run.id,
+        event: run.event,
+        url: run.html_url,
+        workflow: { name: run.name },
+    };
+}

package/bin/types/github.d.mts

@@ -60,6 +60,8 @@ export interface CheckRun {
     workflowId?: string;
     /** True when GraphQL reported at least one CheckRun annotation. Omitted when false. */
     hasAnnotations?: boolean;
+    /** Annotation total GraphQL reported for this CheckRun. Internal: validates cached lists. */
+    annotationCount?: number;
     /**
      * Every annotation on this run, when BatchPr's `annotations(first: 1)` page already held all
      * of them. Internal: lets the check path skip `CheckRunAnnotationsBatch`; never rendered.

package/bin/types/poll-summary.d.mts

@@ -3,6 +3,7 @@ import type { MergeableState, MergeStateStatus, ReviewDecision } from "./github.
 import type { MergeQueueRemovalStatus } from "./merge-requirements.mts";
 import type { ShepherdAction } from "./iterate.mts";
 import type { NextCheck } from "./next-check.mts";
+import type { AutoMinimizedItem } from "./report.mts";
 export interface PollSummaryChecks {
     passing?: number;
     failing?: number;
@@ -12,11 +13,26 @@ export interface PollSummaryChecks {
     ignored?: number;
     superseded?: number;
     incomplete?: true;
+    /**
+     * Non-SUCCESS checks with annotations the one-PR check has not shown yet (or that could not be
+     * read). Only set on a row that would otherwise claim ready; it routes to `triage`.
+     */
+    annotated?: number;
     /** Required contexts with no check run and no status context. Omitted when empty. */
     unreportedRequired?: string[];
     /** A relevant Actions workflow suite has not completed. */
     actionsWorkflowInProgress?: true;
 }
+/** The one-PR `ruleAutoResolve` content, with threads reduced to what a row needs: ID and link. */
+export interface PollSummaryRuleAutoResolve {
+    summary: string;
+    threads?: Array<{
+        id: string;
+        url?: string;
+    }>;
+    minimized?: AutoMinimizedItem[];
+    errors?: string[];
+}
 export interface PollSummaryReview {
     comments?: number;
     reviews?: number;
@@ -56,6 +72,8 @@ export interface PollSummaryItem {
     /** Conservative routing hint; the selected one-PR poll makes the authoritative decision. */
     action: ShepherdAction;
     reasons: string[];
+    /** Raw message of the error that stopped this PR's summary read (`summary-read-failed`). */
+    error?: string;
     state: "OPEN" | "CLOSED" | "MERGED" | "UNKNOWN";
     mergeable: MergeableState;
     mergeStateStatus: MergeStateStatus;
@@ -72,6 +90,11 @@ export interface PollSummaryItem {
     remainingSeconds?: number;
     checks?: PollSummaryChecks;
     review?: PollSummaryReview;
+    /**
+     * Rule-driven auto-resolve this tick performed or failed, in the one-PR `ruleAutoResolve`
+     * shape. Kept out of `review` so a one-tick event does not churn the status signature.
+     */
+    ruleAutoResolve?: PollSummaryRuleAutoResolve;
     stack?: PollSummaryStack;
     pollCommand?: string;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pr-shepherd",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Autonomous PR CI monitor and review-comment resolver for agentic coding tools",
   "keywords": [
     "automation",
@@ -91,7 +91,7 @@
     "husky": "^9.1.7",
     "knip": "^6.14.1",
     "marked": "^18.0.11",
-    "oxfmt": "^0.72.0",
+    "oxfmt": "^0.73.0",
     "oxlint": "^1.60.0",
     "typescript": "^7.0.2",
     "vitest": "^5.0.0"

package/plugins/pr-shepherd/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "pr-shepherd",
   "description": "Autonomous PR CI monitor and review-comment resolver for agentic coding tools",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "author": {
     "name": "Jonathan Ong",
     "email": "jonathanrichardong@gmail.com"

package/plugins/pr-shepherd/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "pr-shepherd",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Autonomous PR CI monitor and review-comment resolver for Codex.",
   "author": {
     "name": "Jonathan Ong",

package/plugins/pr-shepherd/.codex.mcp.json

@@ -2,7 +2,7 @@
   "mcpServers": {
     "pr-shepherd": {
       "command": "npx",
-      "args": ["--yes", "--package", "pr-shepherd@1.0.0", "pr-shepherd-mcp"]
+      "args": ["--yes", "--package", "pr-shepherd@1.1.0", "pr-shepherd-mcp"]
     }
   }
 }

package/plugins/pr-shepherd/.mcp.json

@@ -1,6 +1,6 @@
 {
   "pr-shepherd": {
     "command": "npx",
-    "args": ["--yes", "--package", "pr-shepherd@1.0.0", "pr-shepherd-mcp"]
+    "args": ["--yes", "--package", "pr-shepherd@1.1.0", "pr-shepherd-mcp"]
   }
 }