patchrelay 0.50.6 → 0.51.1

package/dist/agent-session-plan.js

@@ -51,6 +51,14 @@ 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: "Awaiting re-verification", status: "pending" },
+        { content: "Priority merge", status: "pending" },
+    ];
+}
 function queueRepairPlan(attempt) {
     return [
         { content: "Prepare workspace", status: "completed" },
@@ -140,7 +148,9 @@ export function buildAgentSessionPlan(params) {
         case "delegated":
             return setStatuses(planForRunType(runType, params), ["inProgress", "pending", "pending", "pending"]);
         case "implementing":
-            return setStatuses(planForRunType("implementation", params), ["completed", "inProgress", "pending", "pending"]);
+            return setStatuses(params.activeRunType === "main_repair" || params.pendingRunType === "main_repair"
+                ? mainRepairPlan(params.ciRepairAttempts ?? 1)
+                : planForRunType("implementation", params), ["completed", "inProgress", "pending", "pending"]);
         case "pr_open":
             return setStatuses(implementationPlan(), ["completed", "completed", "inProgress", "pending"]);
         case "changes_requested":
@@ -173,6 +183,8 @@ export function buildAgentSessionPlan(params) {
 }
 function planForRunType(runType, params) {
     switch (runType) {
+        case "main_repair":
+            return mainRepairPlan(params.ciRepairAttempts ?? 1);
         case "review_fix":
             return reviewFixPlan();
         case "branch_upkeep":
@@ -200,9 +212,10 @@ export function buildAgentSessionPlanForIssue(issue, options) {
 export function buildRunningSessionPlan(runType) {
     return buildAgentSessionPlan({
         factoryState: runType === "ci_repair" ? "repairing_ci"
-            : runType === "review_fix" || runType === "branch_upkeep" ? "changes_requested"
-                : runType === "queue_repair" ? "repairing_queue"
-                    : "implementing",
+            : runType === "main_repair" ? "implementing"
+                : runType === "review_fix" || runType === "branch_upkeep" ? "changes_requested"
+                    : runType === "queue_repair" ? "repairing_queue"
+                        : "implementing",
         activeRunType: runType,
     });
 }

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.50.6",
-  "commit": "93d2215a55bf",
-  "builtAt": "2026-04-21T15:53:17.328Z"
+  "version": "0.51.1",
+  "commit": "0b16fe78f8c9",
+  "builtAt": "2026-04-21T22:06:12.939Z"
 }

package/dist/cli/watch/StateHistoryView.js

@@ -16,6 +16,7 @@ function formatDuration(startedAt, endedAt) {
 }
 const RUN_LABELS = {
     implementation: "implementation",
+    main_repair: "main repair",
     ci_repair: "ci repair",
     review_fix: "review fix",
     branch_upkeep: "branch upkeep",

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: "main repair",
     ci_repair: "ci repair",
     review_fix: "review fix",
     branch_upkeep: "branch upkeep",

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: "implementing",
     ci_repair: "repairing_ci",
     review_fix: "changes_requested",
     branch_upkeep: "changes_requested",

package/dist/config.js

@@ -66,6 +66,7 @@ const projectSchema = z.object({
         webhook_secret: z.string().min(1).optional(),
         repo_full_name: z.string().min(1).optional(),
         base_branch: z.string().min(1).optional(),
+        priority_queue_label: z.string().min(1).optional(),
     }).optional(),
 });
 const repositorySchema = z.object({
@@ -89,6 +90,7 @@ const repositorySchema = z.object({
         base_branch: z.string().min(1).optional(),
         merge_queue_label: z.string().min(1).optional(),
         merge_queue_check_name: z.string().min(1).optional(),
+        priority_queue_label: z.string().min(1).optional(),
     }).optional(),
 });
 const promptLayerSchema = z.object({
@@ -97,6 +99,7 @@ const promptLayerSchema = z.object({
 });
 const promptByRunTypeSchema = z.object({
     implementation: promptLayerSchema.optional(),
+    main_repair: promptLayerSchema.optional(),
     review_fix: promptLayerSchema.optional(),
     branch_upkeep: promptLayerSchema.optional(),
     ci_repair: promptLayerSchema.optional(),
@@ -474,6 +477,7 @@ export function loadConfig(configPath = process.env.PATCHRELAY_CONFIG ?? getDefa
                 ...(repository.github?.webhook_secret ? { webhookSecret: repository.github.webhook_secret } : {}),
                 ...(repository.github?.merge_queue_label ? { mergeQueueLabel: repository.github.merge_queue_label } : {}),
                 ...(repository.github?.merge_queue_check_name ? { mergeQueueCheckName: repository.github.merge_queue_check_name } : {}),
+                ...(repository.github?.priority_queue_label ? { priorityQueueLabel: repository.github.priority_queue_label } : {}),
             },
         };
     });
@@ -514,6 +518,7 @@ export function loadConfig(configPath = process.env.PATCHRELAY_CONFIG ?? getDefa
                     ...(project.github.webhook_secret ? { webhookSecret: project.github.webhook_secret } : {}),
                     ...(project.github.repo_full_name ? { repoFullName: project.github.repo_full_name } : {}),
                     ...(project.github.base_branch ? { baseBranch: project.github.base_branch } : {}),
+                    ...(project.github.priority_queue_label ? { priorityQueueLabel: project.github.priority_queue_label } : {}),
                 },
             } : {}),
         };

package/dist/idle-reconciliation.js

@@ -1,3 +1,4 @@
+import { isMainRepairIssue } from "./main-repair.js";
 import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
 import { parseGitHubFailureContext } from "./github-failure-context.js";
 import { deriveGateCheckStatusFromRollup } from "./github-rollup.js";
@@ -421,6 +422,35 @@ 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)
@@ -435,6 +465,9 @@ 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,3 +1,5 @@
+import { isMainRepairIssue } from "./main-repair.js";
+import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
 import { execCommand } from "./utils.js";
 export class ImplementationOutcomePolicy {
     config;
@@ -11,12 +13,12 @@ export class ImplementationOutcomePolicy {
         this.withHeldLease = withHeldLease;
     }
     async verifyPublishedRunOutcome(run, issue) {
-        if (run.runType !== "implementation") {
+        if (run.runType !== "implementation" && run.runType !== "main_repair") {
             return undefined;
         }
         const project = this.config.projects.find((entry) => entry.id === run.projectId);
         const baseBranch = project?.github?.baseBranch ?? "main";
-        const publishedPrState = await this.detectPublishedPrState(issue, project?.github?.repoFullName);
+        const publishedPrState = await this.detectPublishedPrState(run, issue, project?.github?.repoFullName);
         if (publishedPrState === "open") {
             return undefined;
         }
@@ -24,18 +26,18 @@ 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") {
+        if (run.runType !== "implementation" && run.runType !== "main_repair") {
             return undefined;
         }
         const project = this.config.projects.find((entry) => entry.id === run.projectId);
-        const publishedPrState = await this.detectPublishedPrState(issue, project?.github?.repoFullName);
+        const publishedPrState = await this.detectPublishedPrState(run, issue, project?.github?.repoFullName);
         if (publishedPrState === "open" || publishedPrState === "unknown") {
             return undefined;
         }
         const baseBranch = project?.github?.baseBranch ?? "main";
         return await this.describeLocalImplementationOutcome(issue, baseBranch);
     }
-    async detectPublishedPrState(issue, repoFullName) {
+    async detectPublishedPrState(run, issue, repoFullName) {
         if (issue.prNumber && issue.prState && issue.prState !== "closed") {
             return "open";
         }
@@ -73,6 +75,9 @@ export class ImplementationOutcomePolicy {
                 ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
                 ...(pr.author?.login ? { prAuthorLogin: pr.author.login } : {}),
             }, "published PR verification refresh");
+            if (state !== "closed" && isMainRepairIssue(issue)) {
+                await this.ensurePriorityQueueLabel(run.projectId, pr.number, repoFullName);
+            }
             return state === "closed" ? "closed" : "open";
         }
         catch (error) {
@@ -133,4 +138,42 @@ 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");
+        }
+    }
 }

package/dist/issue-session-events.js

@@ -11,7 +11,7 @@ const NON_ACTIONABLE_SESSION_EVENTS = new Set([
     "delegation_observed",
     "run_released_authority",
 ]);
-const RUN_TYPES = new Set(["implementation", "review_fix", "branch_upkeep", "ci_repair", "queue_repair"]);
+const RUN_TYPES = new Set(["implementation", "main_repair", "review_fix", "branch_upkeep", "ci_repair", "queue_repair"]);
 function parseRunType(value) {
     return typeof value === "string" && RUN_TYPES.has(value) ? value : undefined;
 }
@@ -51,15 +51,12 @@ export function deriveSessionWakePlan(issue, events) {
                 break;
             case "delegated":
                 if (!runType) {
-                    runType = "implementation";
-                    wakeReason = issue.issueClass === "orchestration" ? "initial_delegate" : "delegated";
-                }
-                if (payload?.promptContext !== undefined) {
-                    context.promptContext = payload.promptContext;
-                }
-                if (payload?.promptBody !== undefined) {
-                    context.promptBody = payload.promptBody;
+                    runType = parseRunType(payload?.runType) ?? "implementation";
+                    wakeReason = runType === "main_repair"
+                        ? "main_repair"
+                        : issue.issueClass === "orchestration" ? "initial_delegate" : "delegated";
                 }
+                Object.assign(context, payload ?? {});
                 break;
             case "child_changed":
             case "child_delivered":

package/dist/issue-session.js

@@ -18,6 +18,8 @@ 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-client.js

@@ -109,6 +109,35 @@ export class LinearGraphqlClient {
         }
         return this.mapIssue(response.issue);
     }
+    async createIssue(params) {
+        const response = await this.request(`
+      mutation PatchRelayCreateIssue($input: IssueCreateInput!) {
+        issueCreate(input: $input) {
+          success
+          issue {
+            ${LINEAR_ISSUE_SELECTION}
+          }
+        }
+      }
+      `, {
+            input: {
+                teamId: params.teamId,
+                title: params.title,
+                ...(params.description ? { description: params.description } : {}),
+            },
+        });
+        if (!response.issueCreate.success || !response.issueCreate.issue) {
+            throw new Error(`Linear rejected issue creation for team ${params.teamId}`);
+        }
+        let issue = this.mapIssue(response.issueCreate.issue);
+        if (params.labelNames && params.labelNames.length > 0) {
+            issue = await this.updateIssueLabels({
+                issueId: issue.id,
+                addNames: params.labelNames,
+            });
+        }
+        return issue;
+    }
     async setIssueState(issueId, stateName) {
         const issue = await this.getIssue(issueId);
         const state = issue.workflowStates.find((entry) => entry.name.trim().toLowerCase() === stateName.trim().toLowerCase());

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

@@ -0,0 +1,196 @@
+import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
+import { buildMainRepairBranchName, buildMainRepairDescription, buildMainRepairPromptContext, buildMainRepairTitle, 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;
+    enqueueIssue;
+    logger;
+    feed;
+    constructor(db, config, linearProvider, enqueueIssue, logger, feed) {
+        this.db = db;
+        this.config = config;
+        this.linearProvider = linearProvider;
+        this.enqueueIssue = enqueueIssue;
+        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.db.listIssues().find((issue) => (issue.projectId === projectId
+            && issue.branchName === branchName
+            && isMainRepairIssue(issue)
+            && issue.factoryState !== "done"
+            && issue.factoryState !== "failed"
+            && issue.factoryState !== "escalated"));
+        const summary = await this.readMainBranchFailure(project.github.repoFullName, baseBranch);
+        if (!summary) {
+            if (existing) {
+                this.resolveRecoveredMainRepair(existing);
+            }
+            return;
+        }
+        const protocol = resolveMergeQueueProtocol(project);
+        if (existing) {
+            const age = Date.now() - Date.parse(existing.updatedAt);
+            if (age < MAIN_BRANCH_HEALTH_GRACE_MS) {
+                return;
+            }
+        }
+        if (existing) {
+            this.queueExistingMainRepair(existing, summary, protocol.priorityLabel);
+            return;
+        }
+        const client = await this.linearProvider.forProject(projectId);
+        if (!client?.createIssue) {
+            this.logger.warn({ projectId, repoFullName: project.github.repoFullName }, "Cannot create main repair issue because Linear issue creation is unavailable");
+            return;
+        }
+        const created = await client.createIssue({
+            teamId: project.linearTeamIds[0],
+            title: buildMainRepairTitle(project),
+            description: buildMainRepairDescription(project, summary, protocol.priorityLabel),
+        });
+        const issue = this.db.upsertIssue({
+            projectId,
+            linearIssueId: created.id,
+            delegatedToPatchRelay: true,
+            ...(created.identifier ? { issueKey: created.identifier } : {}),
+            ...(created.title ? { title: created.title } : {}),
+            ...(created.description ? { description: created.description } : {}),
+            ...(created.url ? { url: created.url } : {}),
+            ...(created.priority != null ? { priority: created.priority } : {}),
+            ...(created.estimate != null ? { estimate: created.estimate } : {}),
+            ...(created.stateName ? { currentLinearState: created.stateName } : {}),
+            ...(created.stateType ? { currentLinearStateType: created.stateType } : {}),
+            branchName,
+            factoryState: "delegated",
+        });
+        this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(projectId, issue.linearIssueId, {
+            projectId,
+            linearIssueId: issue.linearIssueId,
+            eventType: "delegated",
+            eventJson: JSON.stringify({
+                runType: "main_repair",
+                baseSha: summary.baseSha,
+                failingChecks: summary.failingChecks,
+                pendingChecks: summary.pendingChecks,
+                priorityLabel: protocol.priorityLabel,
+                promptContext: buildMainRepairPromptContext(project, summary, protocol.priorityLabel),
+            }),
+            dedupeKey: `main_repair:${projectId}:${summary.baseSha}:${summary.failingChecks.map((check) => check.name).join("|")}`,
+        });
+        if (this.db.issueSessions.peekIssueSessionWake(projectId, issue.linearIssueId)) {
+            this.enqueueIssue(projectId, issue.linearIssueId);
+        }
+        this.feed?.publish({
+            level: "warn",
+            kind: "github",
+            issueKey: issue.issueKey,
+            projectId,
+            stage: "delegated",
+            status: "main_repair_queued",
+            summary: `Queued main_repair for ${project.github.repoFullName}@${baseBranch}`,
+            detail: summary.failingChecks.map((check) => check.name).join(", "),
+        });
+    }
+    queueExistingMainRepair(issue, summary, priorityLabel) {
+        if (issue.activeRunId !== undefined)
+            return;
+        if (this.db.issueSessions.hasPendingIssueSessionEvents(issue.projectId, issue.linearIssueId))
+            return;
+        if (issue.prState === "open" || issue.factoryState === "awaiting_queue" || issue.factoryState === "pr_open")
+            return;
+        this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            eventType: "delegated",
+            eventJson: JSON.stringify({
+                runType: "main_repair",
+                baseSha: summary.baseSha,
+                failingChecks: summary.failingChecks,
+                pendingChecks: summary.pendingChecks,
+                priorityLabel,
+            }),
+            dedupeKey: `main_repair:${issue.projectId}:${summary.baseSha}:${summary.failingChecks.map((check) => check.name).join("|")}`,
+        });
+        if (this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
+            this.enqueueIssue(issue.projectId, issue.linearIssueId);
+        }
+    }
+    resolveRecoveredMainRepair(issue) {
+        if (issue.activeRunId !== undefined)
+            return;
+        if (issue.prState === "open" || issue.factoryState === "awaiting_queue" || issue.factoryState === "pr_open") {
+            return;
+        }
+        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

@@ -0,0 +1,47 @@
+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(" ");
+}

package/dist/merge-queue-protocol.js

@@ -1,10 +1,12 @@
 export const DEFAULT_MERGE_QUEUE_LABEL = "queue";
 export const DEFAULT_MERGE_QUEUE_CHECK_NAME = "merge-steward/queue";
+export const DEFAULT_PRIORITY_QUEUE_LABEL = "queue:priority";
 export function resolveMergeQueueProtocol(project) {
     return {
         repoFullName: project?.github?.repoFullName,
         baseBranch: project?.github?.baseBranch,
         admissionLabel: project?.github?.mergeQueueLabel ?? DEFAULT_MERGE_QUEUE_LABEL,
         evictionCheckName: project?.github?.mergeQueueCheckName ?? DEFAULT_MERGE_QUEUE_CHECK_NAME,
+        priorityLabel: project?.github?.priorityQueueLabel ?? DEFAULT_PRIORITY_QUEUE_LABEL,
     };
 }

package/dist/patchrelay-customization.js

@@ -7,6 +7,7 @@ const promptLayerSchema = z.object({
 });
 const promptByRunTypeSchema = z.object({
     implementation: promptLayerSchema.optional(),
+    main_repair: promptLayerSchema.optional(),
     review_fix: promptLayerSchema.optional(),
     branch_upkeep: promptLayerSchema.optional(),
     ci_repair: promptLayerSchema.optional(),

package/dist/prompting/patchrelay.js

@@ -3,6 +3,7 @@ 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",

package/dist/run-launcher.js

@@ -93,10 +93,11 @@ export class RunLauncher {
                 branchName: params.branchName,
                 worktreePath: params.worktreePath,
                 factoryState: params.runType === "implementation" ? "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 === "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" || params.runType === "queue_repair") && failureSignature
                     ? {
                         lastAttemptedFailureSignature: failureSignature,

package/dist/run-orchestrator.js

@@ -3,6 +3,7 @@ import { buildRunStartedActivity, } from "./linear-session-reporting.js";
 import { CompletionCheckService } from "./completion-check.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";
@@ -44,6 +45,7 @@ export class RunOrchestrator {
     feed;
     configPath;
     worktreeManager;
+    mainBranchHealthMonitor;
     /** Tracks last probe-failure feed event per issue to avoid spamming the operator feed. */
     queueHealthMonitor;
     idleReconciler;
@@ -103,6 +105,7 @@ export class RunOrchestrator {
         this.idleReconciler = new IdleIssueReconciler(db, config, {
             enqueueIssue: (projectId, issueId) => this.enqueueIssue(projectId, issueId),
         }, logger, feed);
+        this.mainBranchHealthMonitor = new MainBranchHealthMonitor(db, config, linearProvider, (projectId, issueId) => this.enqueueIssue(projectId, issueId), 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),
@@ -351,6 +354,7 @@ 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,6 +27,10 @@ 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.50.6",
+  "version": "0.51.1",
   "license": "MIT",
   "type": "module",
   "repository": {