patchrelay 0.35.17 → 0.36.0

package/dist/cli/commands/cluster.js

@@ -0,0 +1,14 @@
+import { collectClusterHealth } from "../cluster-health.js";
+import { CliUsageError } from "../errors.js";
+import { formatJson } from "../formatters/json.js";
+import { writeOutput } from "../output.js";
+import { formatClusterHealth } from "../output.js";
+export async function handleClusterCommand(params) {
+    const subcommand = params.commandArgs[0];
+    if (subcommand) {
+        throw new CliUsageError(`Unknown cluster command: ${subcommand}`, "cluster");
+    }
+    const report = await collectClusterHealth(params.config, params.data.db, params.runCommand);
+    writeOutput(params.stdout, params.json ? formatJson(report) : formatClusterHealth(report));
+    return report.ok ? 0 : 1;
+}

package/dist/cli/data.js

@@ -180,6 +180,7 @@ export class CliDataAccess extends CliOperatorApiClient {
         if (!issue)
             return undefined;
         const dbIssue = this.db.getIssueByKey(issueKey);
+        const issueSession = this.db.getIssueSession(issue.projectId, issue.linearIssueId);
         if (dbIssue.activeRunId !== undefined) {
             throw new Error(`Issue ${issueKey} already has an active run.`);
         }
@@ -189,13 +190,13 @@ export class CliDataAccess extends CliOperatorApiClient {
                 : dbIssue.prCheckStatus === "failed" || dbIssue.prCheckStatus === "failure" || issue.latestFailureSource === "branch_ci" || issue.factoryState === "repairing_ci"
                     ? "ci_repair"
                     : dbIssue.prReviewState === "changes_requested" || issue.factoryState === "changes_requested"
-                        ? "review_fix"
+                        ? (dbIssue.pendingRunType === "branch_upkeep" || issueSession?.lastRunType === "branch_upkeep" ? "branch_upkeep" : "review_fix")
                         : "implementation"));
         const factoryState = runType === "queue_repair"
             ? "repairing_queue"
             : runType === "ci_repair"
                 ? "repairing_ci"
-                : runType === "review_fix"
+                : runType === "review_fix" || runType === "branch_upkeep"
                     ? "changes_requested"
                     : "delegated";
         this.appendRetryWake(dbIssue, runType);
@@ -273,16 +274,19 @@ export class CliDataAccess extends CliOperatorApiClient {
             });
             return;
         }
-        if (runType === "review_fix") {
+        if (runType === "review_fix" || runType === "branch_upkeep") {
             this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 eventType: "review_changes_requested",
                 eventJson: JSON.stringify({
-                    reviewBody: "Operator requested retry of review-fix work.",
+                    reviewBody: runType === "branch_upkeep"
+                        ? "Operator requested retry of branch upkeep after requested changes."
+                        : "Operator requested retry of review-fix work.",
+                    ...(runType === "branch_upkeep" ? { branchUpkeepRequired: true, wakeReason: "branch_upkeep" } : {}),
                     source: "operator_retry",
                 }),
-                dedupeKey: `operator_retry:review_fix:${issue.linearIssueId}:${issue.prHeadSha ?? "unknown-sha"}`,
+                dedupeKey: `operator_retry:${runType}:${issue.linearIssueId}:${issue.prHeadSha ?? "unknown-sha"}`,
             });
             return;
         }

package/dist/cli/help.js

