patchrelay 0.35.10 → 0.35.12

package/dist/idle-reconciliation.js

@@ -1,7 +1,16 @@
 import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
 import { parseGitHubFailureContext } from "./github-failure-context.js";
+import { deriveGateCheckStatusFromRollup } from "./github-rollup.js";
+import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
 import { parseStoredQueueRepairContext } from "./merge-queue-incident.js";
 import { execCommand } from "./utils.js";
+function isFailingCheckStatus(status) {
+    return status === "failed" || status === "failure";
+}
+function getGateCheckNames(project) {
+    const configured = project?.gateChecks?.map((entry) => entry.trim()).filter(Boolean) ?? [];
+    return configured.length > 0 ? configured : ["verify"];
+}
 function isDuplicateRepairAttempt(issue, context) {
     const signature = typeof context?.failureSignature === "string" ? context.failureSignature : undefined;
     const headSha = typeof context?.failureHeadSha === "string"
@@ -36,11 +45,23 @@ function buildFailureContext(issue) {
         ...(queueRepairContext ? queueRepairContext : {}),
     };
 }
+function hasFailureProvenance(issue) {
+    return Boolean(issue.lastGitHubFailureSource
+        || issue.lastGitHubFailureHeadSha
+        || issue.lastGitHubFailureSignature
+        || issue.lastGitHubFailureCheckName
+        || issue.lastGitHubFailureCheckUrl
+        || issue.lastGitHubFailureContextJson
+        || issue.lastGitHubFailureAt
+        || issue.lastQueueIncidentJson
+        || issue.lastAttemptedFailureHeadSha
+        || issue.lastAttemptedFailureSignature);
+}
 export function resolveBranchOwnerForStateTransition(newState, pendingRunType) {
     if (pendingRunType)
         return "patchrelay";
     if (newState === "awaiting_queue")
-        return "merge_steward";
+        return "patchrelay";
     if (newState === "repairing_ci" || newState === "repairing_queue")
         return "patchrelay";
     return undefined;
@@ -64,16 +85,27 @@ export class IdleIssueReconciler {
                 this.advanceIdleIssue(issue, "done", { clearFailureProvenance: true });
                 continue;
             }
-            if (issue.prReviewState === "approved" && issue.prCheckStatus !== "failed") {
-                if (issue.factoryState !== "awaiting_queue" || issue.branchOwner !== "merge_steward") {
+            if (issue.lastGitHubFailureSource === "queue_eviction") {
+                await this.routeFailedIssue(issue);
+                continue;
+            }
+            if (issue.lastGitHubFailureSource === "branch_ci") {
+                await this.routeFailedIssue(issue);
+                continue;
+            }
+            if (issue.prReviewState === "approved" && !isFailingCheckStatus(issue.prCheckStatus)) {
+                if (issue.prNumber) {
+                    await this.reconcileFromGitHub(issue);
+                }
+                else if (issue.factoryState !== "awaiting_queue") {
                     this.advanceIdleIssue(issue, "awaiting_queue", { clearFailureProvenance: true });
                 }
-                else if (!issue.queueLabelApplied) {
-                    await this.deps.requestMergeQueueAdmission(issue, issue.projectId);
+                else if (hasFailureProvenance(issue)) {
+                    this.advanceIdleIssue(issue, "awaiting_queue", { clearFailureProvenance: true });
                 }
                 continue;
             }
-            if (issue.prCheckStatus === "failed") {
+            if (isFailingCheckStatus(issue.prCheckStatus)) {
                 await this.routeFailedIssue(issue);
                 continue;
             }
@@ -86,12 +118,15 @@ export class IdleIssueReconciler {
         for (const issue of this.db.listBlockedDelegatedIssues()) {
             const unresolved = this.db.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
             if (unresolved === 0) {
-                this.db.upsertIssue({
+                this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
                     projectId: issue.projectId,
                     linearIssueId: issue.linearIssueId,
-                    pendingRunType: "implementation",
+                    eventType: "delegated",
+                    dedupeKey: `delegated:${issue.linearIssueId}`,
                 });
-                this.deps.enqueueIssue(issue.projectId, issue.linearIssueId);
+                if (this.db.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
+                    this.deps.enqueueIssue(issue.projectId, issue.linearIssueId);
+                }
             }
         }
     }
@@ -100,18 +135,16 @@ export class IdleIssueReconciler {
             return;
         }
         this.logger.info({ issueKey: issue.issueKey, from: issue.factoryState, to: newState, pendingRunType: options?.pendingRunType }, "Reconciliation: advancing idle issue");
-        const resetQueueLabel = newState === "awaiting_queue" || issue.factoryState === "awaiting_queue";
         this.db.upsertIssue({
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             factoryState: newState,
-            ...(options?.pendingRunType ? { pendingRunType: options.pendingRunType } : {}),
-            ...(options?.pendingRunType
+            ...((options?.pendingRunType || newState === "awaiting_queue" || newState === "delegated" || newState === "done")
                 ? {
-                    pendingRunContextJson: options.pendingRunContext ? JSON.stringify(options.pendingRunContext) : null,
+                    pendingRunType: null,
+                    pendingRunContextJson: null,
                 }
                 : {}),
-            ...(resetQueueLabel ? { queueLabelApplied: false } : {}),
             ...(options?.clearFailureProvenance
                 ? {
                     lastGitHubFailureSource: null,
@@ -131,6 +164,9 @@ export class IdleIssueReconciler {
         if (branchOwner) {
             this.db.setBranchOwner(issue.projectId, issue.linearIssueId, branchOwner);
         }
+        if (options?.pendingRunType) {
+            this.appendWakeEvent(issue, options.pendingRunType, options.pendingRunContext, "idle_reconciliation");
+        }
         this.feed?.publish({
             level: "info",
             kind: "stage",
@@ -140,57 +176,52 @@ export class IdleIssueReconciler {
             status: "reconciled",
             summary: `Reconciliation: ${issue.factoryState} \u2192 ${newState}`,
         });
-        if (newState === "awaiting_queue" && issue.factoryState !== "awaiting_queue") {
-            void this.deps.requestMergeQueueAdmission(issue, issue.projectId);
-        }
-        if (options?.pendingRunType) {
+        if (options?.pendingRunType && this.db.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
             this.deps.enqueueIssue(issue.projectId, issue.linearIssueId);
         }
     }
-    async routeFailedIssue(issue) {
-        if (issue.lastGitHubFailureSource === "queue_eviction") {
-            const pendingRunContext = buildFailureContext(issue);
-            if (isDuplicateRepairAttempt(issue, pendingRunContext)) {
-                this.advanceIdleIssue(issue, "repairing_queue");
-            }
-            else {
-                this.advanceIdleIssue(issue, "repairing_queue", {
-                    pendingRunType: "queue_repair",
-                    ...(pendingRunContext ? { pendingRunContext } : {}),
-                });
-            }
-            return;
+    appendWakeEvent(issue, runType, context, dedupeScope = "idle_reconciliation") {
+        let eventType;
+        let dedupeKey;
+        if (runType === "queue_repair") {
+            eventType = "merge_steward_incident";
+            dedupeKey = `${dedupeScope}:queue_repair:${issue.linearIssueId}:${issue.lastGitHubFailureSignature ?? issue.prHeadSha ?? issue.lastGitHubFailureHeadSha ?? "unknown"}`;
         }
-        if (issue.lastGitHubFailureSource === "branch_ci") {
-            const pendingRunContext = buildFailureContext(issue);
-            if (isDuplicateRepairAttempt(issue, pendingRunContext)) {
-                this.advanceIdleIssue(issue, "repairing_ci");
-            }
-            else {
-                this.advanceIdleIssue(issue, "repairing_ci", {
-                    pendingRunType: "ci_repair",
-                    ...(pendingRunContext ? { pendingRunContext } : {}),
-                });
-            }
-            return;
+        else if (runType === "ci_repair") {
+            eventType = "settled_red_ci";
+            dedupeKey = `${dedupeScope}:ci_repair:${issue.linearIssueId}:${issue.lastGitHubFailureSignature ?? issue.prHeadSha ?? issue.lastGitHubFailureHeadSha ?? "unknown"}`;
         }
-        if (issue.factoryState === "awaiting_queue") {
-            const inferProject = this.config.projects.find((p) => p.id === issue.projectId);
-            const inferProtocol = resolveMergeQueueProtocol(inferProject);
-            let inferred = "branch_ci";
-            const probeSha = issue.lastGitHubFailureHeadSha ?? issue.lastGitHubCiSnapshotHeadSha;
-            if (inferProject?.github?.repoFullName && issue.prNumber && probeSha) {
-                try {
-                    const { stdout } = await execCommand("gh", [
-                        "api",
-                        `repos/${inferProject.github.repoFullName}/commits/${probeSha}/check-runs`,
-                        "--jq", `.check_runs[] | select(.name == "${inferProtocol.evictionCheckName}" and .conclusion == "failure") | .name`,
-                    ], { timeoutMs: 10_000 });
-                    if (stdout.trim().length > 0)
-                        inferred = "queue_eviction";
-                }
-                catch { /* best effort */ }
-            }
+        else if (runType === "review_fix") {
+            eventType = "review_changes_requested";
+            dedupeKey = `${dedupeScope}:review_fix:${issue.linearIssueId}:${issue.prHeadSha ?? "unknown"}`;
+        }
+        else {
+            eventType = "delegated";
+            dedupeKey = `${dedupeScope}:implementation:${issue.linearIssueId}`;
+        }
+        this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            eventType,
+            ...(context ? { eventJson: JSON.stringify(context) } : {}),
+            dedupeKey,
+        });
+    }
+    async routeFailedIssue(issue) {
+        issue = await this.refreshMissingFailureProvenance(issue);
+        issue = await this.reclassifyStaleBranchFailure(issue);
+        const latestRun = this.db.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
+        const ignoreDuplicateAttempt = latestRun?.status === "failed"
+            && latestRun.failureReason === "Codex turn was interrupted";
+        const reactiveIntent = deriveIssueSessionReactiveIntent({
+            prNumber: issue.prNumber,
+            prState: issue.prState,
+            prReviewState: issue.prReviewState,
+            prCheckStatus: issue.prCheckStatus,
+            latestFailureSource: issue.lastGitHubFailureSource,
+        });
+        if (!reactiveIntent && issue.factoryState === "awaiting_queue") {
+            const inferred = await this.inferFailureSourceFromGitHub(issue) ?? "branch_ci";
             const inferRunType = inferred === "queue_eviction" ? "queue_repair" : "ci_repair";
             const inferState = inferred === "queue_eviction" ? "repairing_queue" : "repairing_ci";
             this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, inferred }, "Inferred failure provenance for awaiting_queue issue");
@@ -201,17 +232,126 @@ export class IdleIssueReconciler {
             });
             return;
         }
+        if (!reactiveIntent) {
+            return;
+        }
         const pendingRunContext = buildFailureContext(issue);
-        if (isDuplicateRepairAttempt(issue, pendingRunContext)) {
-            this.advanceIdleIssue(issue, "repairing_ci");
+        const duplicateRepair = reactiveIntent.runType !== "review_fix"
+            && !ignoreDuplicateAttempt
+            && isDuplicateRepairAttempt(issue, pendingRunContext);
+        if (duplicateRepair) {
+            this.advanceIdleIssue(issue, reactiveIntent.compatibilityFactoryState);
         }
         else {
-            this.advanceIdleIssue(issue, "repairing_ci", {
-                pendingRunType: "ci_repair",
+            this.advanceIdleIssue(issue, reactiveIntent.compatibilityFactoryState, {
+                pendingRunType: reactiveIntent.runType,
                 ...(pendingRunContext ? { pendingRunContext } : {}),
             });
         }
     }
+    async refreshMissingFailureProvenance(issue) {
+        if (issue.lastGitHubFailureSource || !issue.prNumber || !isFailingCheckStatus(issue.prCheckStatus)) {
+            return issue;
+        }
+        const inferred = await this.inferFailureSourceFromGitHub(issue);
+        if (!inferred)
+            return issue;
+        const protocol = this.getIssueProtocol(issue);
+        const failureHeadSha = issue.lastGitHubFailureHeadSha ?? issue.lastGitHubCiSnapshotHeadSha ?? issue.prHeadSha ?? null;
+        const checkName = inferred === "queue_eviction"
+            ? issue.lastGitHubFailureCheckName ?? protocol.evictionCheckName
+            : issue.lastGitHubFailureCheckName ?? null;
+        const failureSignature = issue.lastGitHubFailureSignature
+            ?? (inferred === "queue_eviction" && failureHeadSha && checkName
+                ? ["queue_eviction", failureHeadSha, checkName].join("::")
+                : null);
+        this.db.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            lastGitHubFailureSource: inferred,
+            ...(failureHeadSha ? { lastGitHubFailureHeadSha: failureHeadSha } : {}),
+            ...(checkName ? { lastGitHubFailureCheckName: checkName } : {}),
+            ...(failureSignature ? { lastGitHubFailureSignature: failureSignature } : {}),
+        });
+        const refreshed = this.db.getIssue(issue.projectId, issue.linearIssueId);
+        if (!refreshed)
+            return issue;
+        this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, inferred, factoryState: issue.factoryState }, "Recovered missing failure provenance from GitHub state");
+        return refreshed;
+    }
+    async reclassifyStaleBranchFailure(issue) {
+        const downstreamOwned = issue.factoryState === "awaiting_queue" || issue.prReviewState === "approved";
+        if (issue.lastGitHubFailureSource !== "branch_ci" || !downstreamOwned) {
+            return issue;
+        }
+        const inferred = await this.inferFailureSourceFromGitHub(issue);
+        if (inferred !== "queue_eviction") {
+            return issue;
+        }
+        const protocol = this.getIssueProtocol(issue);
+        const failureHeadSha = issue.lastGitHubFailureHeadSha ?? issue.lastGitHubCiSnapshotHeadSha ?? issue.prHeadSha ?? null;
+        const checkName = issue.lastGitHubFailureCheckName ?? protocol.evictionCheckName;
+        const failureSignature = issue.lastGitHubFailureSignature
+            ?? (failureHeadSha && checkName ? ["queue_eviction", failureHeadSha, checkName].join("::") : null);
+        this.db.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            lastGitHubFailureSource: "queue_eviction",
+            ...(failureHeadSha ? { lastGitHubFailureHeadSha: failureHeadSha } : {}),
+            ...(checkName ? { lastGitHubFailureCheckName: checkName } : {}),
+            ...(failureSignature ? { lastGitHubFailureSignature: failureSignature } : {}),
+        });
+        const refreshed = this.db.getIssue(issue.projectId, issue.linearIssueId);
+        if (!refreshed)
+            return issue;
+        this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber }, "Reclassified stale branch failure as queue repair from GitHub state");
+        return refreshed;
+    }
+    async inferFailureSourceFromGitHub(issue) {
+        const project = this.config.projects.find((candidate) => candidate.id === issue.projectId);
+        const repoFullName = project?.github?.repoFullName;
+        const probeSha = issue.lastGitHubFailureHeadSha ?? issue.lastGitHubCiSnapshotHeadSha ?? issue.prHeadSha;
+        if (!repoFullName || !issue.prNumber || !probeSha)
+            return undefined;
+        const protocol = this.getIssueProtocol(issue);
+        try {
+            const { stdout } = await execCommand("gh", [
+                "api",
+                `repos/${repoFullName}/commits/${probeSha}/check-runs`,
+                "--jq", `.check_runs[] | select(.name == "${protocol.evictionCheckName}" and .conclusion == "failure") | .name`,
+            ], { timeoutMs: 10_000 });
+            if (stdout.trim().length > 0)
+                return "queue_eviction";
+        }
+        catch {
+            // Fall through to a PR-level probe. Preemptive conflicts can require
+            // queue repair even when no merge-steward eviction check-run exists yet.
+        }
+        try {
+            const { stdout } = await execCommand("gh", [
+                "pr", "view", String(issue.prNumber),
+                "--repo", repoFullName,
+                "--json", "mergeable,mergeStateStatus,labels",
+            ], { timeoutMs: 10_000 });
+            const pr = JSON.parse(stdout);
+            const downstreamOwned = issue.factoryState === "awaiting_queue" || issue.prReviewState === "approved";
+            if ((pr.mergeable === "CONFLICTING" || pr.mergeStateStatus === "DIRTY")
+                && downstreamOwned) {
+                return "queue_eviction";
+            }
+            if (pr.mergeable === "CONFLICTING" || pr.mergeStateStatus === "DIRTY") {
+                return undefined;
+            }
+        }
+        catch {
+            return issue.factoryState === "awaiting_queue" || issue.prReviewState === "approved" ? "branch_ci" : undefined;
+        }
+        return "branch_ci";
+    }
+    getIssueProtocol(issue) {
+        const project = this.config.projects.find((candidate) => candidate.id === issue.projectId);
+        return resolveMergeQueueProtocol(project);
+    }
     async reconcileFromGitHub(issue) {
         const project = this.config.projects.find((p) => p.id === issue.projectId);
         if (!project?.github?.repoFullName || !issue.prNumber)
@@ -220,24 +360,61 @@ export class IdleIssueReconciler {
             const { stdout } = await execCommand("gh", [
                 "pr", "view", String(issue.prNumber),
                 "--repo", project.github.repoFullName,
-                "--json", "state,reviewDecision,mergeable,mergeStateStatus",
+                "--json", "headRefOid,state,reviewDecision,mergeable,mergeStateStatus,statusCheckRollup",
             ], { timeoutMs: 10_000 });
             const pr = JSON.parse(stdout);
+            const gateCheckNames = getGateCheckNames(project);
+            const gateCheckStatus = deriveGateCheckStatusFromRollup(pr.statusCheckRollup, gateCheckNames);
+            this.db.upsertIssue({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
+                ...(pr.state === "OPEN" ? { prState: "open" } : {}),
+                ...(pr.reviewDecision === "APPROVED"
+                    ? { prReviewState: "approved" }
+                    : pr.reviewDecision === "CHANGES_REQUESTED"
+                        ? { prReviewState: "changes_requested" }
+                        : {}),
+                ...(gateCheckStatus ? { prCheckStatus: gateCheckStatus } : {}),
+                ...(pr.headRefOid && gateCheckStatus
+                    ? {
+                        lastGitHubCiSnapshotHeadSha: pr.headRefOid,
+                        lastGitHubCiSnapshotGateCheckName: gateCheckNames[0] ?? "verify",
+                        lastGitHubCiSnapshotGateCheckStatus: gateCheckStatus,
+                        lastGitHubCiSnapshotSettledAt: gateCheckStatus === "pending" ? null : new Date().toISOString(),
+                    }
+                    : {}),
+            });
             if (pr.state === "MERGED") {
                 this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "merged" });
                 this.advanceIdleIssue(issue, "done", { clearFailureProvenance: true });
                 return;
             }
-            if (pr.reviewDecision === "APPROVED") {
-                this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prReviewState: "approved" });
-                this.advanceIdleIssue(issue, "awaiting_queue", { clearFailureProvenance: true });
+            if (pr.state === "CLOSED") {
+                this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber }, "Reconciliation: PR was closed, re-delegating for implementation");
+                this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "closed" });
+                this.advanceIdleIssue(issue, "delegated", {
+                    pendingRunType: "implementation",
+                    clearFailureProvenance: true,
+                });
                 return;
             }
-            // Merge conflict detected — dispatch a repair run to rebase the branch.
-            if (pr.mergeable === "CONFLICTING" || pr.mergeStateStatus === "DIRTY") {
-                this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, mergeable: pr.mergeable }, "Reconciliation: PR has merge conflicts, dispatching rebase");
-                this.advanceIdleIssue(issue, "repairing_queue", {
-                    pendingRunType: "queue_repair",
+            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;
+            const reactiveIntent = deriveIssueSessionReactiveIntent({
+                prNumber: refreshedIssue.prNumber,
+                prState: refreshedIssue.prState,
+                prReviewState: refreshedIssue.prReviewState,
+                prCheckStatus: refreshedIssue.prCheckStatus,
+                latestFailureSource: refreshedIssue.lastGitHubFailureSource,
+                mergeConflictDetected,
+                downstreamOwned,
+            });
+            if (reactiveIntent?.runType === "queue_repair" && mergeConflictDetected) {
+                this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, mergeable: pr.mergeable }, "Reconciliation: PR needs queue repair from fresh GitHub truth");
+                this.advanceIdleIssue(issue, reactiveIntent.compatibilityFactoryState, {
+                    pendingRunType: reactiveIntent.runType,
                     pendingRunContext: {
                         source: "idle_reconciliation",
                         failureReason: "merge_conflict_detected",
@@ -249,14 +426,38 @@ export class IdleIssueReconciler {
                     kind: "github",
                     issueKey: issue.issueKey,
                     projectId: issue.projectId,
-                    stage: "repairing_queue",
+                    stage: reactiveIntent.compatibilityFactoryState,
                     status: "conflict_detected",
                     summary: `PR #${issue.prNumber} has merge conflicts with main, dispatching rebase`,
                 });
+                return;
+            }
+            if (pr.reviewDecision === "APPROVED") {
+                this.db.upsertIssue({
+                    projectId: issue.projectId,
+                    linearIssueId: issue.linearIssueId,
+                    prReviewState: "approved",
+                });
+                if (issue.factoryState !== "awaiting_queue" || hasFailureProvenance(issue)) {
+                    this.advanceIdleIssue(issue, "awaiting_queue", {
+                        ...(hasFailureProvenance(issue) ? { clearFailureProvenance: true } : {}),
+                    });
+                }
+                return;
+            }
+            if (mergeConflictDetected) {
+                this.logger.debug({ issueKey: issue.issueKey, prNumber: issue.prNumber, mergeable: pr.mergeable, mergeStateStatus: pr.mergeStateStatus }, "Reconciliation: PR is dirty but not yet queue-admitted; leaving PatchRelay in review state");
             }
         }
         catch (error) {
             this.logger.debug({ issueKey: issue.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to query GitHub PR state during reconciliation");
+            if (issue.prReviewState === "approved") {
+                if (issue.factoryState !== "awaiting_queue" || hasFailureProvenance(issue)) {
+                    this.advanceIdleIssue(issue, "awaiting_queue", {
+                        ...(hasFailureProvenance(issue) ? { clearFailureProvenance: true } : {}),
+                    });
+                }
+            }
         }
     }
 }