patchrelay 0.71.1 → 0.72.0

package/dist/agent-session-plan.js

@@ -51,14 +51,6 @@ function ciRepairPlan(attempt) {
         { content: "Merge", status: "pending" },
     ];
 }
-function mainRepairPlan(attempt) {
-    return [
-        { content: "Inspect main failure", status: "pending" },
-        { content: `Repairing main (${attemptLabel(attempt)})`, status: "pending" },
-        { content: "Fresh head pushed", status: "pending" },
-        { content: "Priority merge", status: "pending" },
-    ];
-}
 function queueRepairPlan(attempt) {
     return [
         { content: "Prepare workspace", status: "completed" },
@@ -148,9 +140,7 @@ export function buildAgentSessionPlan(params) {
         case "delegated":
             return setStatuses(planForRunType(runType, params), ["inProgress", "pending", "pending", "pending"]);
         case "implementing":
-            return setStatuses(params.activeRunType === "main_repair" || params.pendingRunType === "main_repair"
-                ? mainRepairPlan(params.ciRepairAttempts ?? 1)
-                : planForRunType("implementation", params), ["completed", "inProgress", "pending", "pending"]);
+            return setStatuses(planForRunType("implementation", params), ["completed", "inProgress", "pending", "pending"]);
         case "pr_open":
             return setStatuses([
                 { content: "Prepare workspace", status: "completed" },
@@ -217,8 +207,6 @@ function normalizeState(value) {
 }
 function planForRunType(runType, params) {
     switch (runType) {
-        case "main_repair":
-            return mainRepairPlan(params.ciRepairAttempts ?? 1);
         case "review_fix":
             return reviewFixPlan();
         case "branch_upkeep":

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.71.1",
-  "commit": "a52a4e7f91af",
-  "builtAt": "2026-05-23T22:11:42.868Z"
+  "version": "0.72.0",
+  "commit": "d4d672824c5f",
+  "builtAt": "2026-05-24T01:19:45.865Z"
 }

package/dist/cli/watch/StateHistoryView.js

@@ -16,6 +16,7 @@ function formatDuration(startedAt, endedAt) {
 }
 const RUN_LABELS = {
     implementation: "implementation",
+    // main_repair is a removed run type; label retained to render historical runs.
     main_repair: "main repair",
     ci_repair: "ci repair",
     review_fix: "review fix",

package/dist/cli/watch/event-log-rows.js

@@ -2,6 +2,7 @@ import { relativeTime, truncate } from "./format-utils.js";
 export { relativeTime };
 const RUN_LABEL = {
     implementation: "implementation",
+    // main_repair is a removed run type; label retained to render historical runs.
     main_repair: "main repair",
     ci_repair: "ci repair",
     review_fix: "review fix",

package/dist/cli/watch/history-builder.js

@@ -2,6 +2,7 @@
 const SIDE_TRIP_STATES = new Set(["changes_requested", "repairing_ci", "repairing_queue"]);
 const RUN_TYPE_TO_STATE = {
     implementation: "implementing",
+    // main_repair is a removed run type; label retained to render historical runs.
     main_repair: "implementing",
     ci_repair: "repairing_ci",
     review_fix: "changes_requested",

package/dist/config.js

@@ -102,6 +102,7 @@ const promptLayerSchema = z.object({
 });
 const promptByRunTypeSchema = z.object({
     implementation: promptLayerSchema.optional(),
+    // main_repair is a removed run type; key retained (optional) so pre-existing configs still validate.
     main_repair: promptLayerSchema.optional(),
     review_fix: promptLayerSchema.optional(),
     branch_upkeep: promptLayerSchema.optional(),

package/dist/idle-reconciliation.js

@@ -1,5 +1,4 @@
 import { buildBranchUpkeepContext, buildFailureContext, getGateCheckNames, hasCompletedReviewQuillVerdict, hasFailureProvenance, isDuplicateRepairAttempt, isFailingCheckStatus, isReviewDecisionApproved, isReviewDecisionReviewRequired, } from "./idle-reconciliation-helpers.js";
-import { isMainRepairIssue } from "./main-repair.js";
 import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
 import { deriveGateCheckStatusFromRollup } from "./github-rollup.js";
 import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
@@ -342,35 +341,6 @@ export class IdleIssueReconciler {
         const project = this.config.projects.find((candidate) => candidate.id === issue.projectId);
         return resolveMergeQueueProtocol(project);
     }
-    async ensurePriorityQueueLabel(issue, repoFullName) {
-        if (!isMainRepairIssue(issue) || !issue.prNumber)
-            return;
-        const priorityLabel = this.getIssueProtocol(issue).priorityLabel;
-        try {
-            const { stdout } = await execCommand("gh", [
-                "pr", "view", String(issue.prNumber),
-                "--repo", repoFullName,
-                "--json", "labels",
-            ], { timeoutMs: 10_000 });
-            const payload = JSON.parse(stdout);
-            if ((payload.labels ?? []).some((entry) => entry.name === priorityLabel)) {
-                return;
-            }
-            await execCommand("gh", [
-                "pr", "edit", String(issue.prNumber),
-                "--repo", repoFullName,
-                "--add-label", priorityLabel,
-            ], { timeoutMs: 10_000 });
-        }
-        catch (error) {
-            this.logger.warn({
-                issueKey: issue.issueKey,
-                prNumber: issue.prNumber,
-                priorityLabel,
-                error: error instanceof Error ? error.message : String(error),
-            }, "Reconciliation: failed to enforce priority queue label");
-        }
-    }
     async reconcileFromGitHub(issue) {
         const project = this.config.projects.find((p) => p.id === issue.projectId);
         if (!project?.github?.repoFullName || !issue.prNumber)
@@ -390,9 +360,6 @@ export class IdleIssueReconciler {
             const previousHeadSha = issue.prHeadSha;
             const gateCheckNames = getGateCheckNames(project);
             const gateCheckStatus = deriveGateCheckStatusFromRollup(pr.statusCheckRollup, gateCheckNames);
-            if (pr.state === "OPEN") {
-                await this.ensurePriorityQueueLabel(issue, project.github.repoFullName);
-            }
             this.db.issues.upsertIssue({
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,

package/dist/implementation-outcome-policy.js

@@ -1,5 +1,3 @@
-import { isMainRepairIssue } from "./main-repair.js";
-import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
 import { execCommand } from "./utils.js";
 export class ImplementationOutcomePolicy {
     config;
@@ -13,7 +11,7 @@ export class ImplementationOutcomePolicy {
         this.withHeldLease = withHeldLease;
     }
     async verifyPublishedRunOutcome(run, issue) {
-        if (run.runType !== "implementation" && run.runType !== "main_repair") {
+        if (run.runType !== "implementation") {
             return undefined;
         }
         const project = this.config.projects.find((entry) => entry.id === run.projectId);
@@ -26,7 +24,7 @@ export class ImplementationOutcomePolicy {
         return details ?? `Implementation completed without opening a PR for branch ${issue.branchName ?? issue.linearIssueId}`;
     }
     async detectRecoverableFailedImplementationOutcome(run, issue) {
-        if (run.runType !== "implementation" && run.runType !== "main_repair") {
+        if (run.runType !== "implementation") {
             return undefined;
         }
         const project = this.config.projects.find((entry) => entry.id === run.projectId);
@@ -81,9 +79,6 @@ export class ImplementationOutcomePolicy {
             else {
                 this.clearObservedPrIfLeaseHeld(issue, "published PR verification found only historical PRs for branch");
             }
-            if (isOpenPrState(state) && isMainRepairIssue(issue)) {
-                await this.ensurePriorityQueueLabel(run.projectId, pr.number, repoFullName);
-            }
             return isOpenPrState(state) ? "open" : "closed";
         }
         catch (error) {
@@ -158,44 +153,6 @@ export class ImplementationOutcomePolicy {
         }
         return undefined;
     }
-    async ensurePriorityQueueLabel(projectId, prNumber, repoFullName) {
-        const project = this.config.projects.find((entry) => entry.id === projectId);
-        if (!project || !repoFullName)
-            return;
-        const priorityLabel = resolveMergeQueueProtocol(project).priorityLabel;
-        try {
-            const { stdout } = await execCommand("gh", [
-                "pr",
-                "view",
-                String(prNumber),
-                "--repo",
-                repoFullName,
-                "--json",
-                "labels",
-            ], { timeoutMs: 10_000 });
-            const labels = JSON.parse(stdout);
-            const hasLabel = (labels.labels ?? []).some((entry) => entry.name === priorityLabel);
-            if (hasLabel)
-                return;
-            await execCommand("gh", [
-                "pr",
-                "edit",
-                String(prNumber),
-                "--repo",
-                repoFullName,
-                "--add-label",
-                priorityLabel,
-            ], { timeoutMs: 10_000 });
-        }
-        catch (error) {
-            this.logger.warn({
-                projectId,
-                prNumber,
-                priorityLabel,
-                error: error instanceof Error ? error.message : String(error),
-            }, "Failed to enforce priority queue label on main repair PR");
-        }
-    }
 }
 function isOpenPrState(state) {
     if (!state)

package/dist/issue-session-events.js

@@ -12,7 +12,10 @@ const NON_ACTIONABLE_SESSION_EVENTS = new Set([
     "prompt_delivered",
     "run_released_authority",
 ]);
-const RUN_TYPES = new Set(["implementation", "main_repair", "review_fix", "branch_upkeep", "ci_repair", "queue_repair"]);
+// "main_repair" was removed as a run type; legacy session-event payloads carrying it
+// are not in this set, so parseRunType returns undefined and callers fall back to
+// "implementation" (see deriveSessionWakePlan below).
+const RUN_TYPES = new Set(["implementation", "review_fix", "branch_upkeep", "ci_repair", "queue_repair"]);
 function parseRunType(value) {
     return typeof value === "string" && RUN_TYPES.has(value) ? value : undefined;
 }
@@ -53,9 +56,7 @@ export function deriveSessionWakePlan(issue, events) {
             case "delegated":
                 if (!runType) {
                     runType = parseRunType(payload?.runType) ?? "implementation";
-                    wakeReason = runType === "main_repair"
-                        ? "main_repair"
-                        : issue.issueClass === "orchestration" ? "initial_delegate" : "delegated";
+                    wakeReason = issue.issueClass === "orchestration" ? "initial_delegate" : "delegated";
                 }
                 Object.assign(context, payload ?? {});
                 break;

package/dist/issue-session.js

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

package/dist/linear-workflow-state-sync.js

@@ -1,4 +1,4 @@
-import { resolvePreferredQueuedLinearState, resolvePreferredCompletedLinearState, resolvePreferredDeployingLinearState, resolvePreferredDeployLinearState, resolvePreferredHumanNeededLinearState, resolvePreferredImplementingLinearState, resolvePreferredReviewLinearState, resolvePreferredReviewingLinearState, } from "./linear-workflow.js";
+import { resolvePreferredQueuedLinearState, resolvePreferredCompletedLinearState, resolvePreferredDeployingLinearState, resolvePreferredHumanNeededLinearState, resolvePreferredImplementingLinearState, resolvePreferredMergeQueueLinearState, resolvePreferredReviewingLinearState, } from "./linear-workflow.js";
 import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
 import { isCompletedLinearState } from "./pr-state.js";
 import { hasTrustedNoPrCompletion } from "./trusted-no-pr-completion.js";
@@ -67,24 +67,21 @@ async function syncQueuedForDeployLabel(params) {
         await linear.updateIssueLabels({ issueId: issue.linearIssueId, removeNames: [labelName] });
     }
 }
-// True only when (a) the issue is In Deploy AND (b) the project's
-// Linear workflow has no In Deploy-equivalent state — detected by the
-// preferred-deploying state collapsing to the same name as the
-// preferred-review state. When the project does have a real In Deploy
-// state, `setIssueState` flows the issue there and the label is
-// unnecessary.
+// True only when (a) the issue is in the merge queue (`awaiting_queue`)
+// AND (b) the project's Linear workflow has no dedicated In Merge Queue
+// state — detected by the preferred merge-queue state collapsing to the
+// same name as the reviewing state. When the project has a real In Merge
+// Queue (or Deploying) state, `setIssueState` flows the issue there and
+// the label is unnecessary.
 function isQueuedForDeployFallback(issue, liveIssue) {
     if (issue.factoryState !== "awaiting_queue")
         return false;
-    const deploying = resolvePreferredDeployingLinearState(liveIssue);
-    const review = resolvePreferredReviewLinearState(liveIssue);
-    const deployUnstarted = resolvePreferredDeployLinearState(liveIssue);
-    if (!deploying || !review)
+    const mergeQueue = resolvePreferredMergeQueueLinearState(liveIssue);
+    const reviewing = resolvePreferredReviewingLinearState(liveIssue);
+    if (!mergeQueue || !reviewing)
         return false;
-    // No "deploying"/"deploy" state in the workflow → both resolve to
-    // a review state. That's the fallback condition.
-    return deploying.trim().toLowerCase() === review.trim().toLowerCase()
-        && (deployUnstarted ?? "").trim().toLowerCase() === review.trim().toLowerCase();
+    // No dedicated merge-queue state → it collapses to the reviewing state.
+    return mergeQueue.trim().toLowerCase() === reviewing.trim().toLowerCase();
 }
 async function syncCompletedLinearState(params) {
     const { db, issue, linear, liveIssue } = params;
@@ -121,49 +118,115 @@ function shouldAutoAdvanceLinearState(issue) {
     const normalizedName = issue.currentLinearState?.trim().toLowerCase();
     return normalizedName !== "done" && normalizedName !== "completed" && normalizedName !== "complete";
 }
-function resolveDesiredActiveWorkflowState(issue, trackedIssue, options, liveIssue) {
-    if (issue.factoryState === "awaiting_input" || issue.factoryState === "failed" || issue.factoryState === "escalated"
-        || trackedIssue?.sessionState === "waiting_input" || trackedIssue?.sessionState === "failed") {
+// ─── Unified PR-lifecycle → Linear-state mapping ─────────────────────
+//
+// Five phases, in lifecycle order:
+//   Implementing → Reviewing → In Merge Queue → Deploying → Done
+//
+// Every phase is decided from DURABLE signals (factoryState, prState,
+// prReviewState) — never the ephemeral activeRunId / sessionState / run
+// type. That is what kills the Implementing↔Reviewing flap: the state
+// only moves on a real lifecycle handoff (a review verdict, an approval,
+// a merge), not on whichever transient webhook happens to recompute it
+// while a run briefly holds a lease.
+//
+// Branches are ordered "furthest along the lifecycle wins" so a stale
+// earlier signal can never pull a more-advanced issue backwards.
+function resolveDesiredActiveWorkflowState(issue, trackedIssue, _options, liveIssue) {
+    // 1. Operator must act — overrides everything.
+    if (needsHumanAttention(issue, trackedIssue)) {
         return resolvePreferredHumanNeededLinearState(liveIssue);
     }
+    // 2. Completed → Done. Covers today's merge→done path (the factory has
+    //    no post-merge state yet), so a done issue never reads as Deploying.
+    if (issue.factoryState === "done") {
+        return resolvePreferredCompletedLinearState(liveIssue);
+    }
+    // 3. Paused with no PR and nothing for us to do → backlog.
     const blocked = (trackedIssue?.blockedByCount ?? 0) > 0;
-    const pausedNoPrWork = issue.prNumber === undefined && (!issue.delegatedToPatchRelay || blocked);
-    if (pausedNoPrWork) {
+    const noPr = issue.prNumber === undefined && !issue.prUrl;
+    if (noPr && (issue.delegatedToPatchRelay === false || blocked)) {
         return resolvePreferredQueuedLinearState(liveIssue);
     }
-    const activelyWorking = issue.delegatedToPatchRelay !== false && (issue.activeRunId !== undefined
-        || options?.activeRunType !== undefined
-        || trackedIssue?.sessionState === "running"
-        || (issue.factoryState === "delegated" && !blocked && trackedIssue?.readyForExecution !== false)
-        || issue.factoryState === "implementing"
-        || issue.factoryState === "changes_requested"
-        || issue.factoryState === "repairing_ci"
-        || issue.factoryState === "repairing_queue");
-    if (activelyWorking) {
+    // 4. Post-merge: the change is on main, deploy running → Deploying.
+    //    Durable signal: the PR is merged. (Until PR3 makes merge a
+    //    non-terminal phase this only fires in the merged-not-yet-done
+    //    window; branch 2 already caught factoryState==="done".)
+    if (normalize(issue.prState) === "merged") {
+        return resolvePreferredDeployingLinearState(liveIssue);
+    }
+    // 5. Patchrelay is actively addressing review/CI/queue feedback →
+    //    Implementing. These factory states persist for the run's whole
+    //    duration, so this is stable, not flappy — and it is exactly the
+    //    "show when patchrelay handles feedback" behavior we want.
+    if (isAddressingFeedback(issue)) {
         return resolvePreferredImplementingLinearState(liveIssue);
     }
-    if (issue.factoryState === "awaiting_queue"
-        || issue.prReviewState === "approved"
-        || isApprovedAndGreen(issue.prReviewState, issue.prCheckStatus)) {
-        return resolvePreferredDeployingLinearState(liveIssue);
+    // 6. Approved / admitted to the merge queue → In Merge Queue.
+    if (isInMergeQueue(issue)) {
+        return resolvePreferredMergeQueueLinearState(liveIssue);
     }
-    if (hasPendingReviewQuillVerdict(issue.lastGitHubCiSnapshotJson)) {
+    // 7. Pre-review-feedback implementation work (incl. a draft PR) →
+    //    Implementing.
+    if (isImplementing(issue, trackedIssue)) {
+        return resolvePreferredImplementingLinearState(liveIssue);
+    }
+    // 8. PR exists and is under review → Reviewing.
+    if (isReviewBound(issue)) {
         return resolvePreferredReviewingLinearState(liveIssue);
     }
-    const reviewBound = issue.prNumber !== undefined
+    return undefined;
+}
+function normalize(value) {
+    const trimmed = value?.trim().toLowerCase();
+    return trimmed ? trimmed : undefined;
+}
+function needsHumanAttention(issue, trackedIssue) {
+    return issue.factoryState === "awaiting_input"
+        || issue.factoryState === "failed"
+        || issue.factoryState === "escalated"
+        || trackedIssue?.sessionState === "waiting_input"
+        || trackedIssue?.sessionState === "failed";
+}
+// Active code work to address feedback. Durable factory states +
+// changes-requested review verdict — no run-id involvement. Gated on
+// delegation: an undelegated PR (operator paused us) is not being worked
+// by patchrelay, so it must not read as Implementing.
+function isAddressingFeedback(issue) {
+    if (issue.delegatedToPatchRelay === false)
+        return false;
+    return issue.factoryState === "changes_requested"
+        || issue.factoryState === "repairing_ci"
+        || issue.factoryState === "repairing_queue"
+        || normalize(issue.prReviewState) === "changes_requested";
+}
+// Approved and heading to / sitting in the merge queue. Not yet merged
+// (branch 4 catches merged first).
+function isInMergeQueue(issue) {
+    return issue.factoryState === "awaiting_queue"
+        || normalize(issue.prReviewState) === "approved";
+}
+// Initial implementation, before review starts. A draft PR still counts
+// as implementing. Gated on delegation so we never claim Implementing
+// for work that isn't ours.
+function isImplementing(issue, trackedIssue) {
+    if (issue.delegatedToPatchRelay === false)
+        return false;
+    if (issue.factoryState === "implementing")
+        return true;
+    if (issue.factoryState === "delegated") {
+        const blocked = (trackedIssue?.blockedByCount ?? 0) > 0;
+        return !blocked && trackedIssue?.readyForExecution !== false;
+    }
+    return issue.prIsDraft === true;
+}
+function isReviewBound(issue) {
+    return issue.prNumber !== undefined
         || Boolean(issue.prUrl)
         || issue.factoryState === "pr_open"
         || issue.prReviewState !== undefined
-        || issue.prCheckStatus !== undefined;
-    if (reviewBound) {
-        return resolvePreferredReviewLinearState(liveIssue);
-    }
-    return undefined;
-}
-function isApprovedAndGreen(prReviewState, prCheckStatus) {
-    const normalizedReview = prReviewState?.trim().toLowerCase();
-    const normalizedChecks = prCheckStatus?.trim().toLowerCase();
-    return normalizedReview === "approved" && (normalizedChecks === "success" || normalizedChecks === "passed");
+        || issue.prCheckStatus !== undefined
+        || hasPendingReviewQuillVerdict(issue.lastGitHubCiSnapshotJson);
 }
 function hasPendingReviewQuillVerdict(snapshotJson) {
     if (!snapshotJson)

package/dist/linear-workflow.js

@@ -59,16 +59,37 @@ export function resolvePreferredReviewingLinearState(issue) {
         fallback: resolvePreferredReviewLinearState(issue),
     });
 }
+// The pre-merge "approved, awaiting/undergoing landing" phase. Covers a
+// PR that is queued, being tested in the speculative branch, or actively
+// merging — i.e. everything the merge queue owns up to (but not past)
+// the merge. NOT post-merge: that is `resolvePreferredDeployingLinearState`.
+// Without a dedicated queue state, collapses to the reviewing state (and
+// the `queued-for-deploy` label disambiguates — see state-sync).
+export function resolvePreferredMergeQueueLinearState(issue) {
+    return resolvePreferredLinearState(issue, {
+        names: ["in merge queue", "merge queue", "in queue", "queued", "queue", "merging", "landing", "ready to merge"],
+        types: ["started"],
+        fallback: resolvePreferredLinearState(issue, {
+            names: ["in merge queue", "merge queue", "queued", "ready to merge", "ready to deploy", "ready for deploy", "to deploy", "merge"],
+            types: ["unstarted"],
+            fallback: resolvePreferredReviewingLinearState(issue),
+        }),
+    });
+}
+// Unstarted deploy column, used as a fallback by the started variant.
 export function resolvePreferredDeployLinearState(issue) {
     return resolvePreferredLinearState(issue, {
-        names: ["deploy", "ready to deploy", "ready for deploy", "merge"],
+        names: ["deploy", "to deploy", "ready to ship"],
         types: ["unstarted"],
-        fallback: resolvePreferredReviewLinearState(issue),
+        fallback: resolvePreferredMergeQueueLinearState(issue),
     });
 }
+// Strictly POST-merge: the change is on main and the deploy workflow is
+// running. "merging" lives in the merge-queue phase, not here. Without a
+// dedicated deploy state, collapses back to the merge-queue state.
 export function resolvePreferredDeployingLinearState(issue) {
     return resolvePreferredLinearState(issue, {
-        names: ["deploying", "merging", "shipping"],
+        names: ["deploying", "deployment", "in deploy", "shipping", "releasing", "rollout"],
         types: ["started"],
         fallback: resolvePreferredDeployLinearState(issue),
     });

package/dist/no-pr-completion-check.js

@@ -168,50 +168,6 @@ export async function handleNoPrCompletionCheck(params) {
             });
             return;
         }
-        if (params.run.runType === "main_repair") {
-            const continued = params.withHeldLease(params.run.projectId, params.run.linearIssueId, (lease) => {
-                params.db.runs.finishRun(params.run.id, runUpdate);
-                params.db.runs.saveCompletionCheck(params.run.id, {
-                    ...completionCheck,
-                    outcome: "continue",
-                    summary: "Main repair cannot finish without a published repair PR; continuing automatically until the fix is published or main recovers externally.",
-                    why: completionCheck.summary,
-                });
-                params.db.issues.upsertIssue({
-                    projectId: params.run.projectId,
-                    linearIssueId: params.run.linearIssueId,
-                    activeRunId: null,
-                    factoryState: "delegated",
-                    pendingRunType: null,
-                    pendingRunContextJson: null,
-                });
-                return Boolean(params.db.issueSessions.appendIssueSessionEventWithLease(lease, {
-                    projectId: params.run.projectId,
-                    linearIssueId: params.run.linearIssueId,
-                    eventType: "completion_check_continue",
-                    eventJson: JSON.stringify({
-                        runType: params.run.runType,
-                        summary: params.publishedOutcomeError,
-                    }),
-                    dedupeKey: `completion_check_continue:${params.run.id}`,
-                }));
-            });
-            if (!continued) {
-                params.logger.warn({ runId: params.run.id, issueId: params.run.linearIssueId }, "Skipping main-repair completion-check continue writes after losing issue-session lease");
-                params.clearProgressAndRelease(params.run);
-                return;
-            }
-            params.syncCompletionCheckOutcome({
-                run: params.run,
-                fallbackIssue: params.issue,
-                level: "info",
-                status: "completion_check_continue",
-                summary: "No repair PR found; continuing automatically",
-                detail: "Main repair cannot close until PatchRelay publishes a repair PR or main recovers externally.",
-                activity: buildCompletionCheckActivity("continue"),
-            });
-            return;
-        }
         const orchestrationOpenChildren = params.issue.issueClass === "orchestration"
             ? params.db.issues.countOpenChildIssues(params.run.projectId, params.run.linearIssueId)
             : 0;

package/dist/patchrelay-customization.js

@@ -7,6 +7,7 @@ const promptLayerSchema = z.object({
 });
 const promptByRunTypeSchema = z.object({
     implementation: promptLayerSchema.optional(),
+    // main_repair is a removed run type; key retained (optional) so pre-existing configs still validate.
     main_repair: promptLayerSchema.optional(),
     review_fix: promptLayerSchema.optional(),
     branch_upkeep: promptLayerSchema.optional(),

package/dist/prompting/patchrelay.js

@@ -3,7 +3,6 @@ import path from "node:path";
 import { derivePrDisplayContext } from "../pr-display-context.js";
 const WORKFLOW_FILES = {
     implementation: "IMPLEMENTATION_WORKFLOW.md",
-    main_repair: "IMPLEMENTATION_WORKFLOW.md",
     review_fix: "REVIEW_WORKFLOW.md",
     branch_upkeep: "REVIEW_WORKFLOW.md",
     ci_repair: "IMPLEMENTATION_WORKFLOW.md",
@@ -346,23 +345,6 @@ function buildCiRepairContext(context) {
             : "",
     ].filter(Boolean).join("\n");
 }
-function buildMainRepairContext(context) {
-    const failingCheckNames = Array.isArray(context?.failingChecks)
-        ? context.failingChecks
-            .filter((entry) => Boolean(entry) && typeof entry === "object")
-            .map((entry) => String(entry.name ?? "").trim())
-            .filter((name) => name.length > 0)
-        : [];
-    return [
-        "Base-branch repair on the red mainline.",
-        "Goal: restore main by fixing the real persistent failure, not by papering over a transient runner incident.",
-        "Before changing code or workflow config, verify that the original incident still persists on the exact failing main SHA or identify a concrete log signature that justifies the fix.",
-        "For transient infrastructure symptoms such as disk pressure, runner exhaustion, or network flakiness, prefer a rerun-only repair if the rerun clears the branch.",
-        "Do not propose or implement moving CI, deploy, or tests onto different nodes or runner pools unless a human explicitly asked for that infrastructure migration.",
-        context?.baseSha ? `Failing main SHA: ${String(context.baseSha)}` : "",
-        failingCheckNames.length > 0 ? `Failing checks: ${failingCheckNames.join(", ")}` : "",
-    ].filter(Boolean).join("\n");
-}
 function appendQueueRepairContext(lines, context) {
     const queueContext = context?.mergeQueueContext;
     if (!queueContext || typeof queueContext !== "object") {
@@ -489,9 +471,6 @@ function buildCurrentContext(runType, issue, context, followUp = false) {
     }
     lines.push(...buildHumanContextLines(context));
     switch (runType) {
-        case "main_repair":
-            lines.push(buildMainRepairContext(context));
-            break;
         case "ci_repair":
             lines.push(buildCiRepairContext(context));
             break;

package/dist/run-launcher.js

@@ -125,11 +125,10 @@ export class RunLauncher {
                 branchName: params.branchName,
                 worktreePath: params.worktreePath,
                 factoryState: params.runType === "implementation" ? "implementing"
-                    : params.runType === "main_repair" ? "implementing"
-                        : params.runType === "ci_repair" ? "repairing_ci"
-                            : params.runType === "review_fix" || params.runType === "branch_upkeep" ? "changes_requested"
-                                : params.runType === "queue_repair" ? "repairing_queue"
-                                    : "implementing",
+                    : params.runType === "ci_repair" ? "repairing_ci"
+                        : params.runType === "review_fix" || params.runType === "branch_upkeep" ? "changes_requested"
+                            : params.runType === "queue_repair" ? "repairing_queue"
+                                : "implementing",
                 ...((params.runType === "ci_repair" || params.runType === "queue_repair") && failureSignature
                     ? {
                         lastAttemptedFailureSignature: failureSignature,

package/dist/run-orchestrator.js

@@ -4,7 +4,6 @@ import { CompletionCheckService } from "./completion-check.js";
 import { PublicationRecapService } from "./publication-recap.js";
 import { WorktreeManager } from "./worktree-manager.js";
 import { MergedLinearCompletionReconciler } from "./merged-linear-completion-reconciler.js";
-import { MainBranchHealthMonitor } from "./main-branch-health-monitor.js";
 import { QueueHealthMonitor } from "./queue-health-monitor.js";
 import { IdleIssueReconciler } from "./idle-reconciliation.js";
 import { LinearSessionSync } from "./linear-session-sync.js";
@@ -47,7 +46,6 @@ export class RunOrchestrator {
     linearProvider;
     enqueueIssue;
     worktreeManager;
-    mainBranchHealthMonitor;
     /** Tracks last probe-failure feed event per issue to avoid spamming the operator feed. */
     queueHealthMonitor;
     idleReconciler;
@@ -137,7 +135,6 @@ export class RunOrchestrator {
         this.runReconciler = new RunReconciler(db, logger, linearProvider, this.linearSync, this.interruptedRunRecovery, this.runFinalizer, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, this.threadPorts.readThreadWithRetry, this.recoveryPorts.recoverOrEscalate, (projectId) => this.config.projects.find((project) => project.id === projectId)?.github?.repoFullName, feed);
         this.runWakePlanner = new RunWakePlanner(db);
         this.idleReconciler = new IdleIssueReconciler(db, config, this.wakeDispatcher, logger, feed);
-        this.mainBranchHealthMonitor = new MainBranchHealthMonitor(db, config, linearProvider, logger, feed);
         this.mergedLinearCompletionReconciler = new MergedLinearCompletionReconciler(db, linearProvider, logger);
         this.queueHealthMonitor = new QueueHealthMonitor(db, config, {
             advanceIdleIssue: (issue, newState, options) => this.idleReconciler.advanceIdleIssue(issue, newState, options),
@@ -454,7 +451,6 @@ export class RunOrchestrator {
         for (const run of this.db.runs.listRunningRuns()) {
             await this.reconcileRun(run);
         }
-        await this.mainBranchHealthMonitor.reconcile();
         // Preemptively detect stuck merge-queue PRs (conflicts visible on
         // GitHub) and dispatch queue_repair before the Steward evicts.
         await this.queueHealthMonitor.reconcile();

package/dist/run-wake-planner.js

@@ -27,10 +27,6 @@ export class RunWakePlanner {
             eventType = "settled_red_ci";
             dedupeKey = `${dedupeScope ?? "wake"}:ci_repair:${issue.linearIssueId}:${issue.lastGitHubFailureSignature ?? issue.prHeadSha ?? "unknown-sha"}`;
         }
-        else if (runType === "main_repair") {
-            eventType = "delegated";
-            dedupeKey = `${dedupeScope ?? "wake"}:main_repair:${issue.linearIssueId}`;
-        }
         else if (runType === "review_fix" || runType === "branch_upkeep") {
             eventType = "review_changes_requested";
             dedupeKey = `${dedupeScope ?? "wake"}:${runType}:${issue.linearIssueId}:${issue.prHeadSha ?? "unknown-sha"}`;

package/package.json

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

package/dist/main-branch-health-monitor.js

@@ -1,179 +0,0 @@
-import { resolvePreferredCompletedLinearState } from "./linear-workflow.js";
-import { buildMainRepairBranchName, isMainRepairIssue, } from "./main-repair.js";
-import { execCommand } from "./utils.js";
-const MAIN_BRANCH_HEALTH_GRACE_MS = 120_000;
-function isUnhealthyMainConclusion(conclusion) {
-    return conclusion === "failure"
-        || conclusion === "timed_out"
-        || conclusion === "cancelled"
-        || conclusion === "action_required"
-        || conclusion === "stale";
-}
-export class MainBranchHealthMonitor {
-    db;
-    config;
-    linearProvider;
-    logger;
-    feed;
-    /** Per-project throttle for the information-only "main is red" log. */
-    lastUnhealthyReportAt = new Map();
-    constructor(db, config, linearProvider, logger, feed) {
-        this.db = db;
-        this.config = config;
-        this.linearProvider = linearProvider;
-        this.logger = logger;
-        this.feed = feed;
-    }
-    async reconcile() {
-        for (const project of this.config.projects) {
-            await this.reconcileProject(project.id);
-        }
-    }
-    async reconcileProject(projectId) {
-        const project = this.config.projects.find((entry) => entry.id === projectId);
-        if (!project?.github?.repoFullName)
-            return;
-        if (project.linearTeamIds.length === 0)
-            return;
-        const baseBranch = project.github.baseBranch ?? "main";
-        const branchName = buildMainRepairBranchName(baseBranch);
-        const existing = this.findExistingMainRepair(projectId, branchName);
-        const summary = await this.readMainBranchFailure(project.github.repoFullName, baseBranch);
-        if (!summary) {
-            if (existing) {
-                await this.resolveRecoveredMainRepair(existing);
-            }
-            return;
-        }
-        // main CI is red. The merge queue (merge-steward) gates only on its own
-        // speculative-SHA checks and ignores main entirely, so a red main no longer
-        // warrants an automated repair job — main CI is information-only. Report it
-        // (throttled) and post nothing. Any pre-existing repair issue is left to close
-        // via resolveRecoveredMainRepair once main recovers.
-        this.reportUnhealthyMain(projectId, project.github.repoFullName, baseBranch, summary);
-    }
-    reportUnhealthyMain(projectId, repoFullName, baseBranch, summary) {
-        const now = Date.now();
-        const lastReportedAt = this.lastUnhealthyReportAt.get(projectId);
-        if (lastReportedAt !== undefined && now - lastReportedAt < MAIN_BRANCH_HEALTH_GRACE_MS) {
-            return;
-        }
-        this.lastUnhealthyReportAt.set(projectId, now);
-        this.logger.warn({
-            projectId,
-            repoFullName,
-            baseBranch,
-            baseSha: summary.baseSha,
-            failingChecks: summary.failingChecks.map((check) => check.name),
-        }, "main branch CI is red — information only; no repair job posted (merge queue gates on its own spec CI)");
-    }
-    findExistingMainRepair(projectId, branchName) {
-        const candidates = this.db.listIssues()
-            .filter((issue) => (issue.projectId === projectId
-            && issue.branchName === branchName
-            && isMainRepairIssue(issue)
-            && issue.factoryState !== "done"))
-            .sort((left, right) => this.compareMainRepairCandidates(left, right));
-        return candidates[0];
-    }
-    compareMainRepairCandidates(left, right) {
-        const leftPriority = this.rankMainRepairCandidate(left);
-        const rightPriority = this.rankMainRepairCandidate(right);
-        if (leftPriority !== rightPriority)
-            return leftPriority - rightPriority;
-        return Date.parse(right.updatedAt) - Date.parse(left.updatedAt);
-    }
-    rankMainRepairCandidate(issue) {
-        if (issue.activeRunId !== undefined)
-            return 0;
-        if (issue.prState === "open" || issue.factoryState === "awaiting_queue" || issue.factoryState === "pr_open")
-            return 1;
-        if (issue.factoryState === "delegated" || issue.factoryState === "implementing")
-            return 2;
-        if (issue.factoryState === "failed" || issue.factoryState === "escalated")
-            return 3;
-        return 4;
-    }
-    async resolveRecoveredMainRepair(issue) {
-        if (issue.activeRunId !== undefined)
-            return;
-        if (issue.prState === "open" || issue.factoryState === "awaiting_queue" || issue.factoryState === "pr_open") {
-            return;
-        }
-        const linear = await this.linearProvider.forProject(issue.projectId).catch(() => undefined);
-        if (linear) {
-            const liveIssue = await linear.getIssue(issue.linearIssueId).catch(() => undefined);
-            if (liveIssue) {
-                const targetState = resolvePreferredCompletedLinearState(liveIssue);
-                const normalizedCurrent = liveIssue.stateName?.trim().toLowerCase();
-                if (targetState && normalizedCurrent !== targetState.trim().toLowerCase()) {
-                    const updated = await linear.setIssueState(issue.linearIssueId, targetState).catch(() => undefined);
-                    if (updated) {
-                        this.db.upsertIssue({
-                            projectId: issue.projectId,
-                            linearIssueId: issue.linearIssueId,
-                            ...(updated.stateName ? { currentLinearState: updated.stateName } : {}),
-                            ...(updated.stateType ? { currentLinearStateType: updated.stateType } : {}),
-                        });
-                    }
-                }
-                else {
-                    this.db.upsertIssue({
-                        projectId: issue.projectId,
-                        linearIssueId: issue.linearIssueId,
-                        ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
-                        ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
-                    });
-                }
-            }
-        }
-        this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(issue.projectId, issue.linearIssueId);
-        this.db.upsertIssue({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            factoryState: "done",
-            pendingRunType: null,
-        });
-        this.feed?.publish({
-            level: "info",
-            kind: "github",
-            issueKey: issue.issueKey,
-            projectId: issue.projectId,
-            stage: "done",
-            status: "main_repair_resolved",
-            summary: "Closed stale main_repair after main recovered externally",
-        });
-    }
-    async readMainBranchFailure(repoFullName, baseBranch) {
-        const { stdout: shaOut } = await execCommand("gh", [
-            "api",
-            `repos/${repoFullName}/branches/${baseBranch}`,
-            "--jq",
-            ".commit.sha",
-        ], { timeoutMs: 10_000 });
-        const baseSha = shaOut.trim();
-        if (!baseSha)
-            return undefined;
-        const { stdout: checksOut } = await execCommand("gh", [
-            "api",
-            `repos/${repoFullName}/commits/${baseSha}/check-runs`,
-            "--jq",
-            ".check_runs",
-        ], { timeoutMs: 10_000 });
-        const runs = JSON.parse(checksOut || "[]");
-        const failingChecks = runs
-            .filter((run) => run.status === "completed" && isUnhealthyMainConclusion(run.conclusion) && typeof run.name === "string" && run.name.trim())
-            .map((run) => ({ name: run.name.trim(), ...(run.details_url ? { url: run.details_url } : {}) }));
-        if (failingChecks.length === 0) {
-            return undefined;
-        }
-        const pendingChecks = runs
-            .filter((run) => run.status !== "completed" && typeof run.name === "string" && run.name.trim())
-            .map((run) => ({ name: run.name.trim(), ...(run.details_url ? { url: run.details_url } : {}) }));
-        return {
-            baseSha,
-            failingChecks,
-            pendingChecks,
-        };
-    }
-}

package/dist/main-repair.js

@@ -1,47 +0,0 @@
-export const MAIN_REPAIR_BRANCH_PREFIX = "main-repair";
-export function buildMainRepairBranchName(baseBranch) {
-    return `${MAIN_REPAIR_BRANCH_PREFIX}/${baseBranch}`;
-}
-export function isMainRepairIssue(issue) {
-    return typeof issue.branchName === "string" && issue.branchName.startsWith(`${MAIN_REPAIR_BRANCH_PREFIX}/`);
-}
-export function buildMainRepairTitle(project) {
-    const repo = project.github?.repoFullName ?? project.id;
-    const baseBranch = project.github?.baseBranch ?? "main";
-    return `Repair ${baseBranch} for ${repo}`;
-}
-export function buildMainRepairDescription(project, summary, priorityLabel) {
-    const repo = project.github?.repoFullName ?? project.id;
-    const baseBranch = project.github?.baseBranch ?? "main";
-    const lines = [
-        `Automatically created because \`${repo}@${baseBranch}\` is red.`,
-        "",
-        `Base SHA: \`${summary.baseSha}\``,
-        "",
-        "Repair the base-branch failure on a PR branch, get the PR green, and keep it in the priority queue lane.",
-        `The repair PR must carry the GitHub label \`${priorityLabel}\`.`,
-    ];
-    if (summary.failingChecks.length > 0) {
-        lines.push("", "Failing checks:");
-        for (const check of summary.failingChecks) {
-            lines.push(`- ${check.name}${check.url ? ` — ${check.url}` : ""}`);
-        }
-    }
-    if (summary.pendingChecks.length > 0) {
-        lines.push("", "Pending checks:");
-        for (const check of summary.pendingChecks) {
-            lines.push(`- ${check.name}${check.url ? ` — ${check.url}` : ""}`);
-        }
-    }
-    return lines.join("\n");
-}
-export function buildMainRepairPromptContext(project, summary, priorityLabel) {
-    const repo = project.github?.repoFullName ?? project.id;
-    const baseBranch = project.github?.baseBranch ?? "main";
-    const failingNames = summary.failingChecks.map((check) => check.name).join(", ") || "unknown failing checks";
-    return [
-        `Main repair for ${repo}.`,
-        `${baseBranch} is red at ${summary.baseSha}.`,
-        `Fix the failing base-branch checks (${failingNames}), publish a PR on this branch, and assign the GitHub label ${priorityLabel}.`,
-    ].join(" ");
-}