patchrelay 0.68.0 → 0.68.2

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/dependency-readiness-handler.js

@@ -1,8 +1,10 @@
 export class DependencyReadinessHandler {
     db;
+    wakeDispatcher;
     peekPendingSessionWakeRunType;
-    constructor(db, peekPendingSessionWakeRunType) {
+    constructor(db, wakeDispatcher, peekPendingSessionWakeRunType) {
         this.db = db;
+        this.wakeDispatcher = wakeDispatcher;
         this.peekPendingSessionWakeRunType = peekPendingSessionWakeRunType;
     }
     reconcile(projectId, blockerLinearIssueId) {
@@ -40,9 +42,7 @@ export class DependencyReadinessHandler {
                     pendingRunContextJson: null,
                 });
             }
-            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(projectId, dependent.linearIssueId, {
-                projectId,
-                linearIssueId: dependent.linearIssueId,
+            this.wakeDispatcher.recordEventAndDispatch(projectId, dependent.linearIssueId, {
                 eventType: "delegated",
                 dedupeKey: `delegated:${dependent.linearIssueId}`,
             });

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

@@ -2,19 +2,20 @@ 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;
+    wakeDispatcher;
     feed;
-    constructor(db, linearProvider, feed) {
+    constructor(db, linearProvider, wakeDispatcher, feed) {
         this.db = db;
         this.linearProvider = linearProvider;
+        this.wakeDispatcher = wakeDispatcher;
         this.feed = feed;
     }
     async record(params) {
@@ -28,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,
@@ -45,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,
@@ -288,6 +290,7 @@ export class DesiredStageRecorder {
                 },
                 eventType: "child_changed",
                 changeKind: "detached",
+                wakeDispatcher: this.wakeDispatcher,
             });
         }
         if (currentParentIssueId) {
@@ -311,6 +314,7 @@ export class DesiredStageRecorder {
                     child: issue,
                     eventType,
                     changeKind,
+                    wakeDispatcher: this.wakeDispatcher,
                 });
             }
         }
@@ -320,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.0",
+  "version": "0.68.2",
   "license": "MIT",
   "type": "module",
   "repository": {