patchrelay 0.40.0 → 0.41.0

package/dist/merged-linear-completion-reconciler.js

@@ -2,24 +2,47 @@ import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
 import { resolvePreferredCompletedLinearState } from "./linear-workflow.js";
 import { isCompletedLinearState } from "./pr-state.js";
 import { hasTrustedNoPrCompletion } from "./trusted-no-pr-completion.js";
+const COMPLETION_RECONCILE_WINDOW_MS = 60 * 60 * 1000;
+const COMPLETION_RECONCILE_SUCCESS_BACKOFF_MS = 60 * 60 * 1000;
+const COMPLETION_RECONCILE_FAILURE_BACKOFF_MS = 5 * 60 * 1000;
+const COMPLETION_RECONCILE_RATE_LIMIT_BACKOFF_MS = 30 * 60 * 1000;
+const COMPLETION_RECONCILE_MAX_ISSUES_PER_PASS = 10;
 export class MergedLinearCompletionReconciler {
     db;
     linearProvider;
     logger;
+    retryAfterByIssueKey = new Map();
+    globalRetryAfter;
     constructor(db, linearProvider, logger) {
         this.db = db;
         this.linearProvider = linearProvider;
         this.logger = logger;
     }
     async reconcile() {
-        for (const issue of this.db.issues.listIssues()) {
-            if (issue.factoryState !== "done" && issue.prState !== "merged") {
+        const now = Date.now();
+        if (this.globalRetryAfter !== undefined) {
+            if (this.globalRetryAfter > now) {
+                return;
+            }
+            this.globalRetryAfter = undefined;
+        }
+        const candidates = this.db.issues.listIssues()
+            .filter((issue) => this.isRecentCompletionCandidate(issue, now))
+            .sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt));
+        this.pruneRetryBackoff(candidates, now);
+        let attemptedIssues = 0;
+        for (const issue of candidates) {
+            if (attemptedIssues >= COMPLETION_RECONCILE_MAX_ISSUES_PER_PASS) {
+                break;
+            }
+            if (!this.shouldAttemptIssue(issue, now)) {
                 continue;
             }
             const linear = await this.linearProvider.forProject(issue.projectId).catch(() => undefined);
             if (!linear) {
                 continue;
             }
+            attemptedIssues += 1;
             try {
                 const liveIssue = await linear.getIssue(issue.linearIssueId);
                 this.db.issues.replaceIssueDependencies({
@@ -37,6 +60,7 @@ export class MergedLinearCompletionReconciler {
                 const trustedNoPrDone = hasTrustedNoPrCompletion(issue, latestRun);
                 if (issue.prState === "merged" || trustedNoPrDone) {
                     await this.reconcileCompletedLinearState(issue, liveIssue, linear);
+                    this.settleIssue(issue, now);
                     continue;
                 }
                 if (issue.factoryState === "done" && !isCompletedLinearState(liveIssue.stateType, liveIssue.stateName)) {
@@ -45,9 +69,15 @@ export class MergedLinearCompletionReconciler {
                 else {
                     this.refreshCachedLinearState(issue, liveIssue);
                 }
+                this.settleIssue(issue, now);
             }
             catch (error) {
+                this.deferIssue(issue, error, now);
                 this.logger.warn({ issueKey: issue.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to reconcile merged or stale completed issue state");
+                if (isRateLimitedError(error)) {
+                    this.globalRetryAfter = now + COMPLETION_RECONCILE_RATE_LIMIT_BACKOFF_MS;
+                    break;
+                }
             }
         }
     }
@@ -92,6 +122,9 @@ export class MergedLinearCompletionReconciler {
         }, "Reopened stale local done state from live Linear workflow");
     }
     refreshCachedLinearState(issue, liveIssue) {
+        if (issue.currentLinearState === liveIssue.stateName && issue.currentLinearStateType === liveIssue.stateType) {
+            return;
+        }
         this.db.issues.upsertIssue({
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
@@ -99,6 +132,55 @@ export class MergedLinearCompletionReconciler {
             ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
         });
     }
+    isRecentCompletionCandidate(issue, now) {
+        if (issue.factoryState !== "done" && issue.prState !== "merged") {
+            return false;
+        }
+        const updatedAt = Date.parse(issue.updatedAt);
+        return Number.isFinite(updatedAt) && now - updatedAt <= COMPLETION_RECONCILE_WINDOW_MS;
+    }
+    shouldAttemptIssue(issue, now) {
+        const retry = this.retryAfterByIssueKey.get(this.issueKey(issue));
+        if (!retry) {
+            return true;
+        }
+        if (retry.updatedAt !== issue.updatedAt) {
+            this.retryAfterByIssueKey.delete(this.issueKey(issue));
+            return true;
+        }
+        return retry.retryAfter <= now;
+    }
+    settleIssue(issue, now) {
+        this.retryAfterByIssueKey.set(this.issueKey(issue), {
+            retryAfter: now + COMPLETION_RECONCILE_SUCCESS_BACKOFF_MS,
+            updatedAt: issue.updatedAt,
+        });
+    }
+    deferIssue(issue, error, now) {
+        const message = error instanceof Error ? error.message : String(error);
+        const backoffMs = /ratelimit|rate limit/i.test(message)
+            ? COMPLETION_RECONCILE_RATE_LIMIT_BACKOFF_MS
+            : COMPLETION_RECONCILE_FAILURE_BACKOFF_MS;
+        this.retryAfterByIssueKey.set(this.issueKey(issue), {
+            retryAfter: now + backoffMs,
+            updatedAt: issue.updatedAt,
+        });
+    }
+    pruneRetryBackoff(candidates, now) {
+        const candidateKeys = new Set(candidates.map((issue) => this.issueKey(issue)));
+        for (const [key, retry] of this.retryAfterByIssueKey.entries()) {
+            if (!candidateKeys.has(key) || retry.retryAfter <= now) {
+                this.retryAfterByIssueKey.delete(key);
+            }
+        }
+    }
+    issueKey(issue) {
+        return `${issue.projectId}::${issue.linearIssueId}`;
+    }
+}
+function isRateLimitedError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /ratelimit|rate limit/i.test(message);
 }
 function resolveOpenWorkflowState(issue) {
     const reactiveIntent = deriveIssueSessionReactiveIntent({

package/dist/remote-pr-state.js

@@ -3,7 +3,7 @@ export async function readRemotePrState(repoFullName, prNumber) {
     const { stdout, exitCode } = await execCommand("gh", [
         "pr", "view", String(prNumber),
         "--repo", repoFullName,
-        "--json", "headRefOid,state,reviewDecision,mergeStateStatus",
+        "--json", "url,headRefName,headRefOid,isDraft,isCrossRepository,state,author,reviewDecision,mergeable,mergeStateStatus,statusCheckRollup",
     ], { timeoutMs: 10_000 });
     if (exitCode !== 0)
         return undefined;

package/dist/run-reconciler.js

@@ -1,3 +1,4 @@
+import { appendDelegationObservedEvent, appendRunReleasedAuthorityEvent } from "./delegation-audit.js";
 import { TERMINAL_STATES } from "./factory-state.js";
 import { resolveAuthoritativeLinearStopState } from "./linear-workflow.js";
 import { buildRunFailureActivity } from "./linear-session-reporting.js";
@@ -31,39 +32,40 @@ export class RunReconciler {
     async reconcile(params) {
         const { run, issue, recoveryLease } = params;
         const acquiredRecoveryLease = recoveryLease === true;
-        if (!issue.delegatedToPatchRelay) {
-            this.withHeldLease(run.projectId, run.linearIssueId, () => {
-                this.db.runs.finishRun(run.id, { status: "released", failureReason: "Issue was un-delegated during active run" });
-                this.db.issues.upsertIssue({ projectId: run.projectId, linearIssueId: run.linearIssueId, activeRunId: null, factoryState: issue.factoryState });
-            });
-            const pausedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
-            void this.linearSync.syncSession(pausedIssue, { activeRunType: run.runType });
-            this.releaseLease(run.projectId, run.linearIssueId);
-            return;
+        let effectiveIssue = issue;
+        if (!effectiveIssue.delegatedToPatchRelay) {
+            const authority = await this.confirmDelegationAuthorityBeforeRelease(run, effectiveIssue);
+            effectiveIssue = authority.issue;
+            if (authority.released) {
+                const pausedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? effectiveIssue;
+                void this.linearSync.syncSession(pausedIssue, { activeRunType: run.runType });
+                this.releaseLease(run.projectId, run.linearIssueId);
+                return;
+            }
         }
-        if (TERMINAL_STATES.has(issue.factoryState)) {
+        if (TERMINAL_STATES.has(effectiveIssue.factoryState)) {
             this.withHeldLease(run.projectId, run.linearIssueId, () => {
                 this.db.runs.finishRun(run.id, { status: "released", failureReason: "Issue reached terminal state during active run" });
                 this.db.issues.upsertIssue({ projectId: run.projectId, linearIssueId: run.linearIssueId, activeRunId: null });
             });
-            this.logger.info({ issueKey: issue.issueKey, runId: run.id, factoryState: issue.factoryState }, "Reconciliation: released run on terminal issue");
-            const releasedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
+            this.logger.info({ issueKey: effectiveIssue.issueKey, runId: run.id, factoryState: effectiveIssue.factoryState }, "Reconciliation: released run on terminal issue");
+            const releasedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? effectiveIssue;
             void this.linearSync.syncSession(releasedIssue, { activeRunType: run.runType });
             this.releaseLease(run.projectId, run.linearIssueId);
             return;
         }
         if (!run.threadId) {
             if (recoveryLease === "owned") {
-                this.logger.debug({ issueKey: issue.issueKey, runId: run.id, runType: run.runType }, "Skipping zombie reconciliation for locally-owned launch that has not created a thread yet");
+                this.logger.debug({ issueKey: effectiveIssue.issueKey, runId: run.id, runType: run.runType }, "Skipping zombie reconciliation for locally-owned launch that has not created a thread yet");
                 return;
             }
-            this.logger.warn({ issueKey: issue.issueKey, runId: run.id, runType: run.runType }, "Zombie run detected (no thread)");
+            this.logger.warn({ issueKey: effectiveIssue.issueKey, runId: run.id, runType: run.runType }, "Zombie run detected (no thread)");
             this.withHeldLease(run.projectId, run.linearIssueId, () => {
                 this.db.runs.finishRun(run.id, { status: "failed", failureReason: "Zombie: never started (no thread after restart)" });
                 this.db.issues.upsertIssue({ projectId: run.projectId, linearIssueId: run.linearIssueId, activeRunId: null });
             });
-            this.recoverOrEscalate(issue, run.runType, "zombie");
-            const recoveredIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
+            this.recoverOrEscalate(effectiveIssue, run.runType, "zombie");
+            const recoveredIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? effectiveIssue;
             void this.linearSync.emitActivity(recoveredIssue, buildRunFailureActivity(run.runType, "The Codex turn never started before PatchRelay restarted."));
             void this.linearSync.syncSession(recoveredIssue, { activeRunType: run.runType });
             this.releaseLease(run.projectId, run.linearIssueId);
@@ -74,13 +76,13 @@ export class RunReconciler {
             thread = await this.readThreadWithRetry(run.threadId);
         }
         catch {
-            this.logger.warn({ issueKey: issue.issueKey, runId: run.id, runType: run.runType, threadId: run.threadId }, "Stale thread during reconciliation");
+            this.logger.warn({ issueKey: effectiveIssue.issueKey, runId: run.id, runType: run.runType, threadId: run.threadId }, "Stale thread during reconciliation");
             this.withHeldLease(run.projectId, run.linearIssueId, () => {
                 this.db.runs.finishRun(run.id, { status: "failed", failureReason: "Stale thread after restart" });
                 this.db.issues.upsertIssue({ projectId: run.projectId, linearIssueId: run.linearIssueId, activeRunId: null });
             });
-            this.recoverOrEscalate(issue, run.runType, "stale_thread");
-            const recoveredIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
+            this.recoverOrEscalate(effectiveIssue, run.runType, "stale_thread");
+            const recoveredIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? effectiveIssue;
             void this.linearSync.emitActivity(recoveredIssue, buildRunFailureActivity(run.runType, "PatchRelay lost the active Codex thread after restart and needs to recover."));
             void this.linearSync.syncSession(recoveredIssue, { activeRunType: run.runType });
             this.releaseLease(run.projectId, run.linearIssueId);
@@ -111,7 +113,7 @@ export class RunReconciler {
                         status: "reconciled",
                         summary: `Linear state ${stopState.stateName} -> done`,
                     });
-                    const doneIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
+                    const doneIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? effectiveIssue;
                     void this.linearSync.syncSession(doneIssue, { activeRunType: run.runType });
                     this.releaseLease(run.projectId, run.linearIssueId);
                     return;
@@ -120,14 +122,14 @@ export class RunReconciler {
         }
         const latestTurn = getThreadTurns(thread).at(-1);
         if (latestTurn?.status === "interrupted") {
-            await this.interruptedRunRecovery.handle(run, issue);
+            await this.interruptedRunRecovery.handle(run, effectiveIssue);
             return;
         }
         if (latestTurn?.status === "completed") {
             await this.runFinalizer.finalizeCompletedRun({
                 source: "reconciliation",
                 run,
-                issue,
+                issue: effectiveIssue,
                 thread,
                 threadId: run.threadId,
                 ...(latestTurn.id ? { completedTurnId: latestTurn.id } : {}),
@@ -139,4 +141,111 @@ export class RunReconciler {
             this.releaseLease(run.projectId, run.linearIssueId);
         }
     }
+    async confirmDelegationAuthorityBeforeRelease(run, issue) {
+        const installation = this.db.linearInstallations.getLinearInstallationForProject(run.projectId);
+        const linear = await this.linearProvider.forProject(run.projectId).catch(() => undefined);
+        if (!installation?.actorId || !linear) {
+            appendDelegationObservedEvent(this.db, {
+                projectId: run.projectId,
+                linearIssueId: run.linearIssueId,
+                payload: {
+                    source: "run_reconciler",
+                    ...(installation?.actorId ? { actorId: installation.actorId } : {}),
+                    previousDelegatedToPatchRelay: issue.delegatedToPatchRelay,
+                    observedDelegatedToPatchRelay: issue.delegatedToPatchRelay,
+                    appliedDelegatedToPatchRelay: issue.delegatedToPatchRelay,
+                    hydration: "live_linear_failed",
+                    activeRunId: run.id,
+                    decision: "none",
+                    reason: "live_linear_unavailable_before_undelegation_release",
+                },
+            });
+            return { issue, released: false };
+        }
+        const linearIssue = await linear.getIssue(run.linearIssueId).catch(() => undefined);
+        if (!linearIssue) {
+            appendDelegationObservedEvent(this.db, {
+                projectId: run.projectId,
+                linearIssueId: run.linearIssueId,
+                payload: {
+                    source: "run_reconciler",
+                    actorId: installation.actorId,
+                    previousDelegatedToPatchRelay: issue.delegatedToPatchRelay,
+                    observedDelegatedToPatchRelay: issue.delegatedToPatchRelay,
+                    appliedDelegatedToPatchRelay: issue.delegatedToPatchRelay,
+                    hydration: "live_linear_failed",
+                    activeRunId: run.id,
+                    decision: "none",
+                    reason: "live_linear_refresh_failed_before_undelegation_release",
+                },
+            });
+            return { issue, released: false };
+        }
+        const delegated = linearIssue.delegateId === installation.actorId;
+        appendDelegationObservedEvent(this.db, {
+            projectId: run.projectId,
+            linearIssueId: run.linearIssueId,
+            payload: {
+                source: "run_reconciler",
+                actorId: installation.actorId,
+                ...(linearIssue.delegateId ? { observedDelegateId: linearIssue.delegateId } : {}),
+                previousDelegatedToPatchRelay: issue.delegatedToPatchRelay,
+                observedDelegatedToPatchRelay: delegated,
+                appliedDelegatedToPatchRelay: delegated,
+                hydration: "live_linear",
+                activeRunId: run.id,
+                decision: delegated ? "resume_issue" : "release_run",
+                reason: delegated
+                    ? "live_linear_confirmed_issue_is_still_delegated"
+                    : "live_linear_confirmed_issue_is_no_longer_delegated",
+            },
+        });
+        if (delegated) {
+            const repairedIssue = this.withHeldLease(run.projectId, run.linearIssueId, () => this.db.issues.upsertIssue({
+                projectId: run.projectId,
+                linearIssueId: run.linearIssueId,
+                delegatedToPatchRelay: true,
+                ...(linearIssue.identifier ? { issueKey: linearIssue.identifier } : {}),
+                ...(linearIssue.title ? { title: linearIssue.title } : {}),
+                ...(linearIssue.description ? { description: linearIssue.description } : {}),
+                ...(linearIssue.url ? { url: linearIssue.url } : {}),
+                ...(linearIssue.priority != null ? { priority: linearIssue.priority } : {}),
+                ...(linearIssue.estimate != null ? { estimate: linearIssue.estimate } : {}),
+                ...(linearIssue.stateName ? { currentLinearState: linearIssue.stateName } : {}),
+                ...(linearIssue.stateType ? { currentLinearStateType: linearIssue.stateType } : {}),
+            })) ?? issue;
+            return { issue: repairedIssue, released: false };
+        }
+        appendRunReleasedAuthorityEvent(this.db, {
+            projectId: run.projectId,
+            linearIssueId: run.linearIssueId,
+            payload: {
+                runId: run.id,
+                runType: run.runType,
+                localDelegatedToPatchRelay: issue.delegatedToPatchRelay,
+                liveDelegatedToPatchRelay: delegated,
+                source: "run_reconciler",
+                reason: "Issue was un-delegated during active run",
+            },
+        });
+        this.withHeldLease(run.projectId, run.linearIssueId, () => {
+            this.db.runs.finishRun(run.id, { status: "released", failureReason: "Issue was un-delegated during active run" });
+            this.db.issues.upsertIssue({
+                projectId: run.projectId,
+                linearIssueId: run.linearIssueId,
+                activeRunId: null,
+                factoryState: issue.factoryState,
+                delegatedToPatchRelay: false,
+                ...(linearIssue.identifier ? { issueKey: linearIssue.identifier } : {}),
+                ...(linearIssue.title ? { title: linearIssue.title } : {}),
+                ...(linearIssue.description ? { description: linearIssue.description } : {}),
+                ...(linearIssue.url ? { url: linearIssue.url } : {}),
+                ...(linearIssue.priority != null ? { priority: linearIssue.priority } : {}),
+                ...(linearIssue.estimate != null ? { estimate: linearIssue.estimate } : {}),
+                ...(linearIssue.stateName ? { currentLinearState: linearIssue.stateName } : {}),
+                ...(linearIssue.stateType ? { currentLinearStateType: linearIssue.stateType } : {}),
+            });
+        });
+        return { issue, released: true };
+    }
 }

package/dist/service-runtime.js

@@ -30,13 +30,12 @@ export class ServiceRuntime {
     async start() {
         try {
             await this.codex.start();
-            await this.runReconciler.reconcileActiveRuns();
             for (const issue of this.readyIssueSource.listIssuesReadyForExecution()) {
                 this.enqueueIssue(issue.projectId, issue.linearIssueId);
             }
             this.ready = true;
             this.startupError = undefined;
-            this.scheduleBackgroundReconcile();
+            void this.runBackgroundReconcile();
         }
         catch (error) {
             this.ready = false;

package/dist/service-startup-recovery.js

@@ -1,3 +1,4 @@
+import { appendDelegationObservedEvent } from "./delegation-audit.js";
 import { isResumablePausedLocalWork } from "./paused-issue-state.js";
 export class ServiceStartupRecovery {
     db;
@@ -65,6 +66,24 @@ export class ServiceStartupRecovery {
                 })),
             });
             const delegated = liveIssue.delegateId === installation.actorId;
+            if (issue.delegatedToPatchRelay !== delegated) {
+                appendDelegationObservedEvent(this.db, {
+                    projectId: issue.projectId,
+                    linearIssueId: issue.linearIssueId,
+                    payload: {
+                        source: "startup_recovery",
+                        actorId: installation.actorId,
+                        ...(liveIssue.delegateId ? { observedDelegateId: liveIssue.delegateId } : {}),
+                        previousDelegatedToPatchRelay: issue.delegatedToPatchRelay,
+                        observedDelegatedToPatchRelay: delegated,
+                        appliedDelegatedToPatchRelay: delegated,
+                        hydration: "live_linear",
+                        ...(issue.activeRunId !== undefined ? { activeRunId: issue.activeRunId } : {}),
+                        decision: delegated ? "resume_issue" : "none",
+                        reason: "startup_recovery_refreshed_linear_delegation",
+                    },
+                });
+            }
             const unresolvedBlockers = this.db.issues.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
             const latestRun = this.db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
             const shouldRecoverPausedLocalWork = delegated

package/dist/service.js

@@ -106,7 +106,10 @@ export class PatchRelayService {
             }
         }
         await this.runtime.start();
-        await this.startupRecovery.recoverDelegatedIssueStateFromLinear();
+        void this.startupRecovery.recoverDelegatedIssueStateFromLinear().catch((error) => {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger.warn({ error: msg }, "Background delegated issue recovery failed");
+        });
         void this.startupRecovery.syncKnownAgentSessions().catch((error) => {
             const msg = error instanceof Error ? error.message : String(error);
             this.logger.warn({ error: msg }, "Background agent session sync failed");

package/dist/waiting-reason.js

@@ -10,7 +10,7 @@ export const PATCHRELAY_WAITING_REASONS = {
     waitingForReviewOnNewHead: "Waiting on review of a newer pushed head",
     sameHeadStillBlocked: "Requested changes still block the current head",
     waitingForMergeStewardRepair: "Waiting to repair a merge-steward incident",
-    waitingForDownstreamAutomation: "Waiting on downstream review/merge automation",
+    waitingForDownstreamAutomation: "PatchRelay work is done; waiting on downstream review/merge automation",
     workComplete: "PatchRelay work is complete",
     waitingForOperatorIntervention: "Waiting on operator intervention",
     waitingForExternalReview: "Waiting on external review",

package/dist/webhooks/decision-helpers.js

@@ -38,10 +38,17 @@ export function resolveReDelegationResume(p) {
     if (p.prState === "merged") {
         return { factoryState: "done", pendingRunType: null };
     }
+    if (p.prNumber !== undefined && (p.prState === undefined || p.prState === "open") && p.prIsDraft) {
+        return {
+            factoryState: "delegated",
+            pendingRunType: (p.unresolvedBlockers ?? 0) === 0 ? "implementation" : null,
+        };
+    }
     const reactiveIntent = deriveIssueSessionReactiveIntent({
         delegatedToPatchRelay: true,
         prNumber: p.prNumber,
         prState: p.prState,
+        prIsDraft: p.prIsDraft,
         prReviewState: p.prReviewState,
         prCheckStatus: p.prCheckStatus,
         latestFailureSource: p.latestFailureSource,
@@ -100,6 +107,7 @@ export function mergeIssueMetadata(issue, liveIssue) {
         ...(issue.identifier ? {} : liveIssue.identifier ? { identifier: liveIssue.identifier } : {}),
         ...(issue.title ? {} : liveIssue.title ? { title: liveIssue.title } : {}),
         ...(issue.url ? {} : liveIssue.url ? { url: liveIssue.url } : {}),
+        ...(issue.attachments && issue.attachments.length > 0 ? {} : liveIssue.attachments ? { attachments: liveIssue.attachments } : {}),
         ...(issue.teamId ? {} : liveIssue.teamId ? { teamId: liveIssue.teamId } : {}),
         ...(issue.teamKey ? {} : liveIssue.teamKey ? { teamKey: liveIssue.teamKey } : {}),
         ...(issue.stateId ? {} : liveIssue.stateId ? { stateId: liveIssue.stateId } : {}),