patchrelay 0.30.1 → 0.32.0

package/dist/run-orchestrator.js

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { ACTIVE_RUN_STATES, TERMINAL_STATES } from "./factory-state.js";
+import { parseGitHubFailureContext } from "./github-failure-context.js";
 import { buildHookEnv, runProjectHook } from "./hook-runner.js";
 import { buildAgentSessionPlanForIssue, } from "./agent-session-plan.js";
 import { buildStageReport, countEventMethods, extractTurnId, resolveRunCompletionStatus, summarizeCurrentThread, } from "./run-reporting.js";
@@ -56,9 +57,17 @@ function buildRunPrompt(issue, runType, repoPath, context) {
     }
     // Add run-type-specific context for reactive runs
     switch (runType) {
-        case "ci_repair":
-            lines.push("## CI Repair", "", "A CI check has failed on your PR. Fix the failure and push.", context?.checkName ? `Failed check: ${String(context.checkName)}` : "", context?.checkUrl ? `Check URL: ${String(context.checkUrl)}` : "", "", "Read the CI failure logs, fix the code issue, run verification, commit and push.", "Do not change test expectations unless the test is genuinely wrong.", "");
+        case "ci_repair": {
+            const snapshot = context?.ciSnapshot && typeof context.ciSnapshot === "object"
+                ? context.ciSnapshot
+                : undefined;
+            lines.push("## CI Repair", "", "A full CI iteration has settled failed on your PR. Diagnose the whole snapshot, fix the root cause and directly related fallout, then push to the same PR branch.", snapshot?.gateCheckName ? `Gate check: ${String(snapshot.gateCheckName)}` : "", snapshot?.gateCheckStatus ? `Gate status: ${String(snapshot.gateCheckStatus)}` : "", snapshot?.settledAt ? `Settled at: ${String(snapshot.settledAt)}` : "", context?.failureHeadSha ? `Failing head SHA: ${String(context.failureHeadSha)}` : "", context?.checkName ? `Failed check: ${String(context.checkName)}` : "", context?.jobName && context?.jobName !== context?.checkName ? `Failed job: ${String(context.jobName)}` : "", context?.stepName ? `Failed step: ${String(context.stepName)}` : "", context?.summary ? `Failure summary: ${String(context.summary)}` : "", Array.isArray(snapshot?.failedChecks) && snapshot.failedChecks.length > 0
+                ? `All failed checks in settled snapshot:\n${snapshot.failedChecks.map((entry) => `- ${String(entry.name ?? "unknown")}${entry.summary ? `: ${String(entry.summary)}` : ""}`).join("\n")}`
+                : "", context?.checkUrl ? `Check URL: ${String(context.checkUrl)}` : "", Array.isArray(context?.annotations) && context.annotations.length > 0
+                ? `Annotations:\n${context.annotations.map((entry) => `- ${String(entry)}`).join("\n")}`
+                : "", "", "Read the latest CI logs, consider the broader PR context, fix the likely root cause and any directly related fallout in one pass, run verification, commit and push.", "Do not open a new PR. Keep working on the existing branch until CI goes green or the situation is clearly stuck.", "Do not change test expectations unless the test is genuinely wrong.", "");
             break;
+        }
         case "review_fix":
             lines.push("## Review Changes Requested", "", "A reviewer has requested changes on your PR. Address the feedback and push.", context?.reviewerName ? `Reviewer: ${String(context.reviewerName)}` : "", context?.reviewBody ? `\n## Review comment\n\n${String(context.reviewBody)}` : "", "", "Steps:", "1. Read the review feedback and PR comments (`gh pr view --comments`).", "2. Check the current diff (`git diff origin/main`) — a prior rebase may have already resolved some concerns (e.g., scope-bundling from stale commits).", "3. For each review point: if already resolved, note why. If not, fix it.", "4. Run verification, commit and push.", "5. If you believe all concerns are resolved, request a re-review: `gh pr edit <PR#> --add-reviewer <reviewer>`.", "   Do NOT just post a comment saying \"resolved\" — the reviewer must re-review to dismiss the CHANGES_REQUESTED state.", "");
             break;
@@ -155,6 +164,10 @@ export class RunOrchestrator {
                 runType,
                 promptText: prompt,
             });
