patchrelay 0.70.0 → 0.71.1

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.70.0",
-  "commit": "b70636ecd6d4",
-  "builtAt": "2026-05-23T19:04:31.282Z"
+  "version": "0.71.1",
+  "commit": "a52a4e7f91af",
+  "builtAt": "2026-05-23T22:11:42.868Z"
 }

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

@@ -1,6 +1,5 @@
-import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
 import { resolvePreferredCompletedLinearState } from "./linear-workflow.js";
-import { buildMainRepairBranchName, buildMainRepairDescription, buildMainRepairPromptContext, buildMainRepairTitle, isMainRepairIssue, } from "./main-repair.js";
+import { buildMainRepairBranchName, isMainRepairIssue, } from "./main-repair.js";
 import { execCommand } from "./utils.js";
 const MAIN_BRANCH_HEALTH_GRACE_MS = 120_000;
 function isUnhealthyMainConclusion(conclusion) {
@@ -14,14 +13,14 @@ export class MainBranchHealthMonitor {
     db;
     config;
     linearProvider;
-    wakeDispatcher;
     logger;
     feed;
-    constructor(db, config, linearProvider, wakeDispatcher, 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.wakeDispatcher = wakeDispatcher;
         this.logger = logger;
         this.feed = feed;
     }
@@ -46,64 +45,27 @@ export class MainBranchHealthMonitor {
             }
             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");
+        // 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;
         }
-        const created = await client.createIssue({
-            teamId: project.linearTeamIds[0],
-            title: buildMainRepairTitle(project),
-            description: buildMainRepairDescription(project, summary, protocol.priorityLabel),
-        });
-        const issue = this.db.upsertIssue({
+        this.lastUnhealthyReportAt.set(projectId, now);
+        this.logger.warn({
             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.wakeDispatcher.recordEventAndDispatch(projectId, 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("|")}`,
-        });
-        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(", "),
-        });
+            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()
@@ -132,35 +94,6 @@ export class MainBranchHealthMonitor {
             return 3;
         return 4;
     }
-    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.upsertIssue({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            delegatedToPatchRelay: true,
-            factoryState: "delegated",
-            pendingRunType: null,
-            pendingRunContextJson: null,
-            activeRunId: null,
-        });
-        this.wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
-            eventType: "delegated",
-            eventJson: JSON.stringify({
-                runType: "main_repair",
-                baseSha: summary.baseSha,
-                failingChecks: summary.failingChecks,
-                pendingChecks: summary.pendingChecks,
-                priorityLabel,
-                promptContext: buildMainRepairPromptContext(this.config.projects.find((project) => project.id === issue.projectId) ?? { id: issue.projectId }, summary, priorityLabel),
-            }),
-            dedupeKey: `main_repair:${issue.projectId}:${summary.baseSha}:${summary.failingChecks.map((check) => check.name).join("|")}`,
-        });
-    }
     async resolveRecoveredMainRepair(issue) {
         if (issue.activeRunId !== undefined)
             return;

package/dist/run-orchestrator.js

@@ -137,7 +137,7 @@ 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, 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),

package/package.json

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

package/service.env.example

@@ -12,8 +12,11 @@ LINEAR_OAUTH_CLIENT_ID=replace-with-linear-oauth-client-id
 LINEAR_OAUTH_CLIENT_SECRET=replace-with-linear-oauth-client-secret
 
 # Optional: GitHub App for bot identity.
-# When configured, PatchRelay generates short-lived installation tokens
-# and writes a gh wrapper so Codex operates as app-name[bot].
+# When configured, PatchRelay mints short-lived installation tokens and keeps a
+# private gh config dir fresh (GH_CONFIG_DIR), so both gh and git authenticate as
+# app-name[bot] with an always-fresh token. git reads credentials from gh via the
+# credential helper; nothing is written into repo or global git config, so these
+# credentials never leak into interactive shell sessions.
 # Create a GitHub App at Settings > Developer settings > GitHub Apps.
 #
 # The private key resolves through the provider-agnostic fallback: