patchrelay 0.74.3 → 0.74.5

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.74.3",
-  "commit": "21e6267a7b1c",
-  "builtAt": "2026-05-28T21:47:39.635Z"
+  "version": "0.74.5",
+  "commit": "c495abc1770b",
+  "builtAt": "2026-05-29T08:13:54.437Z"
 }

package/dist/cli/data.js

@@ -402,42 +402,7 @@ export class CliDataAccess extends CliOperatorApiClient {
         });
     }
     list(options) {
-        const conditions = [];
-        const values = [];
-        if (options?.project) {
-            conditions.push("i.project_id = ?");
-            values.push(options.project);
-        }
-        const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-        const rows = this.db.connection
-            .prepare(`
-        SELECT
-          i.project_id,
-          i.linear_issue_id,
-          i.issue_key,
-          i.title,
-          i.current_linear_state,
-          i.factory_state,
-          i.updated_at,
-          s.session_state,
-          s.waiting_reason,
-          active_run.run_type AS active_run_type,
-          latest_run.run_type AS latest_run_type,
-          latest_run.status AS latest_run_status
-        FROM issues i
-        LEFT JOIN issue_sessions s
-          ON s.project_id = i.project_id
-         AND s.linear_issue_id = i.linear_issue_id
-        LEFT JOIN runs active_run ON active_run.id = i.active_run_id
-        LEFT JOIN runs latest_run ON latest_run.id = (
-          SELECT r.id FROM runs r
-          WHERE r.project_id = i.project_id AND r.linear_issue_id = i.linear_issue_id
-          ORDER BY r.id DESC LIMIT 1
-        )
-        ${whereClause}
-        ORDER BY i.updated_at DESC, i.issue_key ASC
-        `)
-            .all(...values);
+        const rows = this.db.issues.listIssueSummaryRows(options?.project);
         const items = rows.map((row) => {
             const detachedActiveRun = row.active_run_type === null
                 && (row.latest_run_status === "queued" || row.latest_run_status === "running");

package/dist/db/issue-session-store.js

@@ -292,4 +292,82 @@ export class IssueSessionStore {
         const lease = this.getActiveIssueSessionLease(projectId, linearIssueId);
         this.releaseIssueSessionLease(projectId, linearIssueId, lease?.leaseId);
     }
+    /**
+     * Raw rows for the tracked-issue read model: one row per issue session joined
+     * to its issue, active/latest run, pending session-event count, and blocker
+     * rollup. Row shaping into the read model lives in the query layer; this owns
+     * only the SQL so schema knowledge stays in the persistence layer.
+     */
+    listTrackedIssueRows() {
+        return this.connection
+            .prepare(`SELECT
+          s.project_id, s.linear_issue_id, s.issue_key, i.title,
+          i.current_linear_state, i.factory_state, i.delegated_to_patchrelay, s.session_state, s.waiting_reason, s.summary_text, s.display_updated_at,
+          i.pending_run_type,
+          i.orchestration_settle_until,
+          i.pr_number, i.pr_state, i.pr_head_sha, i.pr_review_state, i.pr_check_status, i.last_blocking_review_head_sha,
+          i.last_github_ci_snapshot_json,
+          i.last_github_failure_source,
+          i.last_github_failure_head_sha,
+          i.last_github_failure_check_name,
+          i.last_github_failure_context_json,
+          active_run.run_type AS active_run_type,
+          active_run.completion_check_thread_id AS active_completion_check_thread_id,
+          active_run.completion_check_outcome AS active_completion_check_outcome,
+          latest_run.run_type AS latest_run_type,
+          latest_run.status AS latest_run_status,
+          latest_run.summary_json AS latest_run_summary_json,
+          latest_run.report_json AS latest_run_report_json,
+          latest_run.completion_check_thread_id AS latest_run_completion_check_thread_id,
+          latest_run.completion_check_outcome AS latest_run_completion_check_outcome,
+          latest_run.completion_check_summary AS latest_run_completion_check_summary,
+          latest_run.completion_check_question AS latest_run_completion_check_question,
+          latest_run.completion_check_why AS latest_run_completion_check_why,
+          latest_run.completion_check_recommended_reply AS latest_run_completion_check_recommended_reply,
+          (
+            SELECT COUNT(*)
+            FROM issue_session_events e
+            WHERE e.project_id = s.project_id
+              AND e.linear_issue_id = s.linear_issue_id
+              AND e.processed_at IS NULL
+          ) AS pending_session_event_count,
+          (
+            SELECT COUNT(*)
+            FROM issue_dependencies d
+            LEFT JOIN issues blockers
+              ON blockers.project_id = d.project_id
+             AND blockers.linear_issue_id = d.blocker_linear_issue_id
+            WHERE d.project_id = s.project_id
+              AND d.linear_issue_id = s.linear_issue_id
+              AND (
+                COALESCE(blockers.current_linear_state_type, d.blocker_current_linear_state_type, '') != 'completed'
+                AND LOWER(TRIM(COALESCE(blockers.current_linear_state, d.blocker_current_linear_state, ''))) != 'done'
+              )
+          ) AS blocked_by_count,
+          (
+            SELECT json_group_array(COALESCE(blockers.issue_key, d.blocker_issue_key, d.blocker_linear_issue_id))
+            FROM issue_dependencies d
+            LEFT JOIN issues blockers
+              ON blockers.project_id = d.project_id
+             AND blockers.linear_issue_id = d.blocker_linear_issue_id
+            WHERE d.project_id = s.project_id
+              AND d.linear_issue_id = s.linear_issue_id
+              AND (
+                COALESCE(blockers.current_linear_state_type, d.blocker_current_linear_state_type, '') != 'completed'
+                AND LOWER(TRIM(COALESCE(blockers.current_linear_state, d.blocker_current_linear_state, ''))) != 'done'
+              )
+          ) AS blocked_by_keys_json
+        FROM issue_sessions s
+        LEFT JOIN issues i
+          ON i.project_id = s.project_id
+         AND i.linear_issue_id = s.linear_issue_id
+        LEFT JOIN runs active_run ON active_run.id = COALESCE(s.active_run_id, i.active_run_id)
+        LEFT JOIN runs latest_run ON latest_run.id = (
+          SELECT r.id FROM runs r
+          WHERE r.project_id = s.project_id AND r.linear_issue_id = s.linear_issue_id
+          ORDER BY r.id DESC LIMIT 1
+        )
+        ORDER BY s.display_updated_at DESC, s.issue_key ASC`)
+            .all();
+    }
 }

package/dist/db/issue-store.js

@@ -354,6 +354,44 @@ export class IssueStore {
             return undefined;
         }
     }
+    /**
+     * Raw rows for the CLI issue-summary read model (one row per issue joined to
+     * its session and active/latest run), optionally scoped to a project. Row
+     * shaping lives in the CLI layer; this owns only the SQL.
+     */
+    listIssueSummaryRows(project) {
+        const whereClause = project ? "WHERE i.project_id = ?" : "";
+        const values = project ? [project] : [];
+        return this.connection
+            .prepare(`
+        SELECT
+          i.project_id,
+          i.linear_issue_id,
+          i.issue_key,
+          i.title,
+          i.current_linear_state,
+          i.factory_state,
+          i.updated_at,
+          s.session_state,
+          s.waiting_reason,
+          active_run.run_type AS active_run_type,
+          latest_run.run_type AS latest_run_type,
+          latest_run.status AS latest_run_status
+        FROM issues i
+        LEFT JOIN issue_sessions s
+          ON s.project_id = i.project_id
+         AND s.linear_issue_id = i.linear_issue_id
+        LEFT JOIN runs active_run ON active_run.id = i.active_run_id
+        LEFT JOIN runs latest_run ON latest_run.id = (
+          SELECT r.id FROM runs r
+          WHERE r.project_id = i.project_id AND r.linear_issue_id = i.linear_issue_id
+          ORDER BY r.id DESC LIMIT 1
+        )
+        ${whereClause}
+        ORDER BY i.updated_at DESC, i.issue_key ASC
+        `)
+            .all(...values);
+    }
 }
 export function mapIssueRow(row) {
     return {

package/dist/db/linear-installation-store.js

@@ -170,6 +170,10 @@ export class LinearInstallationStore {
     deleteLinearInstallation(installationId) {
         this.connection.prepare("DELETE FROM linear_installations WHERE id = ?").run(installationId);
     }
+    deleteCatalogForInstallation(installationId) {
+        this.connection.prepare("DELETE FROM linear_catalog_teams WHERE installation_id = ?").run(installationId);
+        this.connection.prepare("DELETE FROM linear_catalog_projects WHERE installation_id = ?").run(installationId);
+    }
     getLinearInstallationForProject(projectId) {
         const row = this.connection
             .prepare(`

package/dist/failure-provenance.js

@@ -0,0 +1,23 @@
+/**
+ * Every failure-provenance field on an issue, set to null.
+ *
+ * Spread into an issue upsert when a run reaches a clean advancing or terminal
+ * state (for example `awaiting_queue` or `done`) and any previously recorded
+ * GitHub failure or queue-incident context must not leak into the next
+ * decision. Keeping the field set in one place stops it from drifting between
+ * the run finalizer, the reconcilers, the completion check, and the webhook
+ * state projector.
+ */
+export const CLEARED_FAILURE_PROVENANCE = {
+    lastGitHubFailureSource: null,
+    lastGitHubFailureHeadSha: null,
+    lastGitHubFailureSignature: null,
+    lastGitHubFailureCheckName: null,
+    lastGitHubFailureCheckUrl: null,
+    lastGitHubFailureContextJson: null,
+    lastGitHubFailureAt: null,
+    lastQueueIncidentJson: null,
+    lastAttemptedFailureHeadSha: null,
+    lastAttemptedFailureSignature: null,
+    lastAttemptedFailureAt: null,
+};

package/dist/github-webhook-state-projector.js

@@ -1,3 +1,4 @@
+import { CLEARED_FAILURE_PROVENANCE } from "./failure-provenance.js";
 import { createGitHubCiSnapshotResolver, createGitHubFailureContextResolver } from "./github-failure-context.js";
 import { buildClosedPrCleanupFields } from "./pr-state.js";
 import { canClearFailureProvenance, deriveImmediatePrCheckStatus, getGateCheckNames, getPrimaryGateCheckName, isGateCheckEvent, isMetadataOnlyCheckEvent, isQueueEvictionFailure, isStaleGateEvent, isSettledBranchFailure, resolveGitHubFactoryStateForEvent, } from "./github-webhook-policy.js";
@@ -313,17 +314,7 @@ async function updateGitHubFailureProvenance(deps, issue, event, project, failur
         deps.db.issues.upsertIssue({
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
-            lastGitHubFailureSource: null,
-            lastGitHubFailureHeadSha: null,
-            lastGitHubFailureSignature: null,
-            lastGitHubFailureCheckName: null,
-            lastGitHubFailureCheckUrl: null,
-            lastGitHubFailureContextJson: null,
-            lastGitHubFailureAt: null,
-            lastQueueIncidentJson: null,
-            lastAttemptedFailureHeadSha: null,
-            lastAttemptedFailureSignature: null,
-            lastAttemptedFailureAt: null,
+            ...CLEARED_FAILURE_PROVENANCE,
         });
     }
 }

package/dist/idle-reconciliation.js

@@ -1,4 +1,5 @@
 import { TERMINAL_STATES } from "./factory-state.js";
+import { CLEARED_FAILURE_PROVENANCE } from "./failure-provenance.js";
 import { DEPLOY_WATCH_TIMEOUT_MS, evaluateDeploy, isDeployTrackingEnabled, } from "./post-merge-deploy.js";
 import { buildBranchUpkeepContext, buildFailureContext, getGateCheckNames, hasCompletedReviewQuillVerdict, hasFailureProvenance, isDuplicateRepairAttempt, isFailingCheckStatus, isReviewDecisionApproved, isReviewDecisionReviewRequired, } from "./idle-reconciliation-helpers.js";
 import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
@@ -9,7 +10,7 @@ import { getReviewFixBudget } from "./run-budgets.js";
 import { queueSettledOrchestrationIssue } from "./orchestration-parent-wake.js";
 import { fetchPullRequestSnapshot } from "./reconcile-pr-fetch.js";
 import { buildPrStateUpdates } from "./reconcile-pr-state-updates.js";
-import { buildRequestedChangesWakeIdentity } from "./reactive-wake-keys.js";
+import { buildRepairWakeDedupeKey, buildRequestedChangesWakeIdentity, reactiveWakeEventType } from "./reactive-wake-keys.js";
 import { execCommand } from "./utils.js";
 export class IdleIssueReconciler {
     db;
@@ -239,19 +240,7 @@ export class IdleIssueReconciler {
                 }
                 : {}),
             ...(options?.clearFailureProvenance
-                ? {
-                    lastGitHubFailureSource: null,
-                    lastGitHubFailureHeadSha: null,
-                    lastGitHubFailureSignature: null,
-                    lastGitHubFailureCheckName: null,
-                    lastGitHubFailureCheckUrl: null,
-                    lastGitHubFailureContextJson: null,
-                    lastGitHubFailureAt: null,
-                    lastQueueIncidentJson: null,
-                    lastAttemptedFailureHeadSha: null,
-                    lastAttemptedFailureSignature: null,
-                    lastAttemptedFailureAt: null,
-                }
+                ? { ...CLEARED_FAILURE_PROVENANCE }
                 : {}),
         });
         const updatedIssue = this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
@@ -277,18 +266,19 @@ export class IdleIssueReconciler {
         // is needed here.
     }
     recordWakeEvent(issue, runType, context, dedupeScope = "idle_reconciliation") {
-        let eventType;
+        const eventType = reactiveWakeEventType(runType);
         let dedupeKey;
-        if (runType === "queue_repair") {
-            eventType = "merge_steward_incident";
-            dedupeKey = `${dedupeScope}:queue_repair:${issue.linearIssueId}:${issue.lastGitHubFailureSignature ?? issue.prHeadSha ?? issue.lastGitHubFailureHeadSha ?? "unknown"}`;
-        }
-        else if (runType === "ci_repair") {
-            eventType = "settled_red_ci";
-            dedupeKey = `${dedupeScope}:ci_repair:${issue.linearIssueId}:${issue.lastGitHubFailureSignature ?? issue.prHeadSha ?? issue.lastGitHubFailureHeadSha ?? "unknown"}`;
+        if (runType === "queue_repair" || runType === "ci_repair") {
+            dedupeKey = buildRepairWakeDedupeKey({
+                scope: dedupeScope,
+                runType,
+                linearIssueId: issue.linearIssueId,
+                signature: issue.lastGitHubFailureSignature,
+                prHeadSha: issue.prHeadSha,
+                failureHeadSha: issue.lastGitHubFailureHeadSha,
+            });
         }
         else if (runType === "review_fix" || runType === "branch_upkeep") {
-            eventType = "review_changes_requested";
             dedupeKey = buildRequestedChangesWakeIdentity({
                 linearIssueId: issue.linearIssueId,
                 runType,
@@ -296,7 +286,6 @@ export class IdleIssueReconciler {
             }).dedupeKey;
         }
         else {
-            eventType = "delegated";
             dedupeKey = `${dedupeScope}:implementation:${issue.linearIssueId}`;
         }
         const requestedChangesIdentity = eventType === "review_changes_requested"

package/dist/interrupted-run-recovery.js

@@ -1,9 +1,7 @@
 import { ACTIVE_RUN_STATES } from "./factory-state.js";
 import { buildRunFailureActivity } from "./linear-session-reporting.js";
 import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
-function isRequestedChangesRunType(runType) {
-    return runType === "review_fix" || runType === "branch_upkeep";
-}
+import { isRequestedChangesRunType } from "./reactive-pr-state.js";
 function resolveRetryRunType(runType, context) {
     if (runType === "branch_upkeep") {
         return "branch_upkeep";

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

@@ -1,3 +1,4 @@
+import { CLEARED_FAILURE_PROVENANCE } from "./failure-provenance.js";
 import { buildCompletionCheckActivity } from "./linear-session-reporting.js";
 import { wakeOrchestrationParentsForChildEvent } from "./orchestration-parent-wake.js";
 function shouldContinueForUnpublishedLocalChanges(message) {
@@ -183,17 +184,7 @@ export async function handleNoPrCompletionCheck(params) {
                 pendingRunType: null,
                 pendingRunContextJson: null,
                 orchestrationSettleUntil: null,
-                lastGitHubFailureSource: null,
-                lastGitHubFailureHeadSha: null,
-                lastGitHubFailureSignature: null,
-                lastGitHubFailureCheckName: null,
-                lastGitHubFailureCheckUrl: null,
-                lastGitHubFailureContextJson: null,
-                lastGitHubFailureAt: null,
-                lastQueueIncidentJson: null,
-                lastAttemptedFailureHeadSha: null,
-                lastAttemptedFailureSignature: null,
-                lastAttemptedFailureAt: null,
+                ...CLEARED_FAILURE_PROVENANCE,
             });
             return true;
         });

package/dist/queue-health-monitor.js

@@ -1,4 +1,5 @@
 import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
+import { buildRepairWakeDedupeKey } from "./reactive-wake-keys.js";
 import { execCommand } from "./utils.js";
 const QUEUE_HEALTH_GRACE_MS = 120_000;
 const QUEUE_HEALTH_PROBE_FAILURE_COOLDOWN_MS = 300_000;
@@ -167,7 +168,12 @@ export class QueueHealthMonitor {
             this.advancer.wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
                 eventType: "merge_steward_incident",
                 eventJson: JSON.stringify(pendingRunContext),
-                dedupeKey: `queue_health:queue_repair:${issue.linearIssueId}:${signature}`,
+                dedupeKey: buildRepairWakeDedupeKey({
+                    scope: "queue_health",
+                    runType: "queue_repair",
+                    linearIssueId: issue.linearIssueId,
+                    signature,
+                }),
             });
             this.advancer.advanceIdleIssue(issue, "repairing_queue");
             this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, headRefOid, reason }, "Queue health: queue issue detected, dispatching repair");

package/dist/reactive-pr-state.js

@@ -2,6 +2,15 @@ import { readRemotePrState } from "./remote-pr-state.js";
 export function isRequestedChangesRunType(runType) {
     return runType === "review_fix" || runType === "branch_upkeep";
 }
+/**
+ * The terminal state a failed run should land the issue in: requested-changes
+ * repairs escalate (a human asked for the change, so a silent failure must
+ * surface), everything else fails. Centralized so the mapping cannot diverge
+ * between the launcher and the notification handler.
+ */
+export function resolveFailureFactoryState(runType) {
+    return isRequestedChangesRunType(runType) ? "escalated" : "failed";
+}
 export function normalizeRemotePrState(value) {
     const normalized = value?.trim().toUpperCase();
     if (normalized === "OPEN")

package/dist/reactive-run-policy.js

@@ -1,3 +1,4 @@
+import { CLEARED_FAILURE_PROVENANCE } from "./failure-provenance.js";
 import { buildReviewFixBranchUpkeepContext, isDirtyMergeStateStatus, isRequestedChangesRunType, readReactivePrSnapshot, } from "./reactive-pr-state.js";
 import { readReactivePublishDelta } from "./reactive-publish-delta.js";
 import { readLatestRequestedChangesReviewContext } from "./remote-pr-review.js";
@@ -173,17 +174,7 @@ export class ReactiveRunPolicy {
                 ...((headAdvanced || reviewFixHeadAdvanced)
                     ? {
                         prCheckStatus: "pending",
-                        lastGitHubFailureSource: null,
-                        lastGitHubFailureHeadSha: null,
-                        lastGitHubFailureSignature: null,
-                        lastGitHubFailureCheckName: null,
-                        lastGitHubFailureCheckUrl: null,
-                        lastGitHubFailureContextJson: null,
-                        lastGitHubFailureAt: null,
-                        lastQueueIncidentJson: null,
-                        lastAttemptedFailureHeadSha: null,
-                        lastAttemptedFailureSignature: null,
-                        lastAttemptedFailureAt: null,
+                        ...CLEARED_FAILURE_PROVENANCE,
                         lastGitHubCiSnapshotHeadSha: snapshot.headSha ?? null,
                         lastGitHubCiSnapshotGateCheckName: snapshot.gateCheckName,
                         lastGitHubCiSnapshotGateCheckStatus: "pending",

package/dist/reactive-wake-keys.js

@@ -62,3 +62,32 @@ function parseObject(raw) {
         return undefined;
     }
 }
+/**
+ * Map a run type to the issue-session event type that wakes it. Shared by every
+ * reconciler that records a reactive wake (idle reconciliation, startup
+ * recovery, queue health) so the mapping stays in one place.
+ */
+export function reactiveWakeEventType(runType) {
+    switch (runType) {
+        case "queue_repair":
+            return "merge_steward_incident";
+        case "ci_repair":
+            return "settled_red_ci";
+        case "review_fix":
+        case "branch_upkeep":
+            return "review_changes_requested";
+        default:
+            return "delegated";
+    }
+}
+/**
+ * Build the dedupe key for a CI/queue repair wake. The discriminator prefers the
+ * failure signature, then the PR head, then the recorded failure head, falling
+ * back to "unknown" — the same precedence every reconciler used independently
+ * before this was consolidated (a prior divergence here swallowed fresh repair
+ * incidents after the main branch advanced).
+ */
+export function buildRepairWakeDedupeKey(params) {
+    const discriminator = params.signature ?? params.prHeadSha ?? params.failureHeadSha ?? "unknown";
+    return `${params.scope}:${params.runType}:${params.linearIssueId}:${discriminator}`;
+}

package/dist/run-finalizer.js

@@ -1,3 +1,4 @@
+import { CLEARED_FAILURE_PROVENANCE } from "./failure-provenance.js";
 import { buildStageReport, countEventMethods } from "./run-reporting.js";
 import { buildRunCompletedActivity, buildRunFailureActivity } from "./linear-session-reporting.js";
 import { handleNoPrCompletionCheck } from "./no-pr-completion-check.js";
@@ -449,19 +450,7 @@ export class RunFinalizer {
                 pendingRunType: null,
                 pendingRunContextJson: null,
                 ...(postRunFollowUp ? {} : (postRunState === "awaiting_queue" || postRunState === "done"
-                    ? {
-                        lastGitHubFailureSource: null,
-                        lastGitHubFailureHeadSha: null,
-                        lastGitHubFailureSignature: null,
-                        lastGitHubFailureCheckName: null,
-                        lastGitHubFailureCheckUrl: null,
-                        lastGitHubFailureContextJson: null,
-                        lastGitHubFailureAt: null,
-                        lastQueueIncidentJson: null,
-                        lastAttemptedFailureHeadSha: null,
-                        lastAttemptedFailureSignature: null,
-                        lastAttemptedFailureAt: null,
-                    }
+                    ? { ...CLEARED_FAILURE_PROVENANCE }
                     : {})),
             });
             if (postRunFollowUp) {

package/dist/run-launcher.js

@@ -1,3 +1,4 @@
+import { resolveFailureFactoryState } from "./reactive-pr-state.js";
 import { buildHookEnv, runProjectHook } from "./hook-runner.js";
 import { buildRunFailureActivity } from "./linear-session-reporting.js";
 import { loadPatchRelayRepoPrompting } from "./patchrelay-customization.js";
@@ -228,7 +229,7 @@ export class RunLauncher {
             const message = error instanceof Error ? error.message : String(error);
             const lostLease = error instanceof Error && error.name === "IssueSessionLeaseLostError";
             if (!lostLease) {
-                const nextState = params.isRequestedChangesRunType(params.runType) ? "escalated" : "failed";
+                const nextState = resolveFailureFactoryState(params.runType);
                 this.db.issueSessions.finishRunWithLease({ projectId: params.project.id, linearIssueId: params.issue.linearIssueId, leaseId: params.leaseId }, params.run.id, {
                     status: "failed",
                     failureReason: message,

package/dist/run-notification-handler.js

@@ -1,9 +1,7 @@
 import { buildRunFailureActivity } from "./linear-session-reporting.js";
 import { extractTurnId, resolveRunCompletionStatus } from "./run-reporting.js";
 import { resolveRecoverablePostRunState } from "./interrupted-run-recovery.js";
-function isRequestedChangesRunType(runType) {
-    return runType === "review_fix" || runType === "branch_upkeep";
-}
+import { resolveFailureFactoryState } from "./reactive-pr-state.js";
 const DEFAULT_PUBLISH_COMMAND_TIMEOUT_MS = 10 * 60 * 1000;
 export class RunNotificationHandler {
     config;
@@ -91,7 +89,7 @@ export class RunNotificationHandler {
                 this.activeThreadId = undefined;
                 return;
             }
-            const nextState = isRequestedChangesRunType(run.runType) ? "escalated" : "failed";
+            const nextState = resolveFailureFactoryState(run.runType);
             const updated = this.withHeldIssueSessionLease(run.projectId, run.linearIssueId, (lease) => {
                 this.db.issueSessions.finishRunWithLease(lease, run.id, {
                     status: "failed",

package/dist/run-orchestrator.js

@@ -1,3 +1,4 @@
+import { isRequestedChangesRunType } from "./reactive-pr-state.js";
 import { summarizeCurrentThread } from "./run-reporting.js";
 import { buildReviewRoundStartedActivity, buildRunStartedActivity, } from "./linear-session-reporting.js";
 import { CompletionCheckService } from "./completion-check.js";
@@ -25,9 +26,6 @@ import { CodexThreadMaterializingError, isThreadMaterializingError } from "./cod
 function lowerCaseFirst(value) {
     return value ? `${value.slice(0, 1).toLowerCase()}${value.slice(1)}` : value;
 }
-function isRequestedChangesRunType(runType) {
-    return runType === "review_fix" || runType === "branch_upkeep";
-}
 function shouldDelayZombieRecoveryLaunch(issue, issueSession, runType) {
     if (issue.zombieRecoveryAttempts <= 0)
         return 0;
@@ -420,7 +418,6 @@ export class RunOrchestrator {
             assertLaunchLease: (targetRun, phase) => this.assertLaunchLease(targetRun, phase),
             linearSync: this.linearSync,
             releaseLease: (projectId, issueId) => this.releaseIssueSessionLease(projectId, issueId),
-            isRequestedChangesRunType,
             lowerCaseFirst,
         });
         this.assertLaunchLease(run, "before recording the active thread");

package/dist/service-startup-recovery.js

@@ -1,7 +1,7 @@
 import { appendDelegationObservedEvent } from "./delegation-audit.js";
 import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
 import { isResumablePausedLocalWork } from "./paused-issue-state.js";
-import { buildRequestedChangesWakeIdentity } from "./reactive-wake-keys.js";
+import { buildRepairWakeDedupeKey, buildRequestedChangesWakeIdentity, reactiveWakeEventType } from "./reactive-wake-keys.js";
 export class ServiceStartupRecovery {
     db;
     linearProvider;
@@ -170,20 +170,21 @@ export class ServiceStartupRecovery {
         }
     }
     appendReactiveWakeEvent(projectId, linearIssueId, issue, runType) {
-        const eventType = runType === "queue_repair"
-            ? "merge_steward_incident"
-            : runType === "ci_repair"
-                ? "settled_red_ci"
-                : "review_changes_requested";
-        const dedupeKey = runType === "queue_repair"
-            ? `startup_recovery:queue_repair:${linearIssueId}:${issue.lastGitHubFailureSignature ?? issue.prHeadSha ?? issue.lastGitHubFailureHeadSha ?? "unknown"}`
-            : runType === "ci_repair"
-                ? `startup_recovery:ci_repair:${linearIssueId}:${issue.lastGitHubFailureSignature ?? issue.prHeadSha ?? issue.lastGitHubFailureHeadSha ?? "unknown"}`
-                : buildRequestedChangesWakeIdentity({
-                    linearIssueId,
-                    runType,
-                    headSha: issue.prHeadSha,
-                }).dedupeKey;
+        const eventType = reactiveWakeEventType(runType);
+        const dedupeKey = runType === "queue_repair" || runType === "ci_repair"
+            ? buildRepairWakeDedupeKey({
+                scope: "startup_recovery",
+                runType,
+                linearIssueId,
+                signature: issue.lastGitHubFailureSignature,
+                prHeadSha: issue.prHeadSha,
+                failureHeadSha: issue.lastGitHubFailureHeadSha,
+            })
+            : buildRequestedChangesWakeIdentity({
+                linearIssueId,
+                runType,
+                headSha: issue.prHeadSha,
+            }).dedupeKey;
         const requestedChangesIdentity = eventType === "review_changes_requested"
             ? buildRequestedChangesWakeIdentity({
                 linearIssueId,

package/dist/service.js

@@ -261,8 +261,7 @@ export class PatchRelayService {
         }
         this.db.transaction(() => {
             this.db.linearInstallations.unlinkInstallationProjects(installation.id);
-            this.db.connection.prepare("DELETE FROM linear_catalog_teams WHERE installation_id = ?").run(installation.id);
-            this.db.connection.prepare("DELETE FROM linear_catalog_projects WHERE installation_id = ?").run(installation.id);
+            this.db.linearInstallations.deleteCatalogForInstallation(installation.id);
             this.db.linearInstallations.deleteLinearInstallation(installation.id);
         });
         return {

package/dist/tracked-issue-list-query.js

@@ -78,76 +78,7 @@ export class TrackedIssueListQuery {
         this.db = db;
     }
     listTrackedIssues() {
-        const rows = this.db.connection
-            .prepare(`SELECT
-          s.project_id, s.linear_issue_id, s.issue_key, i.title,
-          i.current_linear_state, i.factory_state, i.delegated_to_patchrelay, s.session_state, s.waiting_reason, s.summary_text, s.display_updated_at,
-          i.pending_run_type,
-          i.orchestration_settle_until,
-          i.pr_number, i.pr_state, i.pr_head_sha, i.pr_review_state, i.pr_check_status, i.last_blocking_review_head_sha,
-          i.last_github_ci_snapshot_json,
-          i.last_github_failure_source,
-          i.last_github_failure_head_sha,
-          i.last_github_failure_check_name,
-          i.last_github_failure_context_json,
-          active_run.run_type AS active_run_type,
-          active_run.completion_check_thread_id AS active_completion_check_thread_id,
-          active_run.completion_check_outcome AS active_completion_check_outcome,
-          latest_run.run_type AS latest_run_type,
-          latest_run.status AS latest_run_status,
-          latest_run.summary_json AS latest_run_summary_json,
-          latest_run.report_json AS latest_run_report_json,
-          latest_run.completion_check_thread_id AS latest_run_completion_check_thread_id,
-          latest_run.completion_check_outcome AS latest_run_completion_check_outcome,
-          latest_run.completion_check_summary AS latest_run_completion_check_summary,
-          latest_run.completion_check_question AS latest_run_completion_check_question,
-          latest_run.completion_check_why AS latest_run_completion_check_why,
-          latest_run.completion_check_recommended_reply AS latest_run_completion_check_recommended_reply,
-          (
-            SELECT COUNT(*)
-            FROM issue_session_events e
-            WHERE e.project_id = s.project_id
-              AND e.linear_issue_id = s.linear_issue_id
-              AND e.processed_at IS NULL
-          ) AS pending_session_event_count,
-          (
-            SELECT COUNT(*)
-            FROM issue_dependencies d
-            LEFT JOIN issues blockers
-              ON blockers.project_id = d.project_id
-             AND blockers.linear_issue_id = d.blocker_linear_issue_id
-            WHERE d.project_id = s.project_id
-              AND d.linear_issue_id = s.linear_issue_id
-              AND (
-                COALESCE(blockers.current_linear_state_type, d.blocker_current_linear_state_type, '') != 'completed'
-                AND LOWER(TRIM(COALESCE(blockers.current_linear_state, d.blocker_current_linear_state, ''))) != 'done'
-              )
-          ) AS blocked_by_count,
-          (
-            SELECT json_group_array(COALESCE(blockers.issue_key, d.blocker_issue_key, d.blocker_linear_issue_id))
-            FROM issue_dependencies d
-            LEFT JOIN issues blockers
-              ON blockers.project_id = d.project_id
-             AND blockers.linear_issue_id = d.blocker_linear_issue_id
-            WHERE d.project_id = s.project_id
-              AND d.linear_issue_id = s.linear_issue_id
-              AND (
-                COALESCE(blockers.current_linear_state_type, d.blocker_current_linear_state_type, '') != 'completed'
-                AND LOWER(TRIM(COALESCE(blockers.current_linear_state, d.blocker_current_linear_state, ''))) != 'done'
-              )
-          ) AS blocked_by_keys_json
-        FROM issue_sessions s
-        LEFT JOIN issues i
-          ON i.project_id = s.project_id
-         AND i.linear_issue_id = s.linear_issue_id
-        LEFT JOIN runs active_run ON active_run.id = COALESCE(s.active_run_id, i.active_run_id)
-        LEFT JOIN runs latest_run ON latest_run.id = (
-          SELECT r.id FROM runs r
-          WHERE r.project_id = s.project_id AND r.linear_issue_id = s.linear_issue_id
-          ORDER BY r.id DESC LIMIT 1
-        )
-        ORDER BY s.display_updated_at DESC, s.issue_key ASC`)
-            .all();
+        const rows = this.db.issueSessions.listTrackedIssueRows();
         return rows.map((row) => {
             const failureContext = parseGitHubFailureContext(typeof row.last_github_failure_context_json === "string" ? row.last_github_failure_context_json : undefined);
             const prChecksSummary = parseCiSnapshotSummary(typeof row.last_github_ci_snapshot_json === "string" ? row.last_github_ci_snapshot_json : undefined);

package/package.json

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