+            const failureHeadSha = typeof context?.failureHeadSha === "string"
+                ? context.failureHeadSha
+                : typeof context?.headSha === "string" ? context.headSha : undefined;
+            const failureSignature = typeof context?.failureSignature === "string" ? context.failureSignature : undefined;
             this.db.upsertIssue({
                 projectId: item.projectId,
                 linearIssueId: item.issueId,
@@ -168,6 +181,12 @@ export class RunOrchestrator {
                         : runType === "review_fix" ? "changes_requested"
                             : runType === "queue_repair" ? "repairing_queue"
                                 : "implementing",
+                ...((runType === "ci_repair" || runType === "queue_repair") && failureSignature
+                    ? {
+                        lastAttemptedFailureSignature: failureSignature,
+                        lastAttemptedFailureHeadSha: failureHeadSha ?? null,
+                    }
+                    : {}),
             });
             return created;
         });
@@ -402,6 +421,26 @@ export class RunOrchestrator {
         const report = buildStageReport(run, trackedIssue, thread, countEventMethods(this.db.listThreadEvents(run.id)));
         // Determine post-run state based on current PR metadata.
         const freshIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
+        const verifiedRepairError = await this.verifyReactiveRunAdvancedBranch(run, freshIssue);
+        if (verifiedRepairError) {
+            const holdState = resolveRecoverablePostRunState(freshIssue) ?? "failed";
+            this.failRunAndClear(run, verifiedRepairError, holdState);
+            const heldIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? freshIssue;
+            this.feed?.publish({
+                level: "warn",
+                kind: "turn",
+                issueKey: freshIssue.issueKey,
+                projectId: run.projectId,
+                stage: run.runType,
+                status: "branch_not_advanced",
+                summary: verifiedRepairError,
+            });
+            void this.emitLinearActivity(heldIssue, buildRunFailureActivity(run.runType, verifiedRepairError));
+            void this.syncLinearSession(heldIssue, { activeRunType: run.runType });
+            this.progressThrottle.delete(run.id);
+            this.activeThreadId = undefined;
+            return;
+        }
         const postRunState = resolvePostRunState(freshIssue);
         this.db.transaction(() => {
             this.db.finishRun(run.id, {
@@ -419,10 +458,15 @@ export class RunOrchestrator {
                 ...(postRunState === "awaiting_queue" || postRunState === "done"
                     ? {
                         lastGitHubFailureSource: null,
+                        lastGitHubFailureHeadSha: null,
+                        lastGitHubFailureSignature: null,
                         lastGitHubFailureCheckName: null,
                         lastGitHubFailureCheckUrl: null,
+                        lastGitHubFailureContextJson: null,
                         lastGitHubFailureAt: null,
                         lastQueueIncidentJson: null,
+                        lastAttemptedFailureHeadSha: null,
+                        lastAttemptedFailureSignature: null,
                     }
                     : {}),
             });
@@ -534,8 +578,11 @@ export class RunOrchestrator {
             // Checks failed + idle — route based on durable GitHub failure provenance.
             if (issue.prCheckStatus === "failed") {
                 if (issue.lastGitHubFailureSource === "queue_eviction") {
-                    if (issue.factoryState !== "repairing_queue") {
-                        const pendingRunContext = buildFailureContext(issue);
+                    const pendingRunContext = buildFailureContext(issue);
+                    if (isDuplicateRepairAttempt(issue, pendingRunContext)) {
+                        this.advanceIdleIssue(issue, "repairing_queue");
+                    }
+                    else {
                         this.advanceIdleIssue(issue, "repairing_queue", {
                             pendingRunType: "queue_repair",
                             ...(pendingRunContext ? { pendingRunContext } : {}),
@@ -544,8 +591,11 @@ export class RunOrchestrator {
                     continue;
                 }
                 if (issue.lastGitHubFailureSource === "branch_ci") {
-                    if (issue.factoryState !== "repairing_ci") {
-                        const pendingRunContext = buildFailureContext(issue);
+                    const pendingRunContext = buildFailureContext(issue);
+                    if (isDuplicateRepairAttempt(issue, pendingRunContext)) {
+                        this.advanceIdleIssue(issue, "repairing_ci");
+                    }
+                    else {
                         this.advanceIdleIssue(issue, "repairing_ci", {
                             pendingRunType: "ci_repair",
                             ...(pendingRunContext ? { pendingRunContext } : {}),
@@ -566,8 +616,11 @@ export class RunOrchestrator {
                     });
                     continue;
                 }
-                if (issue.factoryState !== "repairing_ci") {
-                    const pendingRunContext = buildFailureContext(issue);
+                const pendingRunContext = buildFailureContext(issue);
+                if (isDuplicateRepairAttempt(issue, pendingRunContext)) {
+                    this.advanceIdleIssue(issue, "repairing_ci");
+                }
+                else {
                     this.advanceIdleIssue(issue, "repairing_ci", {
                         pendingRunType: "ci_repair",
                         ...(pendingRunContext ? { pendingRunContext } : {}),
@@ -606,6 +659,9 @@ export class RunOrchestrator {
         }
     }
     advanceIdleIssue(issue, newState, options) {
+        if (issue.factoryState === newState && !options?.pendingRunType && !options?.clearFailureProvenance) {
+            return;
+        }
         this.logger.info({ issueKey: issue.issueKey, from: issue.factoryState, to: newState, pendingRunType: options?.pendingRunType }, "Reconciliation: advancing idle issue");
         this.db.upsertIssue({
             projectId: issue.projectId,
@@ -620,10 +676,15 @@ export class RunOrchestrator {
             ...(options?.clearFailureProvenance
                 ? {
                     lastGitHubFailureSource: null,
+                    lastGitHubFailureHeadSha: null,
+                    lastGitHubFailureSignature: null,
                     lastGitHubFailureCheckName: null,
                     lastGitHubFailureCheckUrl: null,
+                    lastGitHubFailureContextJson: null,
                     lastGitHubFailureAt: null,
                     lastQueueIncidentJson: null,
+                    lastAttemptedFailureHeadSha: null,
+                    lastAttemptedFailureSignature: null,
                 }
                 : {}),
         });
@@ -790,7 +851,7 @@ export class RunOrchestrator {
             else if (run.runType === "review_fix" && issue.reviewFixAttempts > 0) {
                 this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, reviewFixAttempts: issue.reviewFixAttempts - 1 });
             }
-            const recoveredState = resolvePostRunState(this.db.getIssue(run.projectId, run.linearIssueId) ?? issue);
+            const recoveredState = resolveRecoverablePostRunState(this.db.getIssue(run.projectId, run.linearIssueId) ?? issue);
             this.failRunAndClear(run, "Codex turn was interrupted", recoveredState);
             const failedIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
             if (recoveredState) {
@@ -815,6 +876,21 @@ export class RunOrchestrator {
             const trackedIssue = this.db.issueToTrackedIssue(issue);
             const report = buildStageReport(run, trackedIssue, thread, countEventMethods(this.db.listThreadEvents(run.id)));
             const freshIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
+            const verifiedRepairError = await this.verifyReactiveRunAdvancedBranch(run, freshIssue);
+            if (verifiedRepairError) {
+                const holdState = resolveRecoverablePostRunState(freshIssue) ?? "failed";
+                this.failRunAndClear(run, verifiedRepairError, holdState);
+                this.feed?.publish({
+                    level: "warn",
+                    kind: "turn",
+                    issueKey: issue.issueKey,
+                    projectId: run.projectId,
+                    stage: run.runType,
+                    status: "branch_not_advanced",
+                    summary: verifiedRepairError,
+                });
+                return;
+            }
             const postRunState = resolvePostRunState(freshIssue);
             this.db.transaction(() => {
                 this.db.finishRun(run.id, {
@@ -832,10 +908,15 @@ export class RunOrchestrator {
                     ...(postRunState === "awaiting_queue" || postRunState === "done"
                         ? {
                             lastGitHubFailureSource: null,
+                            lastGitHubFailureHeadSha: null,
+                            lastGitHubFailureSignature: null,
                             lastGitHubFailureCheckName: null,
                             lastGitHubFailureCheckUrl: null,
+                            lastGitHubFailureContextJson: null,
                             lastGitHubFailureAt: null,
                             lastQueueIncidentJson: null,
+                            lastAttemptedFailureHeadSha: null,
+                            lastAttemptedFailureSignature: null,
                         }
                         : {}),
                 });
@@ -908,6 +989,41 @@ export class RunOrchestrator {
             });
         });
     }
+    async verifyReactiveRunAdvancedBranch(run, issue) {
+        if (run.runType !== "ci_repair" && run.runType !== "queue_repair") {
+            return undefined;
+        }
+        if (!issue.prNumber || issue.prState !== "open" || !issue.lastGitHubFailureHeadSha) {
+            return undefined;
+        }
+        const project = this.config.projects.find((entry) => entry.id === run.projectId);
+        if (!project?.github?.repoFullName) {
+            return undefined;
+        }
+        try {
+            const { stdout, exitCode } = await execCommand("gh", [
+                "pr", "view", String(issue.prNumber),
+                "--repo", project.github.repoFullName,
+                "--json", "headRefOid,state",
+            ], { timeoutMs: 10_000 });
+            if (exitCode !== 0)
+                return undefined;
+            const pr = JSON.parse(stdout);
+            if (pr.state?.toUpperCase() !== "OPEN")
+                return undefined;
+            if (!pr.headRefOid || pr.headRefOid !== issue.lastGitHubFailureHeadSha)
+                return undefined;
+            return `Repair finished but PR #${issue.prNumber} is still on failing head ${issue.lastGitHubFailureHeadSha.slice(0, 8)}`;
+        }
+        catch (error) {
+            this.logger.debug({
+                issueKey: issue.issueKey,
+                prNumber: issue.prNumber,
+                error: error instanceof Error ? error.message : String(error),
+            }, "Failed to verify PR head advancement after repair");
+            return undefined;
+        }
+    }
     async emitLinearActivity(issue, content, options) {
         if (!issue.agentSessionId)
             return;
@@ -1025,23 +1141,59 @@ function resolvePostRunState(issue) {
     }
     return undefined;
 }
+function resolveRecoverablePostRunState(issue) {
+    if (!issue.prNumber) {
+        return resolvePostRunState(issue);
+    }
+    if (issue.prState === "merged")
+        return "done";
+    if (issue.prState === "open") {
+        if (issue.lastGitHubFailureSource === "queue_eviction")
+            return "repairing_queue";
+        if (issue.prCheckStatus === "failed" || issue.lastGitHubFailureSource === "branch_ci")
+            return "repairing_ci";
+        if (issue.prReviewState === "changes_requested")
+            return "changes_requested";
+        if (issue.prReviewState === "approved")
+            return "awaiting_queue";
+        return "pr_open";
+    }
+    return resolvePostRunState(issue);
+}
 function buildFailureContext(issue) {
+    const storedFailureContext = parseGitHubFailureContext(issue.lastGitHubFailureContextJson);
     const queueRepairContext = issue.lastQueueIncidentJson
         ? parseStoredQueueRepairContext(issue.lastQueueIncidentJson)
         : undefined;
     if (!queueRepairContext
         && !issue.lastGitHubFailureSource
+        && !issue.lastGitHubFailureHeadSha
+        && !issue.lastGitHubFailureSignature
         && !issue.lastGitHubFailureCheckName
-        && !issue.lastGitHubFailureCheckUrl) {
+        && !issue.lastGitHubFailureCheckUrl
+        && !storedFailureContext) {
         return undefined;
     }
     return {
         ...(issue.lastGitHubFailureSource ? { failureReason: issue.lastGitHubFailureSource } : {}),
+        ...(issue.lastGitHubFailureHeadSha ? { failureHeadSha: issue.lastGitHubFailureHeadSha } : {}),
+        ...(issue.lastGitHubFailureSignature ? { failureSignature: issue.lastGitHubFailureSignature } : {}),
         ...(issue.lastGitHubFailureCheckName ? { checkName: issue.lastGitHubFailureCheckName } : {}),
         ...(issue.lastGitHubFailureCheckUrl ? { checkUrl: issue.lastGitHubFailureCheckUrl } : {}),
+        ...(storedFailureContext ? storedFailureContext : {}),
         ...(queueRepairContext ? queueRepairContext : {}),
     };
 }
+function isDuplicateRepairAttempt(issue, context) {
+    const signature = typeof context?.failureSignature === "string" ? context.failureSignature : undefined;
+    const headSha = typeof context?.failureHeadSha === "string"
+        ? context.failureHeadSha
+        : typeof context?.headSha === "string" ? context.headSha : undefined;
+    if (!signature)
+        return false;
+    return issue.lastAttemptedFailureSignature === signature
+        && (headSha === undefined || issue.lastAttemptedFailureHeadSha === headSha);
+}
 function appendQueueRepairContext(lines, context) {
     const incidentTitle = typeof context?.incidentTitle === "string" ? context.incidentTitle.trim() : "";
     const incidentSummary = typeof context?.incidentSummary === "string" ? context.incidentSummary.trim() : "";

package/dist/service.js

@@ -1,4 +1,5 @@
 import { resolveGitHubAppCredentials, createGitHubAppTokenManager, ensureGhWrapper, } from "./github-app-token.js";
+import { parseGitHubFailureContext, summarizeGitHubFailureContext } from "./github-failure-context.js";
 import { GitHubWebhookHandler } from "./github-webhook-handler.js";
 import { IssueQueryService } from "./issue-query-service.js";
 import { DatabaseBackedLinearClientProvider } from "./linear-client.js";
@@ -216,6 +217,10 @@ export class PatchRelayService {
           i.current_linear_state, i.factory_state, i.updated_at,
           i.pending_run_type,
           i.pr_number, i.pr_review_state, i.pr_check_status,
+          i.last_github_failure_source,
+          i.last_github_failure_head_sha,
+          i.last_github_failure_check_name,
+          i.last_github_failure_context_json,
           active_run.run_type AS active_run_type,
           latest_run.run_type AS latest_run_type,
           latest_run.status AS latest_run_status,
@@ -257,13 +262,22 @@ export class PatchRelayService {
         ORDER BY i.updated_at DESC, i.issue_key ASC`)
             .all();
         return rows.map((row) => {
+            const failureContext = parseGitHubFailureContext(typeof row.last_github_failure_context_json === "string" ? row.last_github_failure_context_json : undefined);
             const statusNote = extractStatusNote(typeof row.latest_run_summary_json === "string" ? row.latest_run_summary_json : undefined, typeof row.latest_run_report_json === "string" ? row.latest_run_report_json : undefined);
             const blockedByKeys = parseStringArray(typeof row.blocked_by_keys_json === "string" ? row.blocked_by_keys_json : undefined);
             const blockedByCount = Number(row.blocked_by_count ?? 0);
             const readyForExecution = row.pending_run_type !== null && row.pending_run_type !== undefined && row.active_run_type === null && blockedByCount === 0;
+            const failureSummary = summarizeGitHubFailureContext(failureContext);
+            const derivedStatusNote = blockedByCount > 0
+                ? `Blocked by ${blockedByKeys.join(", ")}`
+                : failureSummary && (row.factory_state === "repairing_ci"
+                    || row.factory_state === "repairing_queue"
+                    || row.factory_state === "failed")
+                    ? failureSummary
+                    : statusNote;
             const statusNoteWithBlockers = blockedByCount > 0
                 ? `Blocked by ${blockedByKeys.join(", ")}`
-                : statusNote;
+                : derivedStatusNote;
             return {
                 ...(row.issue_key !== null ? { issueKey: String(row.issue_key) } : {}),
                 ...(row.title !== null ? { title: String(row.title) } : {}),
@@ -281,6 +295,11 @@ export class PatchRelayService {
                 ...(row.pr_number !== null ? { prNumber: Number(row.pr_number) } : {}),
                 ...(row.pr_review_state !== null ? { prReviewState: String(row.pr_review_state) } : {}),
                 ...(row.pr_check_status !== null ? { prCheckStatus: String(row.pr_check_status) } : {}),
+                ...(row.last_github_failure_source !== null ? { latestFailureSource: String(row.last_github_failure_source) } : {}),
+                ...(row.last_github_failure_head_sha !== null ? { latestFailureHeadSha: String(row.last_github_failure_head_sha) } : {}),
+                ...(row.last_github_failure_check_name !== null ? { latestFailureCheckName: String(row.last_github_failure_check_name) } : {}),
+                ...(failureContext?.stepName ? { latestFailureStepName: failureContext.stepName } : {}),
+                ...(failureContext?.summary ? { latestFailureSummary: failureContext.summary } : {}),
                 updatedAt: String(row.updated_at),
             };
         });
@@ -417,7 +436,7 @@ export class PatchRelayService {
         // Infer run type from current state instead of always resetting to implementation
         let runType = "implementation";
         let factoryState = "delegated";
-        if (issue.prNumber && issue.prCheckStatus === "failed") {
+        if (issue.prNumber && (issue.prCheckStatus === "failed" || issue.prCheckStatus === "failure" || issue.lastGitHubFailureSource === "branch_ci")) {
             runType = "ci_repair";
             factoryState = "repairing_ci";
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchrelay",
-  "version": "0.30.1",
+  "version": "0.32.0",
   "license": "MIT",
   "type": "module",
   "repository": {