patchrelay 0.68.1 → 0.68.2

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.68.1",
-  "commit": "1cc1884e5fe9",
-  "builtAt": "2026-05-15T07:24:40.081Z"
+  "version": "0.68.2",
+  "commit": "396b8e7a3462",
+  "builtAt": "2026-05-15T11:40:22.942Z"
 }

package/dist/db/issue-store.js

@@ -1,3 +1,4 @@
+import { buildInsertBindings, buildUpdateAssignments } from "./issue-upsert-columns.js";
 import { isoNow } from "./shared.js";
 export class IssueStore {
     connection;
@@ -10,355 +11,22 @@ export class IssueStore {
         const now = isoNow();
         const existing = this.getIssue(params.projectId, params.linearIssueId);
         if (existing) {
-            const sets = ["updated_at = @now"];
-            const values = {
+            const { assignments, values } = buildUpdateAssignments(params);
+            const sql = `UPDATE issues SET ${["updated_at = @now", ...assignments].join(", ")} WHERE project_id = @projectId AND linear_issue_id = @linearIssueId`;
+            this.connection.prepare(sql).run({
+                ...values,
                 now,
                 projectId: params.projectId,
                 linearIssueId: params.linearIssueId,
-            };
-            if (params.delegatedToPatchRelay !== undefined) {
-                sets.push("delegated_to_patchrelay = @delegatedToPatchRelay");
-                values.delegatedToPatchRelay = params.delegatedToPatchRelay ? 1 : 0;
-            }
-            if (params.issueClass !== undefined) {
-                sets.push("issue_class = @issueClass");
-                values.issueClass = params.issueClass;
-            }
-            if (params.issueClassSource !== undefined) {
-                sets.push("issue_class_source = @issueClassSource");
-                values.issueClassSource = params.issueClassSource;
-            }
-            if (params.issueTriageHash !== undefined) {
-                sets.push("issue_triage_hash = @issueTriageHash");
-                values.issueTriageHash = params.issueTriageHash;
-            }
-            if (params.issueTriageResultJson !== undefined) {
-                sets.push("issue_triage_result_json = @issueTriageResultJson");
-                values.issueTriageResultJson = params.issueTriageResultJson;
-            }
-            if (params.parentLinearIssueId !== undefined) {
-                sets.push("parent_linear_issue_id = @parentLinearIssueId");
-                values.parentLinearIssueId = params.parentLinearIssueId;
-            }
-            if (params.parentIssueKey !== undefined) {
-                sets.push("parent_issue_key = @parentIssueKey");
-                values.parentIssueKey = params.parentIssueKey;
-            }
-            if (params.issueKey !== undefined) {
-                sets.push("issue_key = COALESCE(@issueKey, issue_key)");
-                values.issueKey = params.issueKey;
-            }
-            if (params.title !== undefined) {
-                sets.push("title = COALESCE(@title, title)");
-                values.title = params.title;
-            }
-            if (params.description !== undefined) {
-                sets.push("description = COALESCE(@description, description)");
-                values.description = params.description;
-            }
-            if (params.url !== undefined) {
-                sets.push("url = COALESCE(@url, url)");
-                values.url = params.url;
-            }
-            if (params.priority !== undefined) {
-                sets.push("priority = @priority");
-                values.priority = params.priority;
-            }
-            if (params.estimate !== undefined) {
-                sets.push("estimate = @estimate");
-                values.estimate = params.estimate;
-            }
-            if (params.currentLinearState !== undefined) {
-                sets.push("current_linear_state = COALESCE(@currentLinearState, current_linear_state)");
-                values.currentLinearState = params.currentLinearState;
-            }
-            if (params.currentLinearStateType !== undefined) {
-                sets.push("current_linear_state_type = COALESCE(@currentLinearStateType, current_linear_state_type)");
-                values.currentLinearStateType = params.currentLinearStateType;
-            }
-            if (params.factoryState !== undefined) {
-                sets.push("factory_state = @factoryState");
-                values.factoryState = params.factoryState;
-            }
-            if (params.pendingRunType !== undefined) {
-                sets.push("pending_run_type = @pendingRunType");
-                values.pendingRunType = params.pendingRunType;
-            }
-            if (params.pendingRunContextJson !== undefined) {
-                sets.push("pending_run_context_json = @pendingRunContextJson");
-                values.pendingRunContextJson = params.pendingRunContextJson;
-            }
-            if (params.branchName !== undefined) {
-                sets.push("branch_name = COALESCE(@branchName, branch_name)");
-                values.branchName = params.branchName;
-            }
-            if (params.worktreePath !== undefined) {
-                sets.push("worktree_path = COALESCE(@worktreePath, worktree_path)");
-                values.worktreePath = params.worktreePath;
-            }
-            if (params.threadId !== undefined) {
-                sets.push("thread_id = @threadId");
-                values.threadId = params.threadId;
-            }
-            if (params.activeRunId !== undefined) {
-                sets.push("active_run_id = @activeRunId");
-                values.activeRunId = params.activeRunId;
-            }
-            if (params.statusCommentId !== undefined) {
-                sets.push("status_comment_id = @statusCommentId");
-                values.statusCommentId = params.statusCommentId;
-            }
-            if (params.agentSessionId !== undefined) {
-                sets.push("agent_session_id = @agentSessionId");
-                values.agentSessionId = params.agentSessionId;
-            }
-            if (params.lastLinearActivityKey !== undefined) {
-                sets.push("last_linear_activity_key = @lastLinearActivityKey");
-                values.lastLinearActivityKey = params.lastLinearActivityKey;
-            }
-            if (params.prNumber !== undefined) {
-                sets.push("pr_number = @prNumber");
-                values.prNumber = params.prNumber;
-            }
-            if (params.prUrl !== undefined) {
-                sets.push("pr_url = @prUrl");
-                values.prUrl = params.prUrl;
-            }
-            if (params.prState !== undefined) {
-                sets.push("pr_state = @prState");
-                values.prState = params.prState;
-            }
-            if (params.prIsDraft !== undefined) {
-                sets.push("pr_is_draft = @prIsDraft");
-                values.prIsDraft = params.prIsDraft == null ? null : params.prIsDraft ? 1 : 0;
-            }
-            if (params.prHeadSha !== undefined) {
-                sets.push("pr_head_sha = @prHeadSha");
-                values.prHeadSha = params.prHeadSha;
-            }
-            if (params.prAuthorLogin !== undefined) {
-                sets.push("pr_author_login = @prAuthorLogin");
-                values.prAuthorLogin = params.prAuthorLogin;
-            }
-            if (params.prReviewState !== undefined) {
-                sets.push("pr_review_state = @prReviewState");
-                values.prReviewState = params.prReviewState;
-            }
-            if (params.prCheckStatus !== undefined) {
-                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;
-            }
-            if (params.lastGitHubFailureHeadSha !== undefined) {
-                sets.push("last_github_failure_head_sha = @lastGitHubFailureHeadSha");
-                values.lastGitHubFailureHeadSha = params.lastGitHubFailureHeadSha;
-            }
-            if (params.lastGitHubFailureSignature !== undefined) {
-                sets.push("last_github_failure_signature = @lastGitHubFailureSignature");
-                values.lastGitHubFailureSignature = params.lastGitHubFailureSignature;
-            }
-            if (params.lastGitHubFailureCheckName !== undefined) {
-                sets.push("last_github_failure_check_name = @lastGitHubFailureCheckName");
-                values.lastGitHubFailureCheckName = params.lastGitHubFailureCheckName;
-            }
-            if (params.lastGitHubFailureCheckUrl !== undefined) {
-                sets.push("last_github_failure_check_url = @lastGitHubFailureCheckUrl");
-                values.lastGitHubFailureCheckUrl = params.lastGitHubFailureCheckUrl;
-            }
-            if (params.lastGitHubFailureContextJson !== undefined) {
-                sets.push("last_github_failure_context_json = @lastGitHubFailureContextJson");
-                values.lastGitHubFailureContextJson = params.lastGitHubFailureContextJson;
-            }
-            if (params.lastGitHubFailureAt !== undefined) {
-                sets.push("last_github_failure_at = @lastGitHubFailureAt");
-                values.lastGitHubFailureAt = params.lastGitHubFailureAt;
-            }
-            if (params.lastGitHubCiSnapshotHeadSha !== undefined) {
-                sets.push("last_github_ci_snapshot_head_sha = @lastGitHubCiSnapshotHeadSha");
-                values.lastGitHubCiSnapshotHeadSha = params.lastGitHubCiSnapshotHeadSha;
-            }
-            if (params.lastGitHubCiSnapshotGateCheckName !== undefined) {
-                sets.push("last_github_ci_snapshot_gate_check_name = @lastGitHubCiSnapshotGateCheckName");
-                values.lastGitHubCiSnapshotGateCheckName = params.lastGitHubCiSnapshotGateCheckName;
-            }
-            if (params.lastGitHubCiSnapshotGateCheckStatus !== undefined) {
-                sets.push("last_github_ci_snapshot_gate_check_status = @lastGitHubCiSnapshotGateCheckStatus");
-                values.lastGitHubCiSnapshotGateCheckStatus = params.lastGitHubCiSnapshotGateCheckStatus;
-            }
-            if (params.lastGitHubCiSnapshotJson !== undefined) {
-                sets.push("last_github_ci_snapshot_json = @lastGitHubCiSnapshotJson");
-                values.lastGitHubCiSnapshotJson = params.lastGitHubCiSnapshotJson;
-            }
-            if (params.lastGitHubCiSnapshotSettledAt !== undefined) {
-                sets.push("last_github_ci_snapshot_settled_at = @lastGitHubCiSnapshotSettledAt");
-                values.lastGitHubCiSnapshotSettledAt = params.lastGitHubCiSnapshotSettledAt;
-            }
-            if (params.lastQueueSignalAt !== undefined) {
-                sets.push("last_queue_signal_at = @lastQueueSignalAt");
-                values.lastQueueSignalAt = params.lastQueueSignalAt;
-            }
-            if (params.lastQueueIncidentJson !== undefined) {
-                sets.push("last_queue_incident_json = @lastQueueIncidentJson");
-                values.lastQueueIncidentJson = params.lastQueueIncidentJson;
-            }
-            if (params.lastAttemptedFailureHeadSha !== undefined) {
-                sets.push("last_attempted_failure_head_sha = @lastAttemptedFailureHeadSha");
-                values.lastAttemptedFailureHeadSha = params.lastAttemptedFailureHeadSha;
-            }
-            if (params.lastAttemptedFailureSignature !== undefined) {
-                sets.push("last_attempted_failure_signature = @lastAttemptedFailureSignature");
-                values.lastAttemptedFailureSignature = params.lastAttemptedFailureSignature;
-            }
-            if (params.lastAttemptedFailureAt !== undefined) {
-                sets.push("last_attempted_failure_at = @lastAttemptedFailureAt");
-                values.lastAttemptedFailureAt = params.lastAttemptedFailureAt;
-            }
-            if (params.lastPublishedPatchId !== undefined) {
-                sets.push("last_published_patch_id = @lastPublishedPatchId");
-                values.lastPublishedPatchId = params.lastPublishedPatchId;
-            }
-            if (params.lastPublishedIntegrationTreeId !== undefined) {
-                sets.push("last_published_integration_tree_id = @lastPublishedIntegrationTreeId");
-                values.lastPublishedIntegrationTreeId = params.lastPublishedIntegrationTreeId;
-            }
-            if (params.lastPublishedHeadSha !== undefined) {
-                sets.push("last_published_head_sha = @lastPublishedHeadSha");
-                values.lastPublishedHeadSha = params.lastPublishedHeadSha;
-            }
-            if (params.parentPrBranch !== undefined) {
-                sets.push("parent_pr_branch = @parentPrBranch");
-                values.parentPrBranch = params.parentPrBranch;
-            }
-            if (params.ciRepairAttempts !== undefined) {
-                sets.push("ci_repair_attempts = @ciRepairAttempts");
-                values.ciRepairAttempts = params.ciRepairAttempts;
-            }
-            if (params.queueRepairAttempts !== undefined) {
-                sets.push("queue_repair_attempts = @queueRepairAttempts");
-                values.queueRepairAttempts = params.queueRepairAttempts;
-            }
-            if (params.reviewFixAttempts !== undefined) {
-                sets.push("review_fix_attempts = @reviewFixAttempts");
-                values.reviewFixAttempts = params.reviewFixAttempts;
-            }
-            if (params.zombieRecoveryAttempts !== undefined) {
-                sets.push("zombie_recovery_attempts = @zombieRecoveryAttempts");
-                values.zombieRecoveryAttempts = params.zombieRecoveryAttempts;
-            }
-            if (params.lastZombieRecoveryAt !== undefined) {
-                sets.push("last_zombie_recovery_at = @lastZombieRecoveryAt");
-                values.lastZombieRecoveryAt = params.lastZombieRecoveryAt;
-            }
-            if (params.orchestrationSettleUntil !== undefined) {
-                sets.push("orchestration_settle_until = @orchestrationSettleUntil");
-                values.orchestrationSettleUntil = params.orchestrationSettleUntil;
-            }
-            this.connection.prepare(`UPDATE issues SET ${sets.join(", ")} WHERE project_id = @projectId AND linear_issue_id = @linearIssueId`).run(values);
+            });
         }
         else {
-            this.connection.prepare(`
-        INSERT INTO issues (
-          project_id, linear_issue_id, delegated_to_patchrelay, issue_class, issue_class_source, issue_triage_hash, issue_triage_result_json, parent_linear_issue_id, parent_issue_key, issue_key, title, description, url,
-          priority, estimate,
-          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, last_linear_activity_key,
-          pr_number, pr_url, pr_state, pr_is_draft, 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,
-          last_attempted_failure_head_sha, last_attempted_failure_signature, last_attempted_failure_at,
-          last_published_patch_id, last_published_integration_tree_id, last_published_head_sha,
-          parent_pr_branch,
-          ci_repair_attempts, queue_repair_attempts, review_fix_attempts, zombie_recovery_attempts, last_zombie_recovery_at, orchestration_settle_until,
-          updated_at
-        ) VALUES (
-          @projectId, @linearIssueId, @delegatedToPatchRelay, @issueClass, @issueClassSource, @issueTriageHash, @issueTriageResultJson, @parentLinearIssueId, @parentIssueKey, @issueKey, @title, @description, @url,
-          @priority, @estimate,
-          @currentLinearState, @currentLinearStateType, @factoryState, @pendingRunType, @pendingRunContextJson,
-          @branchName, @worktreePath, @threadId, @activeRunId, @statusCommentId,
-          @agentSessionId, @lastLinearActivityKey,
-          @prNumber, @prUrl, @prState, @prIsDraft, @prHeadSha, @prAuthorLogin, @prReviewState, @prCheckStatus, @lastBlockingReviewHeadSha,
-          @lastGitHubFailureSource, @lastGitHubFailureHeadSha, @lastGitHubFailureSignature, @lastGitHubFailureCheckName, @lastGitHubFailureCheckUrl, @lastGitHubFailureContextJson, @lastGitHubFailureAt,
-          @lastGitHubCiSnapshotHeadSha, @lastGitHubCiSnapshotGateCheckName, @lastGitHubCiSnapshotGateCheckStatus, @lastGitHubCiSnapshotJson, @lastGitHubCiSnapshotSettledAt,
-          @lastQueueSignalAt, @lastQueueIncidentJson,
-          @lastAttemptedFailureHeadSha, @lastAttemptedFailureSignature, @lastAttemptedFailureAt,
-          @lastPublishedPatchId, @lastPublishedIntegrationTreeId, @lastPublishedHeadSha,
-          @parentPrBranch,
-          @ciRepairAttempts, @queueRepairAttempts, @reviewFixAttempts, @zombieRecoveryAttempts, @lastZombieRecoveryAt, @orchestrationSettleUntil,
-          @now
-        )
-      `).run({
+            const { columns, placeholders, values } = buildInsertBindings(params);
+            const sql = `INSERT INTO issues (project_id, linear_issue_id, ${columns.join(", ")}, updated_at) VALUES (@projectId, @linearIssueId, ${placeholders.join(", ")}, @now)`;
+            this.connection.prepare(sql).run({
+                ...values,
                 projectId: params.projectId,
                 linearIssueId: params.linearIssueId,
-                delegatedToPatchRelay: params.delegatedToPatchRelay === false ? 0 : 1,
-                issueClass: params.issueClass ?? null,
-                issueClassSource: params.issueClassSource ?? null,
-                issueTriageHash: params.issueTriageHash ?? null,
-                issueTriageResultJson: params.issueTriageResultJson ?? null,
-                parentLinearIssueId: params.parentLinearIssueId ?? null,
-                parentIssueKey: params.parentIssueKey ?? null,
-                issueKey: params.issueKey ?? null,
-                title: params.title ?? null,
-                description: params.description ?? null,
-                url: params.url ?? null,
-                priority: params.priority ?? null,
-                estimate: params.estimate ?? null,
-                currentLinearState: params.currentLinearState ?? null,
-                currentLinearStateType: params.currentLinearStateType ?? null,
-                factoryState: params.factoryState ?? "delegated",
-                pendingRunType: params.pendingRunType ?? null,
-                pendingRunContextJson: params.pendingRunContextJson ?? null,
-                branchName: params.branchName ?? null,
-                worktreePath: params.worktreePath ?? null,
-                threadId: params.threadId ?? null,
-                activeRunId: params.activeRunId ?? null,
-                statusCommentId: params.statusCommentId ?? null,
-                agentSessionId: params.agentSessionId ?? null,
-                lastLinearActivityKey: params.lastLinearActivityKey ?? null,
-                prNumber: params.prNumber ?? null,
-                prUrl: params.prUrl ?? null,
-                prState: params.prState ?? null,
-                prIsDraft: params.prIsDraft == null ? null : params.prIsDraft ? 1 : 0,
-                prHeadSha: params.prHeadSha ?? null,
-                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,
-                lastGitHubFailureCheckName: params.lastGitHubFailureCheckName ?? null,
-                lastGitHubFailureCheckUrl: params.lastGitHubFailureCheckUrl ?? null,
-                lastGitHubFailureContextJson: params.lastGitHubFailureContextJson ?? null,
-                lastGitHubFailureAt: params.lastGitHubFailureAt ?? null,
-                lastGitHubCiSnapshotHeadSha: params.lastGitHubCiSnapshotHeadSha ?? null,
-                lastGitHubCiSnapshotGateCheckName: params.lastGitHubCiSnapshotGateCheckName ?? null,
-                lastGitHubCiSnapshotGateCheckStatus: params.lastGitHubCiSnapshotGateCheckStatus ?? null,
-                lastGitHubCiSnapshotJson: params.lastGitHubCiSnapshotJson ?? null,
-                lastGitHubCiSnapshotSettledAt: params.lastGitHubCiSnapshotSettledAt ?? null,
-                lastQueueSignalAt: params.lastQueueSignalAt ?? null,
-                lastQueueIncidentJson: params.lastQueueIncidentJson ?? null,
-                lastAttemptedFailureHeadSha: params.lastAttemptedFailureHeadSha ?? null,
-                lastAttemptedFailureSignature: params.lastAttemptedFailureSignature ?? null,
-                lastAttemptedFailureAt: params.lastAttemptedFailureAt ?? null,
-                lastPublishedPatchId: params.lastPublishedPatchId ?? null,
-                lastPublishedIntegrationTreeId: params.lastPublishedIntegrationTreeId ?? null,
-                lastPublishedHeadSha: params.lastPublishedHeadSha ?? null,
-                parentPrBranch: params.parentPrBranch ?? null,
-                ciRepairAttempts: params.ciRepairAttempts ?? 0,
-                queueRepairAttempts: params.queueRepairAttempts ?? 0,
-                reviewFixAttempts: params.reviewFixAttempts ?? 0,
-                zombieRecoveryAttempts: params.zombieRecoveryAttempts ?? 0,
-                lastZombieRecoveryAt: params.lastZombieRecoveryAt ?? null,
-                orchestrationSettleUntil: params.orchestrationSettleUntil ?? null,
                 now,
             });
         }

package/dist/db/issue-upsert-columns.js

@@ -0,0 +1,119 @@
+const booleanToInt = (value) => value === true || value === 1 ? 1 : 0;
+const nullableBooleanToInt = (value) => {
+    if (value == null)
+        return null;
+    return value === true || value === 1 ? 1 : 0;
+};
+/**
+ * Source-of-truth column map for `upsertIssue`. Ordered to match the INSERT
+ * column list so a quick read shows the table shape end-to-end. Adding a new
+ * field is a one-line addition here instead of editing three parallel lists.
+ */
+export const ISSUE_COLUMN_DEFS = {
+    delegatedToPatchRelay: { column: "delegated_to_patchrelay", transform: booleanToInt, insertDefault: 1 },
+    issueClass: { column: "issue_class" },
+    issueClassSource: { column: "issue_class_source" },
+    issueTriageHash: { column: "issue_triage_hash" },
+    issueTriageResultJson: { column: "issue_triage_result_json" },
+    parentLinearIssueId: { column: "parent_linear_issue_id" },
+    parentIssueKey: { column: "parent_issue_key" },
+    issueKey: { column: "issue_key", coalesce: true },
+    title: { column: "title", coalesce: true },
+    description: { column: "description", coalesce: true },
+    url: { column: "url", coalesce: true },
+    priority: { column: "priority" },
+    estimate: { column: "estimate" },
+    currentLinearState: { column: "current_linear_state", coalesce: true },
+    currentLinearStateType: { column: "current_linear_state_type", coalesce: true },
+    factoryState: { column: "factory_state", insertDefault: "delegated" },
+    pendingRunType: { column: "pending_run_type" },
+    pendingRunContextJson: { column: "pending_run_context_json" },
+    branchName: { column: "branch_name", coalesce: true },
+    worktreePath: { column: "worktree_path", coalesce: true },
+    threadId: { column: "thread_id" },
+    activeRunId: { column: "active_run_id" },
+    statusCommentId: { column: "status_comment_id" },
+    agentSessionId: { column: "agent_session_id" },
+    lastLinearActivityKey: { column: "last_linear_activity_key" },
+    prNumber: { column: "pr_number" },
+    prUrl: { column: "pr_url" },
+    prState: { column: "pr_state" },
+    prIsDraft: { column: "pr_is_draft", transform: nullableBooleanToInt },
+    prHeadSha: { column: "pr_head_sha" },
+    prAuthorLogin: { column: "pr_author_login" },
+    prReviewState: { column: "pr_review_state" },
+    prCheckStatus: { column: "pr_check_status" },
+    lastBlockingReviewHeadSha: { column: "last_blocking_review_head_sha" },
+    lastGitHubFailureSource: { column: "last_github_failure_source" },
+    lastGitHubFailureHeadSha: { column: "last_github_failure_head_sha" },
+    lastGitHubFailureSignature: { column: "last_github_failure_signature" },
+    lastGitHubFailureCheckName: { column: "last_github_failure_check_name" },
+    lastGitHubFailureCheckUrl: { column: "last_github_failure_check_url" },
+    lastGitHubFailureContextJson: { column: "last_github_failure_context_json" },
+    lastGitHubFailureAt: { column: "last_github_failure_at" },
+    lastGitHubCiSnapshotHeadSha: { column: "last_github_ci_snapshot_head_sha" },
+    lastGitHubCiSnapshotGateCheckName: { column: "last_github_ci_snapshot_gate_check_name" },
+    lastGitHubCiSnapshotGateCheckStatus: { column: "last_github_ci_snapshot_gate_check_status" },
+    lastGitHubCiSnapshotJson: { column: "last_github_ci_snapshot_json" },
+    lastGitHubCiSnapshotSettledAt: { column: "last_github_ci_snapshot_settled_at" },
+    lastQueueSignalAt: { column: "last_queue_signal_at" },
+    lastQueueIncidentJson: { column: "last_queue_incident_json" },
+    lastAttemptedFailureHeadSha: { column: "last_attempted_failure_head_sha" },
+    lastAttemptedFailureSignature: { column: "last_attempted_failure_signature" },
+    lastAttemptedFailureAt: { column: "last_attempted_failure_at" },
+    lastPublishedPatchId: { column: "last_published_patch_id" },
+    lastPublishedIntegrationTreeId: { column: "last_published_integration_tree_id" },
+    lastPublishedHeadSha: { column: "last_published_head_sha" },
+    parentPrBranch: { column: "parent_pr_branch" },
+    ciRepairAttempts: { column: "ci_repair_attempts", insertDefault: 0 },
+    queueRepairAttempts: { column: "queue_repair_attempts", insertDefault: 0 },
+    reviewFixAttempts: { column: "review_fix_attempts", insertDefault: 0 },
+    zombieRecoveryAttempts: { column: "zombie_recovery_attempts", insertDefault: 0 },
+    lastZombieRecoveryAt: { column: "last_zombie_recovery_at" },
+    orchestrationSettleUntil: { column: "orchestration_settle_until" },
+};
+export const ISSUE_COLUMN_KEYS = Object.keys(ISSUE_COLUMN_DEFS);
+/**
+ * Builds the `SET col = @param` fragments and the bound-value bag for an
+ * UPDATE. Only fields explicitly set in `params` are included so we don't
+ * accidentally clobber other columns.
+ */
+export function buildUpdateAssignments(params) {
+    const assignments = [];
+    const values = {};
+    for (const key of ISSUE_COLUMN_KEYS) {
+        const value = params[key];
+        if (value === undefined)
+            continue;
+        const def = ISSUE_COLUMN_DEFS[key];
+        const bound = def.transform ? def.transform(value) : value;
+        assignments.push(def.coalesce
+            ? `${def.column} = COALESCE(@${key}, ${def.column})`
+            : `${def.column} = @${key}`);
+        values[key] = bound;
+    }
+    return { assignments, values };
+}
+/**
+ * Builds the columns list, the placeholders list, and the bound-value bag for
+ * an INSERT. Every column is emitted (NULL if the param is omitted and no
+ * `insertDefault` is set) so the SQL stays stable across calls.
+ */
+export function buildInsertBindings(params) {
+    const columns = [];
+    const placeholders = [];
+    const values = {};
+    for (const key of ISSUE_COLUMN_KEYS) {
+        const def = ISSUE_COLUMN_DEFS[key];
+        columns.push(def.column);
+        placeholders.push(`@${key}`);
+        const raw = params[key];
+        const resolved = raw !== undefined ? raw : def.insertDefault;
+        if (resolved === undefined) {
+            values[key] = null;
+            continue;
+        }
+        values[key] = def.transform ? def.transform(resolved) : resolved;
+    }
+    return { columns, placeholders, values };
+}

package/dist/idle-reconciliation-helpers.js

@@ -0,0 +1,100 @@
+import { parseGitHubFailureContext } from "./github-failure-context.js";
+import { parseStoredQueueRepairContext } from "./merge-queue-incident.js";
+export function isFailingCheckStatus(status) {
+    return status === "failed" || status === "failure";
+}
+export function isReviewDecisionApproved(value) {
+    return value?.trim().toUpperCase() === "APPROVED";
+}
+export function isReviewDecisionChangesRequested(value) {
+    return value?.trim().toUpperCase() === "CHANGES_REQUESTED";
+}
+export function isReviewDecisionReviewRequired(value) {
+    return value?.trim().toUpperCase() === "REVIEW_REQUIRED";
+}
+export function buildBranchUpkeepContext(prNumber, baseBranch, mergeStateStatus, headSha) {
+    const promptContext = [
+        `The requested code change may already be present, but GitHub still reports PR #${prNumber} as ${mergeStateStatus ?? "DIRTY"} against latest ${baseBranch}.`,
+        `This turn is branch upkeep on the existing PR branch: update onto latest ${baseBranch}, resolve any conflicts, rerun the narrowest relevant verification, and push a newer head.`,
+        "Do not stop just because the requested code change is already present. Review can only move forward after a new pushed head.",
+    ].join(" ");
+    return {
+        branchUpkeepRequired: true,
+        reviewFixMode: "branch_upkeep",
+        wakeReason: "branch_upkeep",
+        promptContext,
+        ...(mergeStateStatus ? { mergeStateStatus } : {}),
+        ...(headSha ? { failingHeadSha: headSha } : {}),
+        baseBranch,
+    };
+}
+export function hasCompletedReviewQuillVerdict(entries) {
+    return (entries ?? []).some((entry) => entry.__typename === "CheckRun"
+        && entry.name === "review-quill/verdict"
+        && entry.status === "COMPLETED");
+}
+export function getGateCheckNames(project) {
+    const configured = project?.gateChecks?.map((entry) => entry.trim()).filter(Boolean) ?? [];
+    return configured.length > 0 ? configured : ["verify"];
+}
+/**
+ * A repair attempt is "duplicate" when we have already tried to repair the
+ * exact same failure (same signature, same head SHA) AND no newer failure
+ * has been observed since that attempt was recorded. For queue evictions
+ * the PR head doesn't advance between attempts, so we additionally compare
+ * the timestamps: a fresh incident after `main` advances looks identical
+ * to a stale one without the timestamp check.
+ */
+export function isDuplicateRepairAttempt(issue, context) {
+    const signature = typeof context?.failureSignature === "string" ? context.failureSignature : undefined;
+    const headSha = typeof context?.failureHeadSha === "string"
+        ? context.failureHeadSha
+        : typeof context?.headSha === "string" ? context.headSha : undefined;
+    if (!signature)
+        return false;
+    if (issue.lastAttemptedFailureSignature !== signature)
+        return false;
+    if (headSha !== undefined && issue.lastAttemptedFailureHeadSha !== headSha)
+        return false;
+    if (issue.lastAttemptedFailureAt && issue.lastGitHubFailureAt
+        && issue.lastGitHubFailureAt > issue.lastAttemptedFailureAt) {
+        return false;
+    }
+    return true;
+}
+export function buildFailureContext(issue) {
+    const storedFailureContext = parseGitHubFailureContext(issue.lastGitHubFailureContextJson);
+    const queueRepairContext = issue.lastQueueIncidentJson
+        ? parseStoredQueueRepairContext(issue.lastQueueIncidentJson)
+        : undefined;
+    if (!queueRepairContext
+        && !issue.lastGitHubFailureSource
+        && !issue.lastGitHubFailureHeadSha
+        && !issue.lastGitHubFailureSignature
+        && !issue.lastGitHubFailureCheckName
+        && !issue.lastGitHubFailureCheckUrl
+        && !storedFailureContext) {
+        return undefined;
+    }
+    return {
+        ...(issue.lastGitHubFailureSource ? { failureReason: issue.lastGitHubFailureSource } : {}),
+        ...(issue.lastGitHubFailureHeadSha ? { failureHeadSha: issue.lastGitHubFailureHeadSha } : {}),
+        ...(issue.lastGitHubFailureSignature ? { failureSignature: issue.lastGitHubFailureSignature } : {}),
+        ...(issue.lastGitHubFailureCheckName ? { checkName: issue.lastGitHubFailureCheckName } : {}),
+        ...(issue.lastGitHubFailureCheckUrl ? { checkUrl: issue.lastGitHubFailureCheckUrl } : {}),
+        ...(storedFailureContext ? storedFailureContext : {}),
+        ...(queueRepairContext ? queueRepairContext : {}),
+    };
+}
+export function hasFailureProvenance(issue) {
+    return Boolean(issue.lastGitHubFailureSource
+        || issue.lastGitHubFailureHeadSha
+        || issue.lastGitHubFailureSignature
+        || issue.lastGitHubFailureCheckName
+        || issue.lastGitHubFailureCheckUrl
+        || issue.lastGitHubFailureContextJson
+        || issue.lastGitHubFailureAt
+        || issue.lastQueueIncidentJson
+        || issue.lastAttemptedFailureHeadSha
+        || issue.lastAttemptedFailureSignature);
+}

package/dist/idle-reconciliation.js

@@ -1,107 +1,12 @@
+import { buildBranchUpkeepContext, buildFailureContext, getGateCheckNames, hasCompletedReviewQuillVerdict, hasFailureProvenance, isDuplicateRepairAttempt, isFailingCheckStatus, isReviewDecisionApproved, isReviewDecisionChangesRequested, isReviewDecisionReviewRequired, } from "./idle-reconciliation-helpers.js";
 import { isMainRepairIssue } from "./main-repair.js";
 import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
-import { parseGitHubFailureContext } from "./github-failure-context.js";
 import { deriveGateCheckStatusFromRollup } from "./github-rollup.js";
 import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
-import { parseStoredQueueRepairContext } from "./merge-queue-incident.js";
 import { buildClosedPrCleanupFields, resolveClosedPrDisposition } from "./pr-state.js";
 import { getReviewFixBudget } from "./run-budgets.js";
 import { queueSettledOrchestrationIssue } from "./orchestration-parent-wake.js";
 import { execCommand } from "./utils.js";
-function isFailingCheckStatus(status) {
-    return status === "failed" || status === "failure";
-}
-function isReviewDecisionApproved(value) {
-    return value?.trim().toUpperCase() === "APPROVED";
-}
-function isReviewDecisionChangesRequested(value) {
-    return value?.trim().toUpperCase() === "CHANGES_REQUESTED";
-}
-function isReviewDecisionReviewRequired(value) {
-    return value?.trim().toUpperCase() === "REVIEW_REQUIRED";
-}
-function buildBranchUpkeepContext(prNumber, baseBranch, mergeStateStatus, headSha) {
-    const promptContext = [
-        `The requested code change may already be present, but GitHub still reports PR #${prNumber} as ${mergeStateStatus ?? "DIRTY"} against latest ${baseBranch}.`,
-        `This turn is branch upkeep on the existing PR branch: update onto latest ${baseBranch}, resolve any conflicts, rerun the narrowest relevant verification, and push a newer head.`,
-        "Do not stop just because the requested code change is already present. Review can only move forward after a new pushed head.",
-    ].join(" ");
-    return {
-        branchUpkeepRequired: true,
-        reviewFixMode: "branch_upkeep",
-        wakeReason: "branch_upkeep",
-        promptContext,
-        ...(mergeStateStatus ? { mergeStateStatus } : {}),
-        ...(headSha ? { failingHeadSha: headSha } : {}),
-        baseBranch,
-    };
-}
-function hasCompletedReviewQuillVerdict(entries) {
-    return (entries ?? []).some((entry) => entry.__typename === "CheckRun"
-        && entry.name === "review-quill/verdict"
-        && entry.status === "COMPLETED");
-}
-function getGateCheckNames(project) {
-    const configured = project?.gateChecks?.map((entry) => entry.trim()).filter(Boolean) ?? [];
-    return configured.length > 0 ? configured : ["verify"];
-}
-function isDuplicateRepairAttempt(issue, context) {
-    const signature = typeof context?.failureSignature === "string" ? context.failureSignature : undefined;
-    const headSha = typeof context?.failureHeadSha === "string"
-        ? context.failureHeadSha
-        : typeof context?.headSha === "string" ? context.headSha : undefined;
-    if (!signature)
-        return false;
-    if (issue.lastAttemptedFailureSignature !== signature)
-        return false;
-    if (headSha !== undefined && issue.lastAttemptedFailureHeadSha !== headSha)
-        return false;
-    // A signature+headSha match alone isn't enough: for queue evictions the PR head
-    // doesn't advance (we haven't pushed) and the steward's check name is constant,
-    // so a fresh incident after main advances looks identical. Treat the attempt as
-    // stale if a newer failure has been observed since it was recorded.
-    if (issue.lastAttemptedFailureAt && issue.lastGitHubFailureAt
-        && issue.lastGitHubFailureAt > issue.lastAttemptedFailureAt) {
-        return false;
-    }
-    return true;
-}
-function buildFailureContext(issue) {
-    const storedFailureContext = parseGitHubFailureContext(issue.lastGitHubFailureContextJson);
-    const queueRepairContext = issue.lastQueueIncidentJson
-        ? parseStoredQueueRepairContext(issue.lastQueueIncidentJson)
-        : undefined;
-    if (!queueRepairContext
-        && !issue.lastGitHubFailureSource
-        && !issue.lastGitHubFailureHeadSha
-        && !issue.lastGitHubFailureSignature
-        && !issue.lastGitHubFailureCheckName
-        && !issue.lastGitHubFailureCheckUrl
-        && !storedFailureContext) {
-        return undefined;
-    }
-    return {
-        ...(issue.lastGitHubFailureSource ? { failureReason: issue.lastGitHubFailureSource } : {}),
-        ...(issue.lastGitHubFailureHeadSha ? { failureHeadSha: issue.lastGitHubFailureHeadSha } : {}),
-        ...(issue.lastGitHubFailureSignature ? { failureSignature: issue.lastGitHubFailureSignature } : {}),
-        ...(issue.lastGitHubFailureCheckName ? { checkName: issue.lastGitHubFailureCheckName } : {}),
-        ...(issue.lastGitHubFailureCheckUrl ? { checkUrl: issue.lastGitHubFailureCheckUrl } : {}),
-        ...(storedFailureContext ? storedFailureContext : {}),
-        ...(queueRepairContext ? queueRepairContext : {}),
-    };
-}
-function hasFailureProvenance(issue) {
-    return Boolean(issue.lastGitHubFailureSource
-        || issue.lastGitHubFailureHeadSha
-        || issue.lastGitHubFailureSignature
-        || issue.lastGitHubFailureCheckName
-        || issue.lastGitHubFailureCheckUrl
-        || issue.lastGitHubFailureContextJson
-        || issue.lastGitHubFailureAt
-        || issue.lastQueueIncidentJson
-        || issue.lastAttemptedFailureHeadSha
-        || issue.lastAttemptedFailureSignature);
-}
 export class IdleIssueReconciler {
     db;
     config;

package/dist/webhooks/delegation-truth.js

@@ -0,0 +1,52 @@
+import { appendDelegationObservedEvent } from "../delegation-audit.js";
+export function isDelegatedToPatchRelay(db, project, issue) {
+    const installation = db.linearInstallations.getLinearInstallationForProject(project.id);
+    if (!installation?.actorId)
+        return false;
+    return issue.delegateId === installation.actorId;
+}
+/**
+ * Resolves whether the issue is currently delegated to PatchRelay, applying
+ * the "preserve previous value when the webhook didn't carry a delegate
+ * identity" guard so a stale webhook can't accidentally un-delegate the
+ * issue. Emits a `delegation_observed` audit entry whenever the resolved
+ * value diverges from what we previously stored, so the audit log captures
+ * both raw observation and applied decision.
+ */
+export function resolveDelegationTruth(input) {
+    const previousDelegated = input.existingIssue?.delegatedToPatchRelay;
+    const observedDelegated = isDelegatedToPatchRelay(input.db, input.project, input.hydratedIssue);
+    const explicitDelegateSignal = input.triggerEvent === "delegateChanged";
+    const hasObservedDelegate = input.hydratedIssue.delegateId !== undefined;
+    let delegated = observedDelegated;
+    let reason = hasObservedDelegate
+        ? "delegate_id_present"
+        : `missing_delegate_identity_after_${input.hydration}`;
+    if (!hasObservedDelegate && !explicitDelegateSignal && previousDelegated !== undefined) {
+        delegated = previousDelegated;
+        reason = `preserved_previous_delegation_after_${input.hydration}`;
+    }
+    if (previousDelegated !== delegated
+        || input.hydration === "live_linear_failed"
+        || (!hasObservedDelegate && previousDelegated !== undefined)) {
+        appendDelegationObservedEvent(input.db, {
+            projectId: input.project.id,
+            linearIssueId: input.normalizedIssue.id,
+            payload: {
+                source: "linear_webhook",
+                webhookId: input.webhookId,
+                triggerEvent: input.triggerEvent,
+                ...(input.actorId ? { actorId: input.actorId } : {}),
+                ...(input.hydratedIssue.delegateId ? { observedDelegateId: input.hydratedIssue.delegateId } : {}),
+                ...(previousDelegated !== undefined ? { previousDelegatedToPatchRelay: previousDelegated } : {}),
+                observedDelegatedToPatchRelay: observedDelegated,
+                appliedDelegatedToPatchRelay: delegated,
+                hydration: input.hydration,
+                ...(input.activeRunId !== undefined ? { activeRunId: input.activeRunId } : {}),
+                decision: "none",
+                reason,
+            },
+        });
+    }
+    return { delegated };
+}

package/dist/webhooks/desired-stage-recorder.js

@@ -2,12 +2,11 @@ import { classifyIssue } from "../issue-class.js";
 import { computeOrchestrationSettleUntil, wakeOrchestrationParentsForChildEvent, } from "../orchestration-parent-wake.js";
 import { triggerEventAllowed } from "../project-resolution.js";
 import { resolveAwaitingInputReason } from "../awaiting-input-reason.js";
-import { appendDelegationObservedEvent } from "../delegation-audit.js";
-import { decideActiveRunRelease, decideAgentSession, decideRunIntent, decideUnDelegation, isResolvedLinearState, isTerminalDelegationState, mergeIssueMetadata, resolveReDelegationResume, } from "./decision-helpers.js";
+import { decideActiveRunRelease, decideAgentSession, decideRunIntent, decideUnDelegation, isResolvedLinearState, isTerminalDelegationState, resolveReDelegationResume, } from "./decision-helpers.js";
+import { isDelegatedToPatchRelay, resolveDelegationTruth } from "./delegation-truth.js";
+import { syncIssueDependencies } from "./issue-dependency-sync.js";
+import { resolveLinkedPrAdoption } from "./linked-pr-adoption.js";
 import { buildOperatorRetryEvent } from "../operator-retry-event.js";
-import { resolveLinkedPullRequest } from "../linear-linked-pr-reconciliation.js";
-import { readRemotePrState } from "../remote-pr-state.js";
-import { deriveLinkedPrAdoptionOutcome } from "../delegation-linked-pr.js";
 export class DesiredStageRecorder {
     db;
     linearProvider;
@@ -30,12 +29,13 @@ export class DesiredStageRecorder {
         const triggerAllowed = triggerEventAllowed(params.project, params.normalized.triggerEvent);
         const incomingAgentSessionId = params.normalized.agentSession?.id;
         const hasPendingWake = this.db.issueSessions.peekIssueSessionWake(params.project.id, normalizedIssue.id) !== undefined;
-        if (!existingIssue && !this.isDelegatedToPatchRelay(params.project, normalizedIssue) && !incomingAgentSessionId) {
+        if (!existingIssue && !isDelegatedToPatchRelay(this.db, params.project, normalizedIssue) && !incomingAgentSessionId) {
             return { issue: undefined, wakeRunType: undefined, delegated: false };
         }
-        const syncResult = await this.syncIssueDependencies(params.project.id, normalizedIssue);
+        const syncResult = await syncIssueDependencies(this.db, this.linearProvider, params.project.id, normalizedIssue);
         const hydratedIssue = syncResult.issue;
-        const delegation = this.resolveDelegationTruth({
+        const delegation = resolveDelegationTruth({
+            db: this.db,
             project: params.project,
             normalizedIssue,
             hydratedIssue,
@@ -47,7 +47,7 @@ export class DesiredStageRecorder {
             activeRunId: activeRun?.id,
         });
         const delegated = delegation.delegated;
-        const linkedPrAdoption = await this.resolveLinkedPrAdoption({
+        const linkedPrAdoption = await resolveLinkedPrAdoption({
             project: params.project,
             issue: hydratedIssue,
             existingIssue,
@@ -324,115 +324,4 @@ export class DesiredStageRecorder {
             delegated,
         };
     }
-    isDelegatedToPatchRelay(project, issue) {
-        const installation = this.db.linearInstallations.getLinearInstallationForProject(project.id);
-        if (!installation?.actorId)
-            return false;
-        return issue.delegateId === installation.actorId;
-    }
-    resolveDelegationTruth(params) {
-        const previousDelegated = params.existingIssue?.delegatedToPatchRelay;
-        const observedDelegated = this.isDelegatedToPatchRelay(params.project, params.hydratedIssue);
-        const explicitDelegateSignal = params.triggerEvent === "delegateChanged";
-        const hasObservedDelegate = params.hydratedIssue.delegateId !== undefined;
-        let delegated = observedDelegated;
-        let reason = hasObservedDelegate
-            ? "delegate_id_present"
-            : `missing_delegate_identity_after_${params.hydration}`;
-        if (!hasObservedDelegate && !explicitDelegateSignal && previousDelegated !== undefined) {
-            delegated = previousDelegated;
-            reason = `preserved_previous_delegation_after_${params.hydration}`;
-        }
-        if (previousDelegated !== delegated
-            || params.hydration === "live_linear_failed"
-            || (!hasObservedDelegate && previousDelegated !== undefined)) {
-            appendDelegationObservedEvent(this.db, {
-                projectId: params.project.id,
-                linearIssueId: params.normalizedIssue.id,
-                payload: {
-                    source: "linear_webhook",
-                    webhookId: params.webhookId,
-                    triggerEvent: params.triggerEvent,
-                    ...(params.actorId ? { actorId: params.actorId } : {}),
-                    ...(params.hydratedIssue.delegateId ? { observedDelegateId: params.hydratedIssue.delegateId } : {}),
-                    ...(previousDelegated !== undefined ? { previousDelegatedToPatchRelay: previousDelegated } : {}),
-                    observedDelegatedToPatchRelay: observedDelegated,
-                    appliedDelegatedToPatchRelay: delegated,
-                    hydration: params.hydration,
-                    ...(params.activeRunId !== undefined ? { activeRunId: params.activeRunId } : {}),
-                    decision: "none",
-                    reason,
-                },
-            });
-        }
-        return { delegated };
-    }
-    async syncIssueDependencies(projectId, issue) {
-        let source = issue;
-        let hydration = "webhook_only";
-        if (!source.relationsKnown) {
-            const linear = await this.linearProvider.forProject(projectId);
-            if (linear) {
-                try {
-                    source = mergeIssueMetadata(source, await linear.getIssue(issue.id));
-                    hydration = "live_linear";
-                }
-                catch {
-                    // Preserve existing dependency rows when webhook relation data is incomplete.
-                    hydration = "live_linear_failed";
-                }
-            }
-        }
-        if (source.relationsKnown) {
-            this.db.issues.replaceIssueDependencies({
-                projectId,
-                linearIssueId: source.id,
-                blockers: source.blockedBy.map((blocker) => ({
-                    blockerLinearIssueId: blocker.id,
-                    ...(blocker.identifier ? { blockerIssueKey: blocker.identifier } : {}),
-                    ...(blocker.title ? { blockerTitle: blocker.title } : {}),
-                    ...(blocker.stateName ? { blockerCurrentLinearState: blocker.stateName } : {}),
-                    ...(blocker.stateType ? { blockerCurrentLinearStateType: blocker.stateType } : {}),
-                })),
-            });
-        }
-        this.db.issues.replaceIssueParentLink({
-            projectId,
-            childLinearIssueId: source.id,
-            parentLinearIssueId: source.parentId ?? null,
-        });
-        return { issue: source, hydration };
-    }
-    async resolveLinkedPrAdoption(params) {
-        if (!params.delegated)
-            return undefined;
-        if (params.triggerEvent !== "delegateChanged")
-            return undefined;
-        if (params.existingIssue?.prNumber !== undefined)
-            return undefined;
-        const resolution = resolveLinkedPullRequest(params.issue.attachments, params.project.github?.repoFullName);
-        if (resolution.kind === "none")
-            return undefined;
-        if (resolution.kind === "ambiguous") {
-            return {
-                factoryState: "awaiting_input",
-                pendingRunType: null,
-                pendingRunContext: undefined,
-                issueUpdates: {},
-            };
-        }
-        const remote = await readRemotePrState(resolution.reference.repoFullName, resolution.reference.prNumber);
-        if (!remote) {
-            return {
-                factoryState: "awaiting_input",
-                pendingRunType: null,
-                pendingRunContext: undefined,
-                issueUpdates: {
-                    prNumber: resolution.reference.prNumber,
-                    prUrl: resolution.reference.url,
-                },
-            };
-        }
-        return deriveLinkedPrAdoptionOutcome(params.project, resolution.reference.prNumber, remote);
-    }
 }

package/dist/webhooks/issue-dependency-sync.js

@@ -0,0 +1,45 @@
+import { mergeIssueMetadata } from "./decision-helpers.js";
+/**
+ * Brings the local dependency / parent-link state for `issue` up to date.
+ * If the webhook payload doesn't already include relation data we fetch it
+ * from Linear directly so subsequent decisions don't operate on a
+ * stale-by-omission snapshot. Returns the resolved `IssueMetadata` plus a
+ * label describing where the relation data came from (used by the audit
+ * trail).
+ */
+export async function syncIssueDependencies(db, linearProvider, projectId, issue) {
+    let source = issue;
+    let hydration = "webhook_only";
+    if (!source.relationsKnown) {
+        const linear = await linearProvider.forProject(projectId);
+        if (linear) {
+            try {
+                source = mergeIssueMetadata(source, await linear.getIssue(issue.id));
+                hydration = "live_linear";
+            }
+            catch {
+                // Preserve existing dependency rows when webhook relation data is incomplete.
+                hydration = "live_linear_failed";
+            }
+        }
+    }
+    if (source.relationsKnown) {
+        db.issues.replaceIssueDependencies({
+            projectId,
+            linearIssueId: source.id,
+            blockers: source.blockedBy.map((blocker) => ({
+                blockerLinearIssueId: blocker.id,
+                ...(blocker.identifier ? { blockerIssueKey: blocker.identifier } : {}),
+                ...(blocker.title ? { blockerTitle: blocker.title } : {}),
+                ...(blocker.stateName ? { blockerCurrentLinearState: blocker.stateName } : {}),
+                ...(blocker.stateType ? { blockerCurrentLinearStateType: blocker.stateType } : {}),
+            })),
+        });
+    }
+    db.issues.replaceIssueParentLink({
+        projectId,
+        childLinearIssueId: source.id,
+        parentLinearIssueId: source.parentId ?? null,
+    });
+    return { issue: source, hydration };
+}

package/dist/webhooks/linked-pr-adoption.js

@@ -0,0 +1,41 @@
+import { resolveLinkedPullRequest } from "../linear-linked-pr-reconciliation.js";
+import { readRemotePrState } from "../remote-pr-state.js";
+import { deriveLinkedPrAdoptionOutcome } from "../delegation-linked-pr.js";
+/**
+ * On `delegateChanged` for a newly-delegated issue with no recorded PR yet,
+ * try to adopt any pull request referenced in Linear attachments. Returns
+ * the desired stage / pending-run shape, or `undefined` if no adoption
+ * applies (wrong trigger, not delegated, PR already tracked, no candidate).
+ */
+export async function resolveLinkedPrAdoption(input) {
+    if (!input.delegated)
+        return undefined;
+    if (input.triggerEvent !== "delegateChanged")
+        return undefined;
+    if (input.existingIssue?.prNumber !== undefined)
+        return undefined;
+    const resolution = resolveLinkedPullRequest(input.issue.attachments, input.project.github?.repoFullName);
+    if (resolution.kind === "none")
+        return undefined;
+    if (resolution.kind === "ambiguous") {
+        return {
+            factoryState: "awaiting_input",
+            pendingRunType: null,
+            pendingRunContext: undefined,
+            issueUpdates: {},
+        };
+    }
+    const remote = await readRemotePrState(resolution.reference.repoFullName, resolution.reference.prNumber);
+    if (!remote) {
+        return {
+            factoryState: "awaiting_input",
+            pendingRunType: null,
+            pendingRunContext: undefined,
+            issueUpdates: {
+                prNumber: resolution.reference.prNumber,
+                prUrl: resolution.reference.url,
+            },
+        };
+    }
+    return deriveLinkedPrAdoptionOutcome(input.project, resolution.reference.prNumber, remote);
+}

package/package.json

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