patchrelay 0.35.11 → 0.35.13

package/dist/linear-client.js

@@ -23,27 +23,33 @@ const LINEAR_ISSUE_SELECTION = `
       name
     }
   }
-  blockedBy {
+  inverseRelations {
     nodes {
-      id
-      identifier
-      title
-      state {
+      type
+      issue {
         id
-        name
-        type
+        identifier
+        title
+        state {
+          id
+          name
+          type
+        }
       }
     }
   }
-  blocks {
+  relations {
     nodes {
-      id
-      identifier
-      title
-      state {
+      type
+      relatedIssue {
         id
-        name
-        type
+        identifier
+        title
+        state {
+          id
+          name
+          type
+        }
       }
     }
   }
@@ -92,19 +98,16 @@ export class LinearGraphqlClient {
             throw new Error(`Linear state "${stateName}" was not found for issue ${issue.identifier ?? issueId}`);
         }
         const response = await this.request(`
-      mutation PatchRelaySetIssueState($id: String!, $stateId: String!) {
-        issueUpdate(id: $id, input: { stateId: $stateId }) {
+      mutation PatchRelaySetIssueState($id: String!, $input: IssueUpdateInput!) {
+        issueUpdate(id: $id, input: $input) {
           success
-          issue {
-            ${LINEAR_ISSUE_SELECTION}
-          }
         }
       }
-      `, { id: issueId, stateId: state.id });
-        if (!response.issueUpdate.success || !response.issueUpdate.issue) {
+      `, { id: issueId, input: { stateId: state.id } });
+        if (!response.issueUpdate.success) {
             throw new Error(`Linear rejected state update for issue ${issue.identifier ?? issueId}`);
         }
-        return this.mapIssue(response.issueUpdate.issue);
+        return await this.getIssue(issueId);
     }
     async upsertIssueComment(params) {
         if (params.commentId) {
@@ -292,7 +295,10 @@ export class LinearGraphqlClient {
             }),
         });
         if (!response.ok) {
-            throw new Error(`Linear API request failed with HTTP ${response.status}`);
+            const body = (await response.text()).trim();
+            throw new Error(body
+                ? `Linear API request failed with HTTP ${response.status}: ${body}`
+                : `Linear API request failed with HTTP ${response.status}`);
         }
         const payload = (await response.json());
         if (payload.errors?.length) {
@@ -308,6 +314,8 @@ export class LinearGraphqlClient {
     mapIssue(issue) {
         const labels = (issue.labels?.nodes ?? []).map((label) => ({ id: label.id, name: label.name }));
         const teamLabels = (issue.team?.labels?.nodes ?? []).map((label) => ({ id: label.id, name: label.name }));
+        const blocksRelations = (issue.relations?.nodes ?? []).filter((relation) => relation.type?.trim().toLowerCase() === "blocks");
+        const blockedByRelations = (issue.inverseRelations?.nodes ?? []).filter((relation) => relation.type?.trim().toLowerCase() === "blocks");
         return {
             id: issue.id,
             ...(issue.identifier ? { identifier: issue.identifier } : {}),
@@ -331,8 +339,14 @@ export class LinearGraphqlClient {
             labelIds: labels.map((label) => label.id),
             labels,
             teamLabels,
-            blockedBy: (issue.blockedBy?.nodes ?? []).map(mapIssueRelation),
-            blocks: (issue.blocks?.nodes ?? []).map(mapIssueRelation),
+            blockedBy: blockedByRelations
+                .map((relation) => relation.issue)
+                .filter((relation) => Boolean(relation))
+                .map(mapIssueRelation),
+            blocks: blocksRelations
+                .map((relation) => relation.relatedIssue)
+                .filter((relation) => Boolean(relation))
+                .map(mapIssueRelation),
         };
     }
     resolveLabelIds(issue, names) {

package/dist/linear-session-reporting.js

@@ -147,6 +147,18 @@ export function buildMergePrepEscalationActivity(attempts) {
     };
 }
 export function summarizeIssueStateForLinear(issue) {
+    switch (issue.sessionState) {
+        case "waiting_input":
+            return issue.waitingReason ?? (issue.prNumber ? `PR #${issue.prNumber} is waiting for input.` : "Waiting for input.");
+        case "running":
+            return issue.prNumber ? `PR #${issue.prNumber} is actively running.` : "Actively running.";
+        case "idle":
+            return issue.waitingReason ?? (issue.prNumber ? `PR #${issue.prNumber} is idle.` : "Idle.");
+        case "done":
+            return issue.prNumber ? `PR #${issue.prNumber} has merged.` : "Change merged.";
+        case "failed":
+            return issue.waitingReason ?? (issue.prNumber ? `PR #${issue.prNumber} needs help to recover.` : "Needs help to recover.");
+    }
     switch (issue.factoryState) {
         case "pr_open":
             return issue.prNumber ? `PR #${issue.prNumber} is awaiting review.` : "Awaiting review.";

package/dist/linear-session-sync.js

@@ -1,5 +1,8 @@
 import { buildAgentSessionPlanForIssue } from "./agent-session-plan.js";
 import { buildAgentSessionExternalUrls } from "./agent-session-presentation.js";
+import { deriveIssueStatusNote } from "./status-note.js";
+import { derivePatchRelayWaitingReason } from "./waiting-reason.js";
+import { resolvePreferredReviewLinearState, resolvePreferredStartedLinearState } from "./linear-workflow.js";
 const PROGRESS_THROTTLE_MS = 5_000;
 export class LinearSessionSync {
     config;
@@ -15,57 +18,119 @@ export class LinearSessionSync {
         this.logger = logger;
         this.feed = feed;
     }
+    ensureAgentSessionIssue(issue) {
+        if (issue.agentSessionId) {
+            return issue;
+        }
+        const recoveredAgentSessionId = this.db.findLatestAgentSessionIdForIssue(issue.linearIssueId);
+        if (!recoveredAgentSessionId)
+            return issue;
+        this.logger.info({ issueKey: issue.issueKey, agentSessionId: recoveredAgentSessionId }, "Recovered missing Linear agent session id from webhook history");
+        return this.db.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            agentSessionId: recoveredAgentSessionId,
+        });
+    }
     async emitActivity(issue, content, options) {
-        if (!issue.agentSessionId)
+        const syncedIssue = this.ensureAgentSessionIssue(issue);
+        if (!syncedIssue.agentSessionId)
             return;
         try {
-            const linear = await this.linearProvider.forProject(issue.projectId);
+            const linear = await this.linearProvider.forProject(syncedIssue.projectId);
             if (!linear)
                 return;
             const allowEphemeral = content.type === "thought" || content.type === "action";
             await linear.createAgentActivity({
-                agentSessionId: issue.agentSessionId,
+                agentSessionId: syncedIssue.agentSessionId,
                 content,
                 ...(options?.ephemeral && allowEphemeral ? { ephemeral: true } : {}),
             });
         }
         catch (error) {
             const msg = error instanceof Error ? error.message : String(error);
-            this.logger.warn({ issueKey: issue.issueKey, type: content.type, error: msg }, "Failed to emit Linear activity");
+            this.logger.warn({ issueKey: syncedIssue.issueKey, type: content.type, error: msg }, "Failed to emit Linear activity");
             this.feed?.publish({
                 level: "warn",
                 kind: "linear",
-                issueKey: issue.issueKey,
-                projectId: issue.projectId,
+                issueKey: syncedIssue.issueKey,
+                projectId: syncedIssue.projectId,
                 status: "linear_error",
                 summary: `Linear activity failed: ${msg}`,
             });
         }
     }
     async syncSession(issue, options) {
-        if (!issue.agentSessionId)
-            return;
+        const syncedIssue = this.ensureAgentSessionIssue(issue);
         try {
-            const linear = await this.linearProvider.forProject(issue.projectId);
-            if (!linear?.updateAgentSession)
+            const linear = await this.linearProvider.forProject(syncedIssue.projectId);
+            if (!linear)
                 return;
-            const externalUrls = buildAgentSessionExternalUrls(this.config, {
-                ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
-                ...(issue.prUrl ? { prUrl: issue.prUrl } : {}),
-            });
-            await linear.updateAgentSession({
-                agentSessionId: issue.agentSessionId,
-                plan: buildAgentSessionPlanForIssue(issue, options),
-                ...(externalUrls ? { externalUrls } : {}),
-            });
+            const trackedIssue = this.db.getTrackedIssue(syncedIssue.projectId, syncedIssue.linearIssueId);
+            await this.syncActiveWorkflowState(syncedIssue, linear, trackedIssue, options);
+            if (syncedIssue.agentSessionId && linear.updateAgentSession) {
+                const externalUrls = buildAgentSessionExternalUrls(this.config, {
+                    ...(syncedIssue.issueKey ? { issueKey: syncedIssue.issueKey } : {}),
+                    ...(syncedIssue.prUrl ? { prUrl: syncedIssue.prUrl } : {}),
+                });
+                await linear.updateAgentSession({
+                    agentSessionId: syncedIssue.agentSessionId,
+                    plan: buildAgentSessionPlanForIssue(syncedIssue, options),
+                    ...(externalUrls ? { externalUrls } : {}),
+                });
+            }
+            if (shouldSyncVisibleIssueComment(trackedIssue ?? syncedIssue, Boolean(syncedIssue.agentSessionId))) {
+                await this.syncStatusComment(syncedIssue, linear, options);
+            }
         }
         catch (error) {
             const msg = error instanceof Error ? error.message : String(error);
-            this.logger.warn({ issueKey: issue.issueKey, error: msg }, "Failed to update Linear plan");
+            this.logger.warn({ issueKey: syncedIssue.issueKey, error: msg }, "Failed to update Linear plan");
         }
     }
+    async syncActiveWorkflowState(issue, linear, trackedIssue, options) {
+        if (!shouldAutoAdvanceLinearState(issue)) {
+            return;
+        }
+        const liveIssue = await linear.getIssue(issue.linearIssueId).catch(() => undefined);
+        if (!liveIssue)
+            return;
+        if (!shouldAutoAdvanceLinearState({
+            currentLinearState: liveIssue.stateName,
+            currentLinearStateType: liveIssue.stateType,
+        })) {
+            this.db.upsertIssue({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
+                ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
+            });
+            return;
+        }
+        const targetState = resolveDesiredActiveWorkflowState(issue, trackedIssue, options, liveIssue);
+        if (!targetState)
+            return;
+        const normalizedCurrent = liveIssue.stateName?.trim().toLowerCase();
+        if (normalizedCurrent === targetState.trim().toLowerCase()) {
+            this.db.upsertIssue({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
+                ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
+            });
+            return;
+        }
+        const updated = await linear.setIssueState(issue.linearIssueId, targetState);
+        this.db.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            ...(updated.stateName ? { currentLinearState: updated.stateName } : {}),
+            ...(updated.stateType ? { currentLinearStateType: updated.stateType } : {}),
+        });
+    }
     async syncCodexPlan(issue, params) {
-        if (!issue.agentSessionId)
+        const syncedIssue = this.ensureAgentSessionIssue(issue);
+        if (!syncedIssue.agentSessionId)
             return;
         const plan = params.plan;
         if (!Array.isArray(plan))
@@ -87,17 +152,17 @@ export class LinearSessionSync {
             { content: "Merge", status: "pending" },
         ];
         try {
-            const linear = await this.linearProvider.forProject(issue.projectId);
+            const linear = await this.linearProvider.forProject(syncedIssue.projectId);
             if (!linear?.updateAgentSession)
                 return;
             await linear.updateAgentSession({
-                agentSessionId: issue.agentSessionId,
+                agentSessionId: syncedIssue.agentSessionId,
                 plan: fullPlan,
             });
         }
         catch (error) {
             const msg = error instanceof Error ? error.message : String(error);
-            this.logger.warn({ issueKey: issue.issueKey, error: msg }, "Failed to sync codex plan to Linear");
+            this.logger.warn({ issueKey: syncedIssue.issueKey, error: msg }, "Failed to sync codex plan to Linear");
         }
     }
     maybeEmitProgress(notification, run) {
@@ -117,6 +182,28 @@ export class LinearSessionSync {
     clearProgress(runId) {
         this.progressThrottle.delete(runId);
     }
+    async syncStatusComment(issue, linear, options) {
+        try {
+            const trackedIssue = this.db.getTrackedIssue(issue.projectId, issue.linearIssueId);
+            const body = renderStatusComment(this.db, issue, trackedIssue, options);
+            const result = await linear.upsertIssueComment({
+                issueId: issue.linearIssueId,
+                ...(issue.statusCommentId ? { commentId: issue.statusCommentId } : {}),
+                body,
+            });
+            if (result.id !== issue.statusCommentId) {
+                this.db.upsertIssue({
+                    projectId: issue.projectId,
+                    linearIssueId: issue.linearIssueId,
+                    statusCommentId: result.id,
+                });
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger.warn({ issueKey: issue.issueKey, error: msg }, "Failed to sync Linear status comment");
+        }
+    }
 }
 function resolveProgressActivity(notification) {
     if (notification.method === "item/started") {
@@ -141,3 +228,145 @@ function resolveProgressActivity(notification) {
     }
     return undefined;
 }
+function renderStatusComment(db, issue, trackedIssue, options) {
+    const activeRun = issue.activeRunId ? db.getRun(issue.activeRunId) : undefined;
+    const latestRun = db.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
+    const latestEvent = db.listIssueSessionEvents(issue.projectId, issue.linearIssueId, { limit: 1 }).at(-1);
+    const activeRunType = issue.activeRunId !== undefined
+        ? (options?.activeRunType ?? activeRun?.runType)
+        : undefined;
+    const waitingReason = trackedIssue?.waitingReason ?? derivePatchRelayWaitingReason({
+        ...(activeRunType ? { activeRunType } : {}),
+        ...(issue.activeRunId !== undefined ? { activeRunId: issue.activeRunId } : {}),
+        factoryState: issue.factoryState,
+        pendingRunType: issue.pendingRunType,
+        ...(issue.prNumber !== undefined ? { prNumber: issue.prNumber } : {}),
+        prReviewState: issue.prReviewState,
+        prCheckStatus: issue.prCheckStatus,
+        latestFailureCheckName: issue.lastGitHubFailureCheckName,
+    });
+    const lines = [
+        "## PatchRelay status",
+        "",
+        statusHeadline(trackedIssue ?? issue, activeRunType),
+    ];
+    const statusNote = trackedIssue?.statusNote ?? deriveIssueStatusNote({ issue, latestRun, latestEvent, waitingReason });
+    if (waitingReason) {
+        lines.push("", `Waiting: ${waitingReason}`);
+    }
+    if (statusNote && statusNote !== waitingReason) {
+        const label = trackedIssue?.sessionState === "waiting_input" || issue.factoryState === "awaiting_input" ? "Input needed"
+            : trackedIssue?.sessionState === "failed" || issue.factoryState === "failed" || issue.factoryState === "escalated" ? "Action needed"
+                : "Note";
+        lines.push("", `${label}: ${statusNote}`);
+    }
+    if (issue.prNumber !== undefined || issue.prUrl) {
+        const prLabel = issue.prNumber !== undefined ? `#${issue.prNumber}` : "open";
+        lines.push("", `PR: ${issue.prUrl ? `[${prLabel}](${issue.prUrl})` : prLabel}`);
+    }
+    if (latestRun) {
+        lines.push("", `Latest run: ${formatLatestRun(latestRun)}`);
+        if (latestRun.failureReason) {
+            lines.push("", `Failure: ${latestRun.failureReason}`);
+        }
+    }
+    if (issue.lastGitHubFailureCheckName && (issue.factoryState === "repairing_ci" || issue.prCheckStatus === "failed" || issue.prCheckStatus === "failure")) {
+        lines.push("", `Latest failing check: ${issue.lastGitHubFailureCheckName}`);
+    }
+    lines.push("", "_PatchRelay updates this comment as it works. Review and merge remain downstream._");
+    return lines.join("\n");
+}
+function shouldSyncVisibleIssueComment(issue, hasAgentSession) {
+    if (!hasAgentSession) {
+        return true;
+    }
+    if (issue.sessionState === "waiting_input" || issue.sessionState === "failed"
+        || issue.factoryState === "awaiting_input" || issue.factoryState === "failed" || issue.factoryState === "escalated") {
+        return true;
+    }
+    if ((issue.sessionState === "done" || issue.factoryState === "done") && issue.prNumber === undefined && !issue.prUrl) {
+        return true;
+    }
+    return false;
+}
+function statusHeadline(issue, activeRunType) {
+    if (activeRunType) {
+        return `Running ${humanize(activeRunType)}`;
+    }
+    switch (issue.sessionState) {
+        case "waiting_input":
+            return issue.waitingReason ?? "Waiting for more input";
+        case "running":
+            return issue.prNumber !== undefined ? `PR #${issue.prNumber} is actively running` : "Actively running";
+        case "done":
+            return issue.prNumber !== undefined ? `Completed with PR #${issue.prNumber}` : "Completed";
+        case "failed":
+            return "Needs operator intervention";
+        default:
+            break;
+    }
+    switch (issue.factoryState) {
+        case "delegated":
+            return "Queued to start work";
+        case "implementing":
+            return "Implementing requested change";
+        case "pr_open":
+            return issue.prNumber !== undefined ? `PR #${issue.prNumber} opened` : "PR opened";
+        case "changes_requested":
+            return "Addressing requested review changes";
+        case "repairing_ci":
+            return "Repairing failing CI";
+        case "awaiting_queue":
+            return "Handed off downstream for merge";
+        case "repairing_queue":
+            return "Repairing merge handoff";
+        case "awaiting_input":
+            return "Waiting for more input";
+        case "failed":
+            return "Needs operator intervention";
+        case "escalated":
+            return "Needs operator intervention";
+        case "done":
+            return issue.prNumber !== undefined ? `Completed with PR #${issue.prNumber}` : "Completed";
+        default:
+            return humanize(issue.factoryState);
+    }
+}
+function formatLatestRun(run) {
+    const at = run.endedAt ?? run.startedAt;
+    return `${humanize(run.runType)} ${run.status} at ${at}`;
+}
+function humanize(value) {
+    return value.replaceAll("_", " ");
+}
+function shouldAutoAdvanceLinearState(issue) {
+    const normalizedType = issue.currentLinearStateType?.trim().toLowerCase();
+    if (normalizedType === "backlog" || normalizedType === "unstarted") {
+        return true;
+    }
+    const normalizedName = issue.currentLinearState?.trim().toLowerCase();
+    return normalizedName === "backlog" || normalizedName === "todo" || normalizedName === "to do" || normalizedName === "triage";
+}
+function resolveDesiredActiveWorkflowState(issue, trackedIssue, options, liveIssue) {
+    const reviewBound = issue.prNumber !== undefined
+        || Boolean(issue.prUrl)
+        || issue.factoryState === "pr_open"
+        || issue.factoryState === "awaiting_queue"
+        || issue.factoryState === "changes_requested"
+        || issue.factoryState === "repairing_ci"
+        || issue.factoryState === "repairing_queue"
+        || issue.prReviewState !== undefined
+        || issue.prCheckStatus !== undefined;
+    if (reviewBound) {
+        return resolvePreferredReviewLinearState(liveIssue);
+    }
+    const activelyWorking = issue.activeRunId !== undefined
+        || options?.activeRunType !== undefined
+        || trackedIssue?.sessionState === "running"
+        || issue.factoryState === "delegated"
+        || issue.factoryState === "implementing";
+    if (activelyWorking) {
+        return resolvePreferredStartedLinearState(liveIssue);
+    }
+    return undefined;
+}

package/dist/linear-workflow.js

@@ -2,6 +2,39 @@ function normalizeLinearState(value) {
     const trimmed = value?.trim();
     return trimmed ? trimmed.toLowerCase() : undefined;
 }
+export function resolvePreferredStartedLinearState(issue) {
+    const startedStates = issue.workflowStates.filter((state) => normalizeLinearState(state.type) === "started");
+    const preferred = startedStates.find((state) => {
+        const normalized = normalizeLinearState(state.name);
+        return normalized === "in progress" || normalized === "in-progress" || normalized === "started" || normalized === "doing";
+    });
+    return preferred?.name ?? startedStates[0]?.name;
+}
+export function resolvePreferredReviewLinearState(issue) {
+    const reviewState = issue.workflowStates.find((state) => {
+        if (normalizeLinearState(state.type) !== "started")
+            return false;
+        const normalized = normalizeLinearState(state.name);
+        return normalized === "in review" || normalized === "review";
+    });
+    return reviewState?.name ?? resolvePreferredStartedLinearState(issue);
+}
+export function resolvePreferredCompletedLinearState(issue) {
+    const completed = issue.workflowStates.find((state) => normalizeLinearState(state.type) === "completed");
+    if (completed?.name) {
+        return completed.name;
+    }
+    const currentStateName = issue.stateName?.trim();
+    const normalizedCurrentState = normalizeLinearState(currentStateName);
+    if (normalizedCurrentState === "done" || normalizedCurrentState === "completed" || normalizedCurrentState === "complete") {
+        return currentStateName;
+    }
+    const named = issue.workflowStates.find((state) => {
+        const normalized = normalizeLinearState(state.name);
+        return normalized === "done" || normalized === "completed" || normalized === "complete";
+    });
+    return named?.name;
+}
 export function resolveAuthoritativeLinearStopState(issue) {
     const currentStateName = issue.stateName?.trim();
     const normalizedCurrentState = normalizeLinearState(currentStateName);

package/dist/merge-queue-protocol.js

@@ -1,4 +1,3 @@
-import { execCommand } from "./utils.js";
 export const DEFAULT_MERGE_QUEUE_LABEL = "queue";
 export const DEFAULT_MERGE_QUEUE_CHECK_NAME = "merge-steward/queue";
 export function resolveMergeQueueProtocol(project) {
@@ -9,53 +8,3 @@ export function resolveMergeQueueProtocol(project) {
         evictionCheckName: project?.github?.mergeQueueCheckName ?? DEFAULT_MERGE_QUEUE_CHECK_NAME,
     };
 }
-export async function requestMergeQueueAdmission(params) {
-    const { issue, protocol, logger, feed } = params;
-    if (!protocol.repoFullName || !issue.prNumber)
-        return false;
-    feed?.publish({
-        level: "info",
-        kind: "github",
-        issueKey: issue.issueKey,
-        projectId: issue.projectId,
-        stage: "awaiting_queue",
-        status: "queue_label_requested",
-        summary: `Queue hand-off requested via label "${protocol.admissionLabel}" on PR #${issue.prNumber}`,
-    });
-    try {
-        const [owner, repo] = protocol.repoFullName.split("/", 2);
-        if (!owner || !repo) {
-            throw new Error(`Invalid repoFullName: ${protocol.repoFullName}`);
-        }
-        await execCommand("gh", [
-            "api",
-            "--method", "POST",
-            `repos/${owner}/${repo}/issues/${issue.prNumber}/labels`,
-            "-f", `labels[]=${protocol.admissionLabel}`,
-        ], { timeoutMs: 15_000 });
-        feed?.publish({
-            level: "info",
-            kind: "github",
-            issueKey: issue.issueKey,
-            projectId: issue.projectId,
-            stage: "awaiting_queue",
-            status: "queue_label_applied",
-            summary: `Queue label "${protocol.admissionLabel}" applied to PR #${issue.prNumber}`,
-        });
-        return true;
-    }
-    catch (error) {
-        logger.warn({ issueKey: issue.issueKey, err: error }, "Failed to add merge queue label");
-        feed?.publish({
-            level: "warn",
-            kind: "github",
-            issueKey: issue.issueKey,
-            projectId: issue.projectId,
-            stage: "awaiting_queue",
-            status: "queue_label_failed",
-            summary: `Queue hand-off failed while adding label "${protocol.admissionLabel}" to PR #${issue.prNumber}`,
-            detail: error instanceof Error ? error.message : String(error),
-        });
-        return false;
-    }
-}

package/dist/preflight.js

@@ -283,7 +283,7 @@ function checkGitHubProtocol(project, publicBaseUrl) {
         ];
     }
     const checks = [
-        pass(scope, `GitHub protocol configured for ${protocol.repoFullName} (label "${protocol.admissionLabel}", eviction check "${protocol.evictionCheckName}")`),
+        pass(scope, `GitHub protocol configured for ${protocol.repoFullName} (base "${protocol.baseBranch ?? "main"}", queue incident check "${protocol.evictionCheckName}")`),
     ];
     if (!publicBaseUrl) {
         checks.push(warn(scope, "PatchRelay public base URL is not configured; public operator/session links will be incomplete"));
@@ -291,9 +291,6 @@ function checkGitHubProtocol(project, publicBaseUrl) {
     if (!protocol.baseBranch) {
         checks.push(warn(scope, "GitHub base branch is not configured; defaults may diverge from the target repository"));
     }
-    if (!protocol.admissionLabel.trim()) {
-        checks.push(fail(scope, "Merge queue admission label must not be empty"));
-    }
     if (!protocol.evictionCheckName.trim()) {
         checks.push(fail(scope, "Merge queue eviction check name must not be empty"));
     }

package/dist/queue-health-monitor.js

@@ -44,7 +44,7 @@ export class QueueHealthMonitor {
             const { stdout } = await execCommand("gh", [
                 "pr", "view", String(issue.prNumber),
                 "--repo", project.github.repoFullName,
-                "--json", "state,mergeable,mergeStateStatus,headRefOid,labels",
+                "--json", "state,mergeable,mergeStateStatus,headRefOid",
             ], { timeoutMs: 10_000 });
             pr = JSON.parse(stdout);
         }
@@ -74,9 +74,6 @@ export class QueueHealthMonitor {
         }
         if (pr.state !== "OPEN")
             return;
-        const hasQueueLabel = pr.labels?.some((l) => l.name === protocol.admissionLabel) ?? false;
-        if (!hasQueueLabel)
-            return;
         const isDirty = pr.mergeStateStatus === "DIRTY" || pr.mergeable === "CONFLICTING";
         let hasEvictionCheckRun = false;
         if (!isDirty) {
@@ -110,10 +107,17 @@ export class QueueHealthMonitor {
                 lastAttemptedFailureHeadSha: headRefOid,
                 lastAttemptedFailureSignature: signature,
             });
-            this.advancer.advanceIdleIssue(issue, "repairing_queue", {
-                pendingRunType: "queue_repair",
-                pendingRunContext,
+            this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                eventType: "merge_steward_incident",
+                eventJson: JSON.stringify(pendingRunContext),
+                dedupeKey: `queue_health:queue_repair:${issue.linearIssueId}:${signature}`,
             });
+            this.advancer.advanceIdleIssue(issue, "repairing_queue");
+            if (this.db.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
+                this.advancer.enqueueIssue(issue.projectId, issue.linearIssueId);
+            }
             this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, headRefOid, reason }, "Queue health: queue issue detected, dispatching repair");
             this.feed?.publish({
                 level: "warn",