patchrelay 0.35.16 → 0.36.0

package/dist/idle-reconciliation.js

@@ -7,6 +7,20 @@ import { execCommand } from "./utils.js";
 function isFailingCheckStatus(status) {
     return status === "failed" || status === "failure";
 }
+function isReviewDecisionApproved(value) {
+    return value?.trim().toUpperCase() === "APPROVED";
+}
+function isReviewDecisionChangesRequested(value) {
+    return value?.trim().toUpperCase() === "CHANGES_REQUESTED";
+}
+function isReviewDecisionReviewRequired(value) {
+    return value?.trim().toUpperCase() === "REVIEW_REQUIRED";
+}
+function hasCompletedReviewQuillVerdict(entries) {
+    return (entries ?? []).some((entry) => entry.__typename === "CheckRun"
+        && entry.name === "review-quill/verdict"
+        && entry.status === "COMPLETED");
+}
 function getGateCheckNames(project) {
     const configured = project?.gateChecks?.map((entry) => entry.trim()).filter(Boolean) ?? [];
     return configured.length > 0 ? configured : ["verify"];
@@ -115,6 +129,11 @@ export class IdleIssueReconciler {
                 await this.reconcileFromGitHub(issue);
             }
         }
+        for (const issue of this.db.listIssues()) {
+            if (!this.shouldProbeTerminalIssueFromGitHub(issue))
+                continue;
+            await this.reconcileFromGitHub(issue);
+        }
         for (const issue of this.db.listBlockedDelegatedIssues()) {
             const unresolved = this.db.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
             if (unresolved === 0) {
@@ -130,6 +149,15 @@ export class IdleIssueReconciler {
             }
         }
     }
+    shouldProbeTerminalIssueFromGitHub(issue) {
+        if (issue.prNumber === undefined)
+            return false;
+        if (issue.activeRunId !== undefined)
+            return false;
+        if (issue.pendingRunType !== undefined)
+            return false;
+        return issue.factoryState === "escalated" || issue.factoryState === "failed";
+    }
     advanceIdleIssue(issue, newState, options) {
         if (issue.factoryState === newState && !options?.pendingRunType && !options?.clearFailureProvenance) {
             return;
@@ -191,9 +219,9 @@ export class IdleIssueReconciler {
             eventType = "settled_red_ci";
             dedupeKey = `${dedupeScope}:ci_repair:${issue.linearIssueId}:${issue.lastGitHubFailureSignature ?? issue.prHeadSha ?? issue.lastGitHubFailureHeadSha ?? "unknown"}`;
         }
-        else if (runType === "review_fix") {
+        else if (runType === "review_fix" || runType === "branch_upkeep") {
             eventType = "review_changes_requested";
-            dedupeKey = `${dedupeScope}:review_fix:${issue.linearIssueId}:${issue.prHeadSha ?? "unknown"}`;
+            dedupeKey = `${dedupeScope}:${runType}:${issue.linearIssueId}:${issue.prHeadSha ?? "unknown"}`;
         }
         else {
             eventType = "delegated";
@@ -363,6 +391,7 @@ export class IdleIssueReconciler {
                 "--json", "headRefOid,state,reviewDecision,mergeable,mergeStateStatus,statusCheckRollup",
             ], { timeoutMs: 10_000 });
             const pr = JSON.parse(stdout);
+            const previousHeadSha = issue.prHeadSha;
             const gateCheckNames = getGateCheckNames(project);
             const gateCheckStatus = deriveGateCheckStatusFromRollup(pr.statusCheckRollup, gateCheckNames);
             this.db.upsertIssue({
@@ -370,11 +399,13 @@ export class IdleIssueReconciler {
                 linearIssueId: issue.linearIssueId,
                 ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
                 ...(pr.state === "OPEN" ? { prState: "open" } : {}),
-                ...(pr.reviewDecision === "APPROVED"
+                ...(isReviewDecisionApproved(pr.reviewDecision)
                     ? { prReviewState: "approved" }
-                    : pr.reviewDecision === "CHANGES_REQUESTED"
+                    : isReviewDecisionChangesRequested(pr.reviewDecision)
                         ? { prReviewState: "changes_requested" }
-                        : {}),
+                        : isReviewDecisionReviewRequired(pr.reviewDecision)
+                            ? { prReviewState: "commented" }
+                            : {}),
                 ...(gateCheckStatus ? { prCheckStatus: gateCheckStatus } : {}),
                 ...(pr.headRefOid && gateCheckStatus
                     ? {
@@ -399,6 +430,39 @@ export class IdleIssueReconciler {
                 });
                 return;
             }
+            const headAdvanced = Boolean(pr.headRefOid && pr.headRefOid !== previousHeadSha);
+            if (issue.factoryState !== "awaiting_input") {
+                const terminalRecoveryState = this.deriveTerminalRecoveryState(issue, pr.reviewDecision, gateCheckStatus, headAdvanced);
+                if (terminalRecoveryState) {
+                    this.logger.info({
+                        issueKey: issue.issueKey,
+                        prNumber: issue.prNumber,
+                        from: issue.factoryState,
+                        to: terminalRecoveryState,
+                        gateCheckStatus,
+                        reviewDecision: pr.reviewDecision,
+                        headAdvanced,
+                    }, "Reconciliation: recovered terminal issue from newer GitHub truth");
+                    this.advanceIdleIssue(issue, terminalRecoveryState, { clearFailureProvenance: true });
+                    return;
+                }
+            }
+            if (isReviewDecisionReviewRequired(pr.reviewDecision)
+                && gateCheckStatus === "success"
+                && hasCompletedReviewQuillVerdict(pr.statusCheckRollup)) {
+                this.logger.warn({ issueKey: issue.issueKey, prNumber: issue.prNumber, reviewDecision: pr.reviewDecision }, "Reconciliation: review-quill completed without a decisive GitHub review; escalating for operator input");
+                this.advanceIdleIssue(issue, "awaiting_input");
+                this.feed?.publish({
+                    level: "warn",
+                    kind: "github",
+                    issueKey: issue.issueKey,
+                    projectId: issue.projectId,
+                    stage: "awaiting_input",
+                    status: "non_decisive_review",
+                    summary: `PR #${issue.prNumber} needs operator input: review-quill finished but GitHub still requires review`,
+                });
+                return;
+            }
             const downstreamOwned = issue.factoryState === "awaiting_queue" || issue.prReviewState === "approved" || pr.reviewDecision === "APPROVED";
             const mergeConflictDetected = pr.mergeable === "CONFLICTING" || pr.mergeStateStatus === "DIRTY";
             const refreshedIssue = this.db.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
@@ -432,7 +496,7 @@ export class IdleIssueReconciler {
                 });
                 return;
             }
-            if (pr.reviewDecision === "APPROVED") {
+            if (isReviewDecisionApproved(pr.reviewDecision)) {
                 this.db.upsertIssue({
                     projectId: issue.projectId,
                     linearIssueId: issue.linearIssueId,
@@ -460,4 +524,22 @@ export class IdleIssueReconciler {
             }
         }
     }
+    deriveTerminalRecoveryState(issue, reviewDecision, gateCheckStatus, headAdvanced) {
+        if (issue.factoryState !== "escalated" && issue.factoryState !== "failed") {
+            return undefined;
+        }
+        if (isReviewDecisionApproved(reviewDecision) && !isFailingCheckStatus(gateCheckStatus)) {
+            return "awaiting_queue";
+        }
+        if (gateCheckStatus === "pending") {
+            return "pr_open";
+        }
+        if (headAdvanced && !isFailingCheckStatus(gateCheckStatus)) {
+            return "pr_open";
+        }
+        if (isReviewDecisionReviewRequired(reviewDecision) && !isFailingCheckStatus(gateCheckStatus)) {
+            return "pr_open";
+        }
+        return undefined;
+    }
 }

package/dist/issue-query-service.js

@@ -143,8 +143,10 @@ export class IssueQueryService {
             factoryState: issueRecord?.factoryState ?? "delegated",
             pendingRunType: issueRecord?.pendingRunType,
             prNumber: session.prNumber,
+            prHeadSha: issueRecord?.prHeadSha ?? session.prHeadSha,
             prReviewState: issueRecord?.prReviewState,
             prCheckStatus: issueRecord?.prCheckStatus,
+            lastBlockingReviewHeadSha: issueRecord?.lastBlockingReviewHeadSha,
             latestFailureCheckName: issueRecord?.lastGitHubFailureCheckName,
         });
         const issue = {

package/dist/issue-session-events.js

@@ -33,8 +33,8 @@ export function deriveSessionWakePlan(issue, events) {
                 break;
             case "review_changes_requested":
                 if (runType !== "queue_repair" && runType !== "ci_repair") {
-                    runType = "review_fix";
-                    wakeReason = "review_changes_requested";
+                    runType = payload?.branchUpkeepRequired === true ? "branch_upkeep" : "review_fix";
+                    wakeReason = payload?.branchUpkeepRequired === true ? "branch_upkeep" : "review_changes_requested";
                     Object.assign(context, payload ?? {});
                 }
                 break;

package/dist/issue-session.js

@@ -18,6 +18,8 @@ export function deriveIssueSessionWakeReason(params) {
         return "delegated";
     if (params.pendingRunType === "review_fix")
         return "review_changes_requested";
+    if (params.pendingRunType === "branch_upkeep")
+        return "branch_upkeep";
     if (params.pendingRunType === "ci_repair")
         return "settled_red_ci";
     if (params.pendingRunType === "queue_repair")

package/dist/linear-session-reporting.js

@@ -49,6 +49,8 @@ export function buildRunStartedActivity(runType) {
     switch (runType) {
         case "review_fix":
             return { type: "action", action: "Addressing", parameter: "review feedback" };
+        case "branch_upkeep":
+            return { type: "action", action: "Repairing", parameter: "PR branch upkeep after requested changes" };
         case "ci_repair":
             return { type: "action", action: "Repairing", parameter: "failing CI checks" };
         case "queue_repair":

package/dist/linear-session-sync.js

@@ -241,8 +241,10 @@ function renderStatusComment(db, issue, trackedIssue, options) {
         factoryState: issue.factoryState,
         pendingRunType: issue.pendingRunType,
         ...(issue.prNumber !== undefined ? { prNumber: issue.prNumber } : {}),
+        prHeadSha: issue.prHeadSha,
         prReviewState: issue.prReviewState,
         prCheckStatus: issue.prCheckStatus,
+        lastBlockingReviewHeadSha: issue.lastBlockingReviewHeadSha,
         latestFailureCheckName: issue.lastGitHubFailureCheckName,
     });
     const lines = [