patchrelay 0.40.0 → 0.41.0

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

@@ -1,7 +1,11 @@
 import { triggerEventAllowed } from "../project-resolution.js";
 import { resolveAwaitingInputReason } from "../awaiting-input-reason.js";
+import { appendDelegationObservedEvent } from "../delegation-audit.js";
 import { decideActiveRunRelease, decideAgentSession, decideRunIntent, decideUnDelegation, isTerminalDelegationState, mergeIssueMetadata, resolveReDelegationResume, } from "./decision-helpers.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;
@@ -25,8 +29,27 @@ export class DesiredStageRecorder {
         if (!existingIssue && !this.isDelegatedToPatchRelay(params.project, normalizedIssue) && !incomingAgentSessionId) {
             return { issue: undefined, wakeRunType: undefined, delegated: false };
         }
-        const hydratedIssue = await this.syncIssueDependencies(params.project.id, normalizedIssue);
-        const delegated = this.isDelegatedToPatchRelay(params.project, hydratedIssue);
+        const syncResult = await this.syncIssueDependencies(params.project.id, normalizedIssue);
+        const hydratedIssue = syncResult.issue;
+        const delegation = this.resolveDelegationTruth({
+            project: params.project,
+            normalizedIssue,
+            hydratedIssue,
+            existingIssue,
+            triggerEvent: params.normalized.triggerEvent,
+            webhookId: params.normalized.webhookId,
+            actorId: params.normalized.actor?.id,
+            hydration: syncResult.hydration,
+            activeRunId: activeRun?.id,
+        });
+        const delegated = delegation.delegated;
+        const linkedPrAdoption = await this.resolveLinkedPrAdoption({
+            project: params.project,
+            issue: hydratedIssue,
+            existingIssue,
+            delegated,
+            triggerEvent: params.normalized.triggerEvent,
+        });
         const unresolvedBlockers = this.db.issues.countUnresolvedBlockers(params.project.id, normalizedIssue.id);
         const terminal = isTerminalDelegationState(existingIssue, hydratedIssue);
         const openPrExists = existingIssue?.prNumber !== undefined
@@ -35,16 +58,18 @@ export class DesiredStageRecorder {
         const blockerPausedImplementation = unresolvedBlockers > 0
             && activeRun?.runType === "implementation"
             && !openPrExists;
-        const desiredStage = decideRunIntent({
-            delegated,
-            triggerAllowed,
-            triggerEvent: params.normalized.triggerEvent,
-            unresolvedBlockers,
-            hasActiveRun: Boolean(activeRun),
-            hasPendingWake,
-            terminal,
-            currentState: existingIssue?.factoryState,
-        });
+        const desiredStage = linkedPrAdoption
+            ? undefined
+            : decideRunIntent({
+                delegated,
+                triggerAllowed,
+                triggerEvent: params.normalized.triggerEvent,
+                unresolvedBlockers,
+                hasActiveRun: Boolean(activeRun),
+                hasPendingWake,
+                terminal,
+                currentState: existingIssue?.factoryState,
+            });
         const runRelease = decideActiveRunRelease({
             hasActiveRun: Boolean(activeRun),
             terminal,
@@ -60,20 +85,31 @@ export class DesiredStageRecorder {
             currentState: existingIssue?.factoryState,
             hasPr: existingIssue?.prNumber !== undefined && existingIssue?.prState !== "merged",
         });
-        const reDelegationResume = resolveReDelegationResume({
-            delegated,
-            previouslyDelegated: existingIssue?.delegatedToPatchRelay,
-            currentState: existingIssue?.factoryState,
-            awaitingInputReason: existingIssue
-                ? resolveAwaitingInputReason({ issue: existingIssue, latestRun })
-                : undefined,
-            unresolvedBlockers,
-            prNumber: existingIssue?.prNumber,
-            prState: existingIssue?.prState,
-            prReviewState: existingIssue?.prReviewState,
-            prCheckStatus: existingIssue?.prCheckStatus,
-            latestFailureSource: existingIssue?.lastGitHubFailureSource,
-        });
+        const startupResume = linkedPrAdoption
+            ? {
+                factoryState: linkedPrAdoption.factoryState,
+                pendingRunType: linkedPrAdoption.pendingRunType,
+                pendingRunContext: linkedPrAdoption.pendingRunContext,
+                source: "linked_pr_adoption",
+            }
+            : {
+                ...resolveReDelegationResume({
+                    delegated,
+                    previouslyDelegated: existingIssue?.delegatedToPatchRelay,
+                    currentState: existingIssue?.factoryState,
+                    awaitingInputReason: existingIssue
+                        ? resolveAwaitingInputReason({ issue: existingIssue, latestRun })
+                        : undefined,
+                    unresolvedBlockers,
+                    prNumber: existingIssue?.prNumber,
+                    prState: existingIssue?.prState,
+                    prIsDraft: existingIssue?.prIsDraft,
+                    prReviewState: existingIssue?.prReviewState,
+                    prCheckStatus: existingIssue?.prCheckStatus,
+                    latestFailureSource: existingIssue?.lastGitHubFailureSource,
+                }),
+                source: "re_delegated",
+            };
         const existingWakeRunType = existingIssue
             ? params.peekPendingSessionWakeRunType(params.project.id, normalizedIssue.id)
             : undefined;
@@ -96,13 +132,19 @@ export class DesiredStageRecorder {
                 ...(hydratedIssue.estimate != null ? { estimate: hydratedIssue.estimate } : {}),
                 ...(hydratedIssue.stateName ? { currentLinearState: hydratedIssue.stateName } : {}),
                 ...(hydratedIssue.stateType ? { currentLinearStateType: hydratedIssue.stateType } : {}),
+                ...(linkedPrAdoption?.issueUpdates ?? {}),
                 delegatedToPatchRelay: delegated,
                 ...(!existingIssue && !delegated && incomingAgentSessionId ? { factoryState: "awaiting_input" } : {}),
-                ...(reDelegationResume.factoryState ? { factoryState: reDelegationResume.factoryState } : {}),
-                ...(reDelegationResume.pendingRunType !== undefined
-                    ? { pendingRunType: null, pendingRunContextJson: null }
+                ...(startupResume.factoryState ? { factoryState: startupResume.factoryState } : {}),
+                ...(startupResume.pendingRunType !== undefined
+                    ? {
+                        pendingRunType: null,
+                        pendingRunContextJson: startupResume.pendingRunContext
+                            ? JSON.stringify(startupResume.pendingRunContext)
+                            : null,
+                    }
                     : {}),
-                ...(!reDelegationResume.factoryState && desiredStage ? { pendingRunType: null, pendingRunContextJson: null, factoryState: "delegated" } : {}),
+                ...(!startupResume.factoryState && desiredStage ? { pendingRunType: null, pendingRunContextJson: null, factoryState: "delegated" } : {}),
                 ...(clearPending ? { pendingRunType: null, pendingRunContextJson: null } : {}),
                 ...(agentSessionId !== undefined ? { agentSessionId } : {}),
                 ...(effectiveRunRelease.release ? { activeRunId: null } : {}),
@@ -162,15 +204,15 @@ export class DesiredStageRecorder {
                 summary: `Implementation paused because ${issue.issueKey ?? normalizedIssue.id} is now blocked`,
             });
         }
-        else if (reDelegationResume.pendingRunType) {
+        else if (startupResume.pendingRunType) {
             this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(params.project.id, normalizedIssue.id, {
                 projectId: params.project.id,
                 linearIssueId: normalizedIssue.id,
-                ...buildOperatorRetryEvent(issue, reDelegationResume.pendingRunType, "re_delegated"),
+                ...buildOperatorRetryEvent(issue, startupResume.pendingRunType, startupResume.source),
             });
         }
-        else if (!reDelegationResume.factoryState
-            && !reDelegationResume.pendingRunType
+        else if (!startupResume.factoryState
+            && !startupResume.pendingRunType
             &&
                 desiredStage === "implementation"
             && params.normalized.triggerEvent !== "commentCreated"
@@ -200,16 +242,56 @@ export class DesiredStageRecorder {
             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";
                 }
             }
         }
@@ -226,6 +308,38 @@ export class DesiredStageRecorder {
                 })),
             });
         }
-        return source;
+        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/package.json

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