@@ -38,6 +38,7 @@ export function rootHelpText() {
         "  issue open <issueKey> [--print] [--json]                Open Codex in the issue worktree",
         "  issue sessions <issueKey> [--json]                      Show recorded Codex app-server sessions for one issue",
         "  service status [--json]                                 Show systemd state and local health",
+        "  cluster [--json]                                        Check service + workflow health across all tracked issues",
         "  service logs [--lines <count>] [--json]                 Show recent service logs",
         "  serve                                                   Run the local PatchRelay service",
         "",
@@ -62,6 +63,7 @@ export function rootHelpText() {
         "  patchrelay issue list --active",
         "  patchrelay issue watch USE-54",
         "  patchrelay service status",
+        "  patchrelay cluster",
         "  patchrelay version --json",
         "",
         "Command help:",
@@ -70,6 +72,7 @@ export function rootHelpText() {
         "  patchrelay help repo",
         "  patchrelay help issue",
         "  patchrelay help service",
+        "  patchrelay help cluster",
     ].join("\n");
 }
 export function linearHelpText() {
@@ -171,8 +174,26 @@ export function serviceHelpText() {
         "  patchrelay service logs --lines 100",
     ].join("\n");
 }
+export function clusterHelpText() {
+    return [
+        "Usage:",
+        "  patchrelay cluster [--json]",
+        "",
+        "Behavior:",
+        "  Aggregates local PatchRelay service health with workflow checks for every",
+        "  tracked non-done issue. The command looks for unmanaged blockers, lost",
+        "  dispatch, stale PR handoffs, and downstream waits that no longer have a",
+        "  healthy automation owner.",
+        "",
+        "Examples:",
+        "  patchrelay cluster",
+        "  patchrelay cluster --json",
+    ].join("\n");
+}
 export function helpTextFor(topic) {
     switch (topic) {
+        case "cluster":
+            return clusterHelpText();
         case "linear":
             return linearHelpText();
         case "repo":

package/dist/cli/index.js

@@ -2,6 +2,7 @@ import { loadConfig } from "../config.js";
 import { getBuildInfo } from "../build-info.js";
 import { assertKnownFlags, hasHelpFlag, parseArgs, resolveCommand } from "./args.js";
 import { handleIssueCommand, } from "./commands/issues.js";
+import { handleClusterCommand } from "./commands/cluster.js";
 import { handleLinearCommand } from "./commands/linear.js";
 import { handleRepoCommand } from "./commands/repo.js";
 import { handleInitCommand, handleServiceCommand } from "./commands/setup.js";
@@ -20,6 +21,7 @@ function getCommandConfigProfile(command) {
         case "linear":
         case "dashboard":
             return "operator_cli";
+        case "cluster":
         case "repo":
         case "issue":
             return "cli";
@@ -73,6 +75,9 @@ function validateFlags(command, commandArgs, parsed) {
         case "doctor":
             assertKnownFlags(parsed, command, ["json"]);
             return;
+        case "cluster":
+            assertKnownFlags(parsed, command, ["json"]);
+            return;
         case "init":
             assertKnownFlags(parsed, command, ["force", "json", "public-base-url"]);
             return;
@@ -162,7 +167,7 @@ export async function runCli(argv, options) {
     const json = parsed.flags.get("json") === true;
     if (command === "help") {
         const topic = commandArgs[0];
-        if (topic === "linear" || topic === "repo" || topic === "issue" || topic === "service") {
+        if (topic === "linear" || topic === "repo" || topic === "issue" || topic === "service" || topic === "cluster") {
             writeOutput(stdout, `${helpTextFor(topic)}\n`);
             return 0;
         }
@@ -183,7 +188,7 @@ export async function runCli(argv, options) {
             ? "linear"
             : command === "repo"
                 ? "repo"
-                : command === "issue" || command === "service"
+                : command === "issue" || command === "service" || command === "cluster"
                     ? command
                     : "root";
         writeOutput(stdout, `${helpTextFor(helpTopic)}\n`);
@@ -272,6 +277,10 @@ export async function runCli(argv, options) {
             return 1;
         }
     }
+    if (command === "cluster" && commandArgs[0]) {
+        writeUsageError(stderr, new CliUsageError(`Unknown cluster command: ${commandArgs[0]}`, "cluster"));
+        return 1;
+    }
     const config = options?.config ??
         loadConfig(undefined, {
             profile: getCommandConfigProfile(command),
@@ -311,6 +320,22 @@ export async function runCli(argv, options) {
                 runInteractive,
             });
         }
+        if (command === "cluster") {
+            const issueData = await ensureIssueDataAccess(data, config);
+            if (!data) {
+                data = issueData;
+                ownsData = true;
+            }
+            return await handleClusterCommand({
+                commandArgs,
+                parsed,
+                json,
+                stdout,
+                data: issueData,
+                config,
+                runCommand,
+            });
+        }
         if (command === "dashboard") {
             const { handleWatchCommand } = await import("./commands/watch.js");
             return await handleWatchCommand({ config, parsed });

package/dist/cli/output.js

@@ -22,3 +22,41 @@ export function formatDoctor(report, cliVersion, serviceVersion) {
     lines.push(report.ok ? "Doctor result: ready" : "Doctor result: not ready");
     return `${lines.join("\n")}\n`;
 }
+export function formatClusterHealth(report) {
+    const lines = ["PatchRelay cluster", ""];
+    for (const check of report.checks) {
+        const marker = check.status === "pass" ? "PASS" : check.status === "warn" ? "WARN" : "FAIL";
+        const detail = [
+            check.scope,
+            check.issueKey,
+            check.prNumber !== undefined ? `PR #${check.prNumber}` : undefined,
+        ].filter(Boolean).join(" ");
+        lines.push(`${marker} [${detail}] ${check.message}`);
+    }
+    lines.push("");
+    lines.push(`Summary: tracked=${report.summary.trackedIssues} non_done=${report.summary.openIssues} active_runs=${report.summary.activeRuns} blocked=${report.summary.blockedIssues} ready=${report.summary.readyIssues}`);
+    if (report.summary.ciTrackedPrs > 0) {
+        lines.push(`CI summary: prs=${report.summary.ciTrackedPrs} pending=${report.summary.ciPending} success=${report.summary.ciSuccess} failure=${report.summary.ciFailure} unknown=${report.summary.ciUnknown} missing_owner=${report.summary.ciOrphaned}`);
+        for (const entry of report.ci) {
+            lines.push(`CI ${entry.issueKey ?? entry.projectId} PR #${entry.prNumber}  gate=${entry.gateStatus}  next=${formatCiOwnerLabel(entry.owner)}  ${entry.message}`);
+        }
+    }
+    lines.push(report.ok ? "Cluster result: no ownership gaps detected" : "Cluster result: attention needed");
+    return `${lines.join("\n")}\n`;
+}
+function formatCiOwnerLabel(owner) {
+    switch (owner) {
+        case "patchrelay":
+            return "patchrelay";
+        case "reviewer":
+            return "reviewer";
+        case "review-quill":
+            return "review-quill";
+        case "downstream":
+            return "merge-queue";
+        case "external":
+            return "ci/github";
+        default:
+            return "missing";
+    }
+}

package/dist/cli/watch/StateHistoryView.js

@@ -18,6 +18,7 @@ const RUN_LABELS = {
     implementation: "implementation",
     ci_repair: "ci repair",
     review_fix: "review fix",
+    branch_upkeep: "branch upkeep",
     queue_repair: "queue repair",
 };
 function runStatusSymbol(status) {

package/dist/cli/watch/TimelineRow.js

@@ -16,6 +16,7 @@ const RUN_LABELS = {
     implementation: "implement",
     ci_repair: "ci fix",
     review_fix: "review fix",
+    branch_upkeep: "branch upkeep",
     queue_repair: "merge fix",
 };
 function runDotColor(status) {

package/dist/cli/watch/detail-rows.js

@@ -31,6 +31,7 @@ const RUN_LABELS = {
     implementation: "implementation",
     ci_repair: "ci repair",
     review_fix: "review fix",
+    branch_upkeep: "branch upkeep",
     queue_repair: "queue repair",
 };
 const STATE_LABELS = {

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

@@ -4,6 +4,7 @@ const RUN_TYPE_TO_STATE = {
     implementation: "implementing",
     ci_repair: "repairing_ci",
     review_fix: "changes_requested",
+    branch_upkeep: "changes_requested",
     queue_repair: "repairing_queue",
 };
 function extractTransitions(feedEvents) {

package/dist/db/migrations.js

@@ -26,6 +26,7 @@ CREATE TABLE IF NOT EXISTS issues (
   pr_author_login TEXT,
   pr_review_state TEXT,
   pr_check_status TEXT,
+  last_blocking_review_head_sha TEXT,
   ci_repair_attempts INTEGER NOT NULL DEFAULT 0,
   queue_repair_attempts INTEGER NOT NULL DEFAULT 0,
   updated_at TEXT NOT NULL,
@@ -39,6 +40,7 @@ CREATE TABLE IF NOT EXISTS runs (
   linear_issue_id TEXT NOT NULL,
   run_type TEXT NOT NULL DEFAULT 'implementation',
   status TEXT NOT NULL,
+  source_head_sha TEXT,
   prompt_text TEXT,
   thread_id TEXT,
   turn_id TEXT,
@@ -239,6 +241,10 @@ export function runPatchRelayMigrations(connection) {
     addColumnIfMissing(connection, "issues", "merge_prep_attempts", "INTEGER NOT NULL DEFAULT 0");
     // Add review_fix_attempts counter
     addColumnIfMissing(connection, "issues", "review_fix_attempts", "INTEGER NOT NULL DEFAULT 0");
+    // Preserve the PR head SHA seen when a run started so PatchRelay can
+    // verify that requested-changes work actually published a new head.
+    addColumnIfMissing(connection, "runs", "source_head_sha", "TEXT");
+    addColumnIfMissing(connection, "issues", "last_blocking_review_head_sha", "TEXT");
     // Collapse awaiting_review into pr_open (state normalization)
     connection.prepare("UPDATE issues SET factory_state = 'pr_open' WHERE factory_state = 'awaiting_review'").run();
     // Add Linear issue description, priority, estimate
@@ -319,6 +325,7 @@ function removeRetiredIssueColumnsIfPresent(connection) {
         pr_author_login TEXT,
         pr_review_state TEXT,
         pr_check_status TEXT,
+        last_blocking_review_head_sha TEXT,
         last_github_failure_source TEXT,
         last_github_failure_head_sha TEXT,
         last_github_failure_signature TEXT,
@@ -374,6 +381,7 @@ function removeRetiredIssueColumnsIfPresent(connection) {
         pr_author_login,
         pr_review_state,
         pr_check_status,
+        last_blocking_review_head_sha,
         last_github_failure_source,
         last_github_failure_head_sha,
         last_github_failure_signature,
@@ -427,6 +435,7 @@ function removeRetiredIssueColumnsIfPresent(connection) {
         pr_author_login,
         pr_review_state,
         pr_check_status,
+        last_blocking_review_head_sha,
         last_github_failure_source,
         last_github_failure_head_sha,
         last_github_failure_signature,

package/dist/db.js

@@ -254,6 +254,10 @@ export class PatchRelayDatabase {
                 sets.push("pr_check_status = @prCheckStatus");
                 values.prCheckStatus = params.prCheckStatus;
             }
+            if (params.lastBlockingReviewHeadSha !== undefined) {
+                sets.push("last_blocking_review_head_sha = @lastBlockingReviewHeadSha");
+                values.lastBlockingReviewHeadSha = params.lastBlockingReviewHeadSha;
+            }
             if (params.lastGitHubFailureSource !== undefined) {
                 sets.push("last_github_failure_source = @lastGitHubFailureSource");
                 values.lastGitHubFailureSource = params.lastGitHubFailureSource;
@@ -348,7 +352,7 @@ export class PatchRelayDatabase {
           current_linear_state, current_linear_state_type, factory_state, pending_run_type, pending_run_context_json,
           branch_name, worktree_path, thread_id, active_run_id, status_comment_id,
           agent_session_id,
-          pr_number, pr_url, pr_state, pr_head_sha, pr_author_login, pr_review_state, pr_check_status,
+          pr_number, pr_url, pr_state, pr_head_sha, pr_author_login, pr_review_state, pr_check_status, last_blocking_review_head_sha,
           last_github_failure_source, last_github_failure_head_sha, last_github_failure_signature, last_github_failure_check_name, last_github_failure_check_url, last_github_failure_context_json, last_github_failure_at,
           last_github_ci_snapshot_head_sha, last_github_ci_snapshot_gate_check_name, last_github_ci_snapshot_gate_check_status, last_github_ci_snapshot_json, last_github_ci_snapshot_settled_at,
           last_queue_signal_at, last_queue_incident_json,
@@ -360,7 +364,7 @@ export class PatchRelayDatabase {
           @currentLinearState, @currentLinearStateType, @factoryState, @pendingRunType, @pendingRunContextJson,
           @branchName, @worktreePath, @threadId, @activeRunId, @statusCommentId,
           @agentSessionId,
-          @prNumber, @prUrl, @prState, @prHeadSha, @prAuthorLogin, @prReviewState, @prCheckStatus,
+          @prNumber, @prUrl, @prState, @prHeadSha, @prAuthorLogin, @prReviewState, @prCheckStatus, @lastBlockingReviewHeadSha,
           @lastGitHubFailureSource, @lastGitHubFailureHeadSha, @lastGitHubFailureSignature, @lastGitHubFailureCheckName, @lastGitHubFailureCheckUrl, @lastGitHubFailureContextJson, @lastGitHubFailureAt,
           @lastGitHubCiSnapshotHeadSha, @lastGitHubCiSnapshotGateCheckName, @lastGitHubCiSnapshotGateCheckStatus, @lastGitHubCiSnapshotJson, @lastGitHubCiSnapshotSettledAt,
           @lastQueueSignalAt, @lastQueueIncidentJson,
@@ -394,6 +398,7 @@ export class PatchRelayDatabase {
                 prAuthorLogin: params.prAuthorLogin ?? null,
                 prReviewState: params.prReviewState ?? null,
                 prCheckStatus: params.prCheckStatus ?? null,
+                lastBlockingReviewHeadSha: params.lastBlockingReviewHeadSha ?? null,
                 lastGitHubFailureSource: params.lastGitHubFailureSource ?? null,
                 lastGitHubFailureHeadSha: params.lastGitHubFailureHeadSha ?? null,
                 lastGitHubFailureSignature: params.lastGitHubFailureSignature ?? null,
@@ -809,9 +814,22 @@ export class PatchRelayDatabase {
     }
     listIssuesReadyForExecution() {
         return this.listIssues()
-            .filter((issue) => issue.activeRunId === undefined)
-            .filter((issue) => this.countUnresolvedBlockers(issue.projectId, issue.linearIssueId) === 0)
-            .filter((issue) => issue.pendingRunType !== undefined || this.peekIssueSessionWake(issue.projectId, issue.linearIssueId) !== undefined)
+            .filter((issue) => isIssueSessionReadyForExecution({
+            factoryState: issue.factoryState,
+            sessionState: deriveIssueSessionState({
+                activeRunId: issue.activeRunId,
+                factoryState: issue.factoryState,
+            }),
+            activeRunId: issue.activeRunId,
+            blockedByCount: this.countUnresolvedBlockers(issue.projectId, issue.linearIssueId),
+            hasPendingWake: this.peekIssueSessionWake(issue.projectId, issue.linearIssueId) !== undefined,
+            hasLegacyPendingRun: issue.pendingRunType !== undefined,
+            prNumber: issue.prNumber,
+            prState: issue.prState,
+            prReviewState: issue.prReviewState,
+            prCheckStatus: issue.prCheckStatus,
+            latestFailureSource: issue.lastGitHubFailureSource,
+        }))
             .map((issue) => ({
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
@@ -869,9 +887,9 @@ export class PatchRelayDatabase {
     createRun(params) {
         const now = isoNow();
         const result = this.connection.prepare(`
-      INSERT INTO runs (issue_id, project_id, linear_issue_id, run_type, status, prompt_text, started_at)
-      VALUES (?, ?, ?, ?, 'queued', ?, ?)
-    `).run(params.issueId, params.projectId, params.linearIssueId, params.runType, params.promptText ?? null, now);
+      INSERT INTO runs (issue_id, project_id, linear_issue_id, run_type, status, source_head_sha, prompt_text, started_at)
+      VALUES (?, ?, ?, ?, 'queued', ?, ?, ?)
+    `).run(params.issueId, params.projectId, params.linearIssueId, params.runType, params.sourceHeadSha ?? null, params.promptText ?? null, now);
         const run = this.getRun(Number(result.lastInsertRowid));
         const issue = this.getIssue(params.projectId, params.linearIssueId);
         if (issue) {
@@ -992,8 +1010,10 @@ export class PatchRelayDatabase {
             factoryState: issue.factoryState,
             pendingRunType: issue.pendingRunType,
             prNumber: issue.prNumber,
+            prHeadSha: issue.prHeadSha,
             prReviewState: issue.prReviewState,
             prCheckStatus: issue.prCheckStatus,
+            lastBlockingReviewHeadSha: issue.lastBlockingReviewHeadSha,
             latestFailureCheckName: issue.lastGitHubFailureCheckName,
         });
         const latestRun = this.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
@@ -1241,6 +1261,9 @@ function mapIssueRow(row) {
         ...(row.pr_author_login !== null && row.pr_author_login !== undefined ? { prAuthorLogin: String(row.pr_author_login) } : {}),
         ...(row.pr_review_state !== null && row.pr_review_state !== undefined ? { prReviewState: String(row.pr_review_state) } : {}),
         ...(row.pr_check_status !== null && row.pr_check_status !== undefined ? { prCheckStatus: String(row.pr_check_status) } : {}),
+        ...(row.last_blocking_review_head_sha !== null && row.last_blocking_review_head_sha !== undefined
+            ? { lastBlockingReviewHeadSha: String(row.last_blocking_review_head_sha) }
+            : {}),
         ...(row.last_github_failure_source !== null && row.last_github_failure_source !== undefined
             ? { lastGitHubFailureSource: String(row.last_github_failure_source) }
             : {}),
@@ -1347,6 +1370,7 @@ function mapRunRow(row) {
         linearIssueId: String(row.linear_issue_id),
         runType: String(row.run_type ?? "implementation"),
         status: String(row.status),
+        ...(row.source_head_sha !== null ? { sourceHeadSha: String(row.source_head_sha) } : {}),
         ...(row.prompt_text !== null ? { promptText: String(row.prompt_text) } : {}),
         ...(row.thread_id !== null ? { threadId: String(row.thread_id) } : {}),
         ...(row.turn_id !== null ? { turnId: String(row.turn_id) } : {}),

package/dist/github-webhook-handler.js

@@ -147,6 +147,11 @@ export class GitHubWebhookHandler {
             ...(event.prAuthorLogin !== undefined ? { prAuthorLogin: event.prAuthorLogin } : {}),
             ...(event.reviewState !== undefined ? { prReviewState: event.reviewState } : {}),
             ...(event.checkStatus !== undefined ? { prCheckStatus: event.checkStatus } : {}),
+            ...(event.reviewState === "changes_requested"
+                ? { lastBlockingReviewHeadSha: event.reviewCommitId ?? event.headSha ?? null }
+                : event.reviewState === "approved"
+                    ? { lastBlockingReviewHeadSha: null }
+                    : {}),
         });
         await this.updateCiSnapshot(issue, event, project);
         await this.updateFailureProvenance(issue, event, project);
@@ -195,7 +200,6 @@ export class GitHubWebhookHandler {
                 lastAttemptedFailureHeadSha: null,
                 lastAttemptedFailureSignature: null,
             });
-            await this.maybeRequestRereviewAfterPush(freshIssue, event, project);
         }
         this.logger.info({ issueKey: issue.issueKey, branchName: event.branchName, triggerEvent: event.triggerEvent, prNumber: event.prNumber }, "GitHub webhook: updated issue PR state");
         this.feed?.publish({
@@ -941,83 +945,6 @@ export class GitHubWebhookHandler {
         });
         this.enqueuePendingSessionWake(issue.projectId, issue.linearIssueId);
     }
-    async maybeRequestRereviewAfterPush(issue, event, project) {
-        if (event.triggerEvent !== "pr_synchronize")
-            return;
-        if (issue.activeRunId !== undefined)
-            return;
-        if (issue.prState !== "open" || issue.prReviewState !== "changes_requested" || issue.prNumber === undefined)
-            return;
-        if (!this.isPatchRelayOwnedPr(issue))
-            return;
-        const reviewerName = this.findLatestRequestedChangesReviewer(issue.projectId, issue.linearIssueId);
-        if (!reviewerName) {
-            this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber }, "Skipping auto re-review request because no prior reviewer was recorded");
-            return;
-        }
-        const repoFullName = project?.github?.repoFullName ?? event.repoFullName;
-        const token = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
-        if (!token) {
-            this.logger.warn({ issueKey: issue.issueKey, prNumber: issue.prNumber }, "Skipping auto re-review request because no GitHub token is available");
-            this.feed?.publish({
-                level: "warn",
-                kind: "github",
-                issueKey: issue.issueKey,
-                projectId: issue.projectId,
-                stage: issue.factoryState,
-                status: "rereview_request_skipped",
-                summary: `Skipped auto re-review request for PR #${issue.prNumber}`,
-                detail: "No GitHub token available for requested_reviewers API call",
-            });
-            return;
-        }
-        const response = await this.fetchImpl(`https://api.github.com/repos/${repoFullName}/pulls/${issue.prNumber}/requested_reviewers`, {
-            method: "POST",
-            headers: {
-                authorization: `Bearer ${token}`,
-                accept: "application/vnd.github+json",
-                "content-type": "application/json",
-                "user-agent": "patchrelay",
-            },
-            body: JSON.stringify({ reviewers: [reviewerName] }),
-        });
-        if (!response.ok) {
-            const detail = await this.readGitHubErrorResponse(response);
-            this.logger.warn({ issueKey: issue.issueKey, prNumber: issue.prNumber, reviewerName, status: response.status, detail }, "Failed to auto request re-review after push");
-            this.feed?.publish({
-                level: "warn",
-                kind: "github",
-                issueKey: issue.issueKey,
-                projectId: issue.projectId,
-                stage: issue.factoryState,
-                status: "rereview_request_failed",
-                summary: `Failed to auto request re-review from ${reviewerName}`,
-                detail,
-            });
-            return;
-        }
-        this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, reviewerName }, "Auto requested re-review after push");
-        this.feed?.publish({
-            level: "info",
-            kind: "github",
-            issueKey: issue.issueKey,
-            projectId: issue.projectId,
-            stage: issue.factoryState,
-            status: "rereview_requested",
-            summary: `Requested re-review from ${reviewerName} on PR #${issue.prNumber}`,
-        });
-    }
-    findLatestRequestedChangesReviewer(projectId, linearIssueId) {
-        const event = this.db
-            .listIssueSessionEvents(projectId, linearIssueId)
-            .findLast((candidate) => candidate.eventType === "review_changes_requested");
-        if (!event?.eventJson)
-            return undefined;
-        const payload = safeJsonParse(event.eventJson);
-        return typeof payload?.reviewerName === "string" && payload.reviewerName.trim()
-            ? payload.reviewerName.trim()
-            : undefined;
-    }
     async readGitHubErrorResponse(response) {
         try {
             const payload = await response.json();

package/dist/idle-reconciliation.js

@@ -129,6 +129,11 @@ export class IdleIssueReconciler {
                 await this.reconcileFromGitHub(issue);
             }
         }
+        for (const issue of this.db.listIssues()) {
+            if (!this.shouldProbeTerminalIssueFromGitHub(issue))
+                continue;
+            await this.reconcileFromGitHub(issue);
+        }
         for (const issue of this.db.listBlockedDelegatedIssues()) {
             const unresolved = this.db.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
             if (unresolved === 0) {
@@ -144,6 +149,15 @@ export class IdleIssueReconciler {
             }
         }
     }
+    shouldProbeTerminalIssueFromGitHub(issue) {
+        if (issue.prNumber === undefined)
+            return false;
+        if (issue.activeRunId !== undefined)
+            return false;
+        if (issue.pendingRunType !== undefined)
+            return false;
+        return issue.factoryState === "escalated" || issue.factoryState === "failed";
+    }
     advanceIdleIssue(issue, newState, options) {
         if (issue.factoryState === newState && !options?.pendingRunType && !options?.clearFailureProvenance) {
             return;
@@ -205,9 +219,9 @@ export class IdleIssueReconciler {
             eventType = "settled_red_ci";
             dedupeKey = `${dedupeScope}:ci_repair:${issue.linearIssueId}:${issue.lastGitHubFailureSignature ?? issue.prHeadSha ?? issue.lastGitHubFailureHeadSha ?? "unknown"}`;
         }
-        else if (runType === "review_fix") {
+        else if (runType === "review_fix" || runType === "branch_upkeep") {
             eventType = "review_changes_requested";
-            dedupeKey = `${dedupeScope}:review_fix:${issue.linearIssueId}:${issue.prHeadSha ?? "unknown"}`;
+            dedupeKey = `${dedupeScope}:${runType}:${issue.linearIssueId}:${issue.prHeadSha ?? "unknown"}`;
         }
         else {
             eventType = "delegated";
@@ -377,6 +391,7 @@ export class IdleIssueReconciler {
                 "--json", "headRefOid,state,reviewDecision,mergeable,mergeStateStatus,statusCheckRollup",
             ], { timeoutMs: 10_000 });
             const pr = JSON.parse(stdout);
+            const previousHeadSha = issue.prHeadSha;
             const gateCheckNames = getGateCheckNames(project);
             const gateCheckStatus = deriveGateCheckStatusFromRollup(pr.statusCheckRollup, gateCheckNames);
             this.db.upsertIssue({
@@ -415,6 +430,23 @@ export class IdleIssueReconciler {
                 });
                 return;
             }
+            const headAdvanced = Boolean(pr.headRefOid && pr.headRefOid !== previousHeadSha);
+            if (issue.factoryState !== "awaiting_input") {
+                const terminalRecoveryState = this.deriveTerminalRecoveryState(issue, pr.reviewDecision, gateCheckStatus, headAdvanced);
+                if (terminalRecoveryState) {
+                    this.logger.info({
+                        issueKey: issue.issueKey,
+                        prNumber: issue.prNumber,
+                        from: issue.factoryState,
+                        to: terminalRecoveryState,
+                        gateCheckStatus,
+                        reviewDecision: pr.reviewDecision,
+                        headAdvanced,
+                    }, "Reconciliation: recovered terminal issue from newer GitHub truth");
+                    this.advanceIdleIssue(issue, terminalRecoveryState, { clearFailureProvenance: true });
+                    return;
+                }
+            }
             if (isReviewDecisionReviewRequired(pr.reviewDecision)
                 && gateCheckStatus === "success"
                 && hasCompletedReviewQuillVerdict(pr.statusCheckRollup)) {
@@ -492,4 +524,22 @@ export class IdleIssueReconciler {
             }
         }
     }
+    deriveTerminalRecoveryState(issue, reviewDecision, gateCheckStatus, headAdvanced) {
+        if (issue.factoryState !== "escalated" && issue.factoryState !== "failed") {
+            return undefined;
+        }
+        if (isReviewDecisionApproved(reviewDecision) && !isFailingCheckStatus(gateCheckStatus)) {
+            return "awaiting_queue";
+        }
+        if (gateCheckStatus === "pending") {
+            return "pr_open";
+        }
+        if (headAdvanced && !isFailingCheckStatus(gateCheckStatus)) {
+            return "pr_open";
+        }
+        if (isReviewDecisionReviewRequired(reviewDecision) && !isFailingCheckStatus(gateCheckStatus)) {
+            return "pr_open";
+        }
+        return undefined;
+    }
 }

package/dist/issue-query-service.js

@@ -143,8 +143,10 @@ export class IssueQueryService {
             factoryState: issueRecord?.factoryState ?? "delegated",
             pendingRunType: issueRecord?.pendingRunType,
             prNumber: session.prNumber,
+            prHeadSha: issueRecord?.prHeadSha ?? session.prHeadSha,
             prReviewState: issueRecord?.prReviewState,
             prCheckStatus: issueRecord?.prCheckStatus,
+            lastBlockingReviewHeadSha: issueRecord?.lastBlockingReviewHeadSha,
             latestFailureCheckName: issueRecord?.lastGitHubFailureCheckName,
         });
         const issue = {

package/dist/issue-session-events.js

@@ -33,8 +33,8 @@ export function deriveSessionWakePlan(issue, events) {
                 break;
             case "review_changes_requested":
                 if (runType !== "queue_repair" && runType !== "ci_repair") {
-                    runType = "review_fix";
-                    wakeReason = "review_changes_requested";
+                    runType = payload?.branchUpkeepRequired === true ? "branch_upkeep" : "review_fix";
+                    wakeReason = payload?.branchUpkeepRequired === true ? "branch_upkeep" : "review_changes_requested";
                     Object.assign(context, payload ?? {});
                 }
                 break;

package/dist/issue-session.js

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