patchrelay 0.69.3 → 0.69.5

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.69.3",
-  "commit": "be06a08a368b",
-  "builtAt": "2026-05-22T21:56:51.986Z"
+  "version": "0.69.5",
+  "commit": "ab14b628b055",
+  "builtAt": "2026-05-22T23:00:59.300Z"
 }

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

@@ -6,14 +6,12 @@ export class IssueSessionStore {
     mapIssueSessionEventRow;
     issues;
     runs;
-    deriveImplicitReactiveWake;
-    constructor(connection, mapIssueSessionRow, mapIssueSessionEventRow, issues, runs, deriveImplicitReactiveWake) {
+    constructor(connection, mapIssueSessionRow, mapIssueSessionEventRow, issues, runs) {
         this.connection = connection;
         this.mapIssueSessionRow = mapIssueSessionRow;
         this.mapIssueSessionEventRow = mapIssueSessionEventRow;
         this.issues = issues;
         this.runs = runs;
-        this.deriveImplicitReactiveWake = deriveImplicitReactiveWake;
     }
     getIssueSession(projectId, linearIssueId) {
         const row = this.connection
@@ -108,16 +106,7 @@ export class IssueSessionStore {
                 resumeThread: plan.resumeThread,
             };
         }
-        const implicitWake = this.deriveImplicitReactiveWake(issue);
-        if (!implicitWake)
-            return undefined;
-        return {
-            eventIds: [],
-            runType: implicitWake.runType,
-            context: implicitWake.context,
-            wakeReason: implicitWake.wakeReason,
-            resumeThread: false,
-        };
+        return undefined;
     }
     acquireIssueSessionLease(params) {
         const now = params.now ?? isoNow();

package/dist/db.js

@@ -1,4 +1,3 @@
-import { deriveIssueSessionReactiveIntent, } from "./issue-session.js";
 import {} from "./issue-session-events.js";
 import { IssueStore } from "./db/issue-store.js";
 import { IssueSessionStore } from "./db/issue-session-store.js";
@@ -11,84 +10,7 @@ import { runPatchRelayMigrations } from "./db/migrations.js";
 import { SqliteConnection } from "./db/shared.js";
 import { syncIssueSessionFromIssue } from "./issue-session-projector.js";
 import { TrackedIssueQuery } from "./tracked-issue-query.js";
-function parseObjectJson(raw) {
-    if (!raw)
-        return undefined;
-    try {
-        const parsed = JSON.parse(raw);
-        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
-            ? parsed
-            : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function hasUnattemptedFailureSignature(issue, fallbackHeadSha) {
-    const signature = issue.lastGitHubFailureSignature;
-    if (!signature)
-        return false;
-    const headSha = issue.lastGitHubFailureHeadSha ?? fallbackHeadSha;
-    return issue.lastAttemptedFailureSignature !== signature
-        || (headSha !== undefined && issue.lastAttemptedFailureHeadSha !== headSha);
-}
-function deriveImplicitReactiveWake(issue) {
-    const reactiveIntent = deriveIssueSessionReactiveIntent({
-        delegatedToPatchRelay: issue.delegatedToPatchRelay,
-        activeRunId: issue.activeRunId,
-        prNumber: issue.prNumber,
-        prState: issue.prState,
-        prReviewState: issue.prReviewState,
-        prCheckStatus: issue.prCheckStatus,
-        latestFailureSource: issue.lastGitHubFailureSource,
-    });
-    if (!reactiveIntent)
-        return undefined;
-    if (reactiveIntent.runType === "ci_repair") {
-        const failureContext = parseObjectJson(issue.lastGitHubFailureContextJson) ?? {};
-        const snapshot = parseObjectJson(issue.lastGitHubCiSnapshotJson);
-        const fallbackHeadSha = typeof failureContext.failureHeadSha === "string"
-            ? failureContext.failureHeadSha
-            : issue.lastGitHubFailureHeadSha ?? issue.prHeadSha;
-        const failureSignature = issue.lastGitHubFailureSignature
-            ?? (fallbackHeadSha ? `implicit_branch_ci::${fallbackHeadSha}` : undefined);
-        if (!failureSignature || issue.prState !== "open")
-            return undefined;
-        if (issue.lastAttemptedFailureSignature === failureSignature
-            && (fallbackHeadSha === undefined || issue.lastAttemptedFailureHeadSha === fallbackHeadSha)) {
-            return undefined;
-        }
-        return {
-            runType: reactiveIntent.runType,
-            wakeReason: reactiveIntent.wakeReason,
-            context: {
-                ...failureContext,
-                failureSignature,
-                ...(fallbackHeadSha ? { failureHeadSha: fallbackHeadSha } : {}),
-                ...(issue.lastGitHubFailureCheckName ? { checkName: issue.lastGitHubFailureCheckName } : {}),
-                ...(snapshot ? { ciSnapshot: snapshot } : {}),
-            },
-        };
-    }
-    if (reactiveIntent.runType === "queue_repair") {
-        const failureContext = parseObjectJson(issue.lastGitHubFailureContextJson) ?? {};
-        const incidentContext = parseObjectJson(issue.lastQueueIncidentJson) ?? {};
-        const fallbackHeadSha = typeof failureContext.failureHeadSha === "string"
-            ? failureContext.failureHeadSha
-            : undefined;
-        if (!hasUnattemptedFailureSignature(issue, fallbackHeadSha))
-            return undefined;
-        return {
-            runType: reactiveIntent.runType,
-            wakeReason: reactiveIntent.wakeReason,
-            context: {
-                ...incidentContext,
-                ...failureContext,
-            },
-        };
-    }
-    return undefined;
-}
+import { WorkflowWakeResolver } from "./workflow-wake-resolver.js";
 export class PatchRelayDatabase {
     connection;
     linearInstallations;
@@ -97,6 +19,7 @@ export class PatchRelayDatabase {
     webhookEvents;
     issues;
     issueSessions;
+    workflowWakes;
     runs;
     trackedIssues;
     constructor(databasePath, wal) {
@@ -118,8 +41,9 @@ export class PatchRelayDatabase {
             issue,
             ...(options ? { options } : {}),
         }));
-        this.issueSessions = new IssueSessionStore(this.connection, mapIssueSessionRow, mapIssueSessionEventRow, this.issues, this.runs, deriveImplicitReactiveWake);
-        this.trackedIssues = new TrackedIssueQuery(this.issues, this.issueSessions, this.runs);
+        this.issueSessions = new IssueSessionStore(this.connection, mapIssueSessionRow, mapIssueSessionEventRow, this.issues, this.runs);
+        this.workflowWakes = new WorkflowWakeResolver(this.issues, this.issueSessions);
+        this.trackedIssues = new TrackedIssueQuery(this.issues, this.issueSessions, this.workflowWakes, this.runs);
     }
     runMigrations() {
         runPatchRelayMigrations(this.connection);

package/dist/idle-reconciliation.js

@@ -513,7 +513,7 @@ export class IdleIssueReconciler {
             }
             if (issue.delegatedToPatchRelay
                 && reactiveIntent?.runType === "review_fix"
-                && this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId) === undefined) {
+                && this.db.workflowWakes.peekIssueWake(issue.projectId, issue.linearIssueId) === undefined) {
                 this.logger.info({
                     issueKey: issue.issueKey,
                     prNumber: issue.prNumber,

package/dist/interrupted-run-recovery.js

@@ -147,7 +147,7 @@ export class InterruptedRunRecovery {
             eventType: "delegated",
             dedupeKey: `interrupted_implementation:implementation:${run.linearIssueId}`,
         });
-        if (!this.db.issueSessions.peekIssueSessionWake(run.projectId, run.linearIssueId)) {
+        if (!this.db.workflowWakes.peekIssueWake(run.projectId, run.linearIssueId)) {
             const failedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? refreshedIssue;
             this.feed?.publish({
                 level: "error",

package/dist/issue-overview-query.js

@@ -127,7 +127,7 @@ export class IssueOverviewQuery {
                 delegatedToPatchRelay: issueRecord?.delegatedToPatchRelay,
                 ...(activeRun ? { activeRunId: activeRun.id } : {}),
                 blockedByCount: unresolvedBlockedBy.length,
-                hasPendingWake: this.db.issueSessions.peekIssueSessionWake(session.projectId, session.linearIssueId) !== undefined,
+                hasPendingWake: this.db.workflowWakes.peekIssueWake(session.projectId, session.linearIssueId) !== undefined,
                 hasLegacyPendingRun: issueRecord?.pendingRunType !== undefined,
                 orchestrationSettleUntil: issueRecord?.orchestrationSettleUntil,
                 ...(session.prNumber !== undefined ? { prNumber: session.prNumber } : {}),

package/dist/run-wake-planner.js

@@ -5,7 +5,7 @@ export class RunWakePlanner {
         this.db = db;
     }
     resolveRunWake(issue) {
-        const sessionWake = this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId);
+        const sessionWake = this.db.workflowWakes.peekIssueWake(issue.projectId, issue.linearIssueId);
         if (!sessionWake)
             return undefined;
         return {

package/dist/service-issue-actions.js

@@ -134,7 +134,7 @@ export class ServiceIssueActions {
             status: "retry",
             summary: `Retry queued: ${retryTarget.runType}`,
         });
-        if (this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
+        if (this.db.workflowWakes.peekIssueWake(issue.projectId, issue.linearIssueId)) {
             this.runtime.enqueueIssue(issue.projectId, issue.linearIssueId);
         }
         return { issueKey, runType: retryTarget.runType };

package/dist/service-startup-recovery.js

@@ -90,7 +90,7 @@ export class ServiceStartupRecovery {
             }
             const unresolvedBlockers = this.db.issues.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
             const latestRun = this.db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
-            const hasPendingWake = this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId) !== undefined;
+            const hasPendingWake = this.db.workflowWakes.peekIssueWake(issue.projectId, issue.linearIssueId) !== undefined;
             const shouldRecoverPausedLocalWork = delegated
                 && isResumablePausedLocalWork({
                     issue: {
@@ -147,7 +147,7 @@ export class ServiceStartupRecovery {
                         dedupeKey: `delegated:${issue.linearIssueId}`,
                     });
                 }
-                if (this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
+                if (this.db.workflowWakes.peekIssueWake(issue.projectId, issue.linearIssueId)) {
                     this.enqueueIssue(issue.projectId, issue.linearIssueId);
                 }
                 this.logger.info({

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

@@ -155,7 +155,7 @@ export class TrackedIssueListQuery {
             const blockedByCount = Number(row.blocked_by_count ?? 0);
             const hasPendingSessionEvents = Number(row.pending_session_event_count ?? 0) > 0;
             const hasPendingWake = hasPendingSessionEvents
-                || this.db.issueSessions.peekIssueSessionWake(String(row.project_id), String(row.linear_issue_id)) !== undefined;
+                || this.db.workflowWakes.peekIssueWake(String(row.project_id), String(row.linear_issue_id)) !== undefined;
             const detachedActiveRun = hasDetachedActiveLatestRun({
                 activeRunId: row.active_run_type !== null ? 1 : undefined,
                 latestRun: row.latest_run_status !== null

package/dist/tracked-issue-query.js

@@ -4,10 +4,12 @@ import { resolveEffectiveActiveRun } from "./effective-active-run.js";
 export class TrackedIssueQuery {
     issues;
     issueSessions;
+    workflowWakes;
     runs;
-    constructor(issues, issueSessions, runs) {
+    constructor(issues, issueSessions, workflowWakes, runs) {
         this.issues = issues;
         this.issueSessions = issueSessions;
+        this.workflowWakes = workflowWakes;
         this.runs = runs;
     }
     listIssuesReadyForExecution() {
@@ -20,7 +22,7 @@ export class TrackedIssueQuery {
             }),
             activeRunId: issue.activeRunId,
             blockedByCount: this.issues.countUnresolvedBlockers(issue.projectId, issue.linearIssueId),
-            hasPendingWake: this.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId) !== undefined,
+            hasPendingWake: this.workflowWakes.hasPendingWake(issue.projectId, issue.linearIssueId),
             hasLegacyPendingRun: issue.pendingRunType !== undefined,
             prNumber: issue.prNumber,
             prState: issue.prState,
@@ -38,7 +40,7 @@ export class TrackedIssueQuery {
             issue,
             session: this.issueSessions.getIssueSession(issue.projectId, issue.linearIssueId),
             blockedBy: this.issues.listIssueDependencies(issue.projectId, issue.linearIssueId),
-            hasPendingWake: this.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId) !== undefined,
+            hasPendingWake: this.workflowWakes.hasPendingWake(issue.projectId, issue.linearIssueId),
             latestRun: this.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId),
             latestEvent: this.issueSessions.listIssueSessionEvents(issue.projectId, issue.linearIssueId, { limit: 1 }).at(-1),
         });

package/dist/wake-dispatcher.js

@@ -69,7 +69,7 @@ export class WakeDispatcher {
         const issue = this.db.issues.getIssue(projectId, linearIssueId);
         if (issue?.activeRunId !== undefined)
             return undefined;
-        const wake = this.db.issueSessions.peekIssueSessionWake(projectId, linearIssueId);
+        const wake = this.db.workflowWakes.peekIssueWake(projectId, linearIssueId);
         // Fall back to the legacy pending_run_type column. The orchestrator
         // materializes it into a real event at run time, but the poke still
         // needs to happen now so the orchestrator gets called at all.
@@ -97,7 +97,7 @@ export class WakeDispatcher {
     // check paths publish their own more-specific event and pass false.
     releaseRunAndDispatch(params) {
         this.releaseLease(params.run.projectId, params.run.linearIssueId);
-        const wake = this.db.issueSessions.peekIssueSessionWake(params.run.projectId, params.run.linearIssueId);
+        const wake = this.db.workflowWakes.peekIssueWake(params.run.projectId, params.run.linearIssueId);
         if (!wake)
             return undefined;
         this.enqueueIssue(params.run.projectId, params.run.linearIssueId);

package/dist/webhook-handler.js

@@ -232,7 +232,7 @@ export class WebhookHandler {
         }
     }
     peekPendingSessionWakeRunType(projectId, issueId) {
-        return this.db.issueSessions.peekIssueSessionWake(projectId, issueId)?.runType;
+        return this.db.workflowWakes.peekIssueWake(projectId, issueId)?.runType;
     }
     enqueuePendingSessionWake(projectId, issueId) {
         return this.wakeDispatcher.dispatchIfWakePending(projectId, issueId);

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

@@ -1,13 +1,11 @@
-import { classifyIssue } from "../issue-class.js";
-import { computeOrchestrationSettleUntil, wakeOrchestrationParentsForChildEvent, } from "../orchestration-parent-wake.js";
+import { wakeOrchestrationParentsForChildEvent } from "../orchestration-parent-wake.js";
 import { triggerEventAllowed } from "../project-resolution.js";
-import { resolveAwaitingInputReason } from "../awaiting-input-reason.js";
-import { decideActiveRunRelease, decideAgentSession, decideRunIntent, decideUnDelegation, isResolvedLinearState, isTerminalDelegationState, resolveReDelegationResume, } from "./decision-helpers.js";
+import { isResolvedLinearState } 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 { resolveIssueUpdatePlan } from "./issue-update-plan.js";
+import { planIssueWebhookWorkflow } from "./issue-webhook-workflow-planner.js";
 export class DesiredStageRecorder {
     db;
     linearProvider;
@@ -29,7 +27,7 @@ export class DesiredStageRecorder {
         const latestRun = existingIssue ? this.db.runs.getLatestRunForIssue(params.project.id, normalizedIssue.id) : undefined;
         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;
+        const hasPendingWake = params.peekPendingSessionWakeRunType(params.project.id, normalizedIssue.id) !== undefined;
         if (!existingIssue && !isDelegatedToPatchRelay(this.db, params.project, normalizedIssue) && !incomingAgentSessionId) {
             return { issue: undefined, wakeRunType: undefined, delegated: false };
         }
@@ -56,108 +54,25 @@ export class DesiredStageRecorder {
             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
-            && existingIssue.prState !== "closed"
-            && existingIssue.prState !== "merged";
-        const blockerPausedImplementation = unresolvedBlockers > 0
-            && activeRun?.runType === "implementation"
-            && !openPrExists;
-        const desiredStage = linkedPrAdoption
-            ? undefined
-            : decideRunIntent({
-                delegated,
-                triggerAllowed,
-                triggerEvent: params.normalized.triggerEvent,
-                unresolvedBlockers,
-                hasActiveRun: Boolean(activeRun),
-                hasPendingWake,
-                terminal,
-                currentState: existingIssue?.factoryState,
-            });
         const childIssueCount = this.db.issues.listCanonicalChildIssues(params.project.id, normalizedIssue.id).length;
-        const classification = classifyIssue({
-            issue: {
-                issueClass: existingIssue?.issueClass,
-                issueClassSource: existingIssue?.issueClassSource,
-                title: hydratedIssue.title ?? existingIssue?.title,
-                description: hydratedIssue.description ?? existingIssue?.description,
-                parentLinearIssueId: hydratedIssue.parentId ?? existingIssue?.parentLinearIssueId,
-            },
-            childIssueCount,
-        });
-        const shouldEnterOrchestrationSettle = Boolean(delegated
-            && desiredStage === "implementation"
-            && classification.issueClass === "orchestration"
-            && childIssueCount === 0
-            && !existingIssue?.threadId
-            && !activeRun
-            && !terminal);
-        const runRelease = decideActiveRunRelease({
-            hasActiveRun: Boolean(activeRun),
-            terminal,
-            triggerEvent: params.normalized.triggerEvent,
-            delegated,
-        });
-        const effectiveRunRelease = blockerPausedImplementation
-            ? { release: true, reason: "Issue became blocked during implementation" }
-            : runRelease;
-        const undelegation = decideUnDelegation({
-            triggerEvent: params.normalized.triggerEvent,
-            delegated,
-            currentState: existingIssue?.factoryState,
-            hasPr: existingIssue?.prNumber !== undefined && existingIssue?.prState !== "merged",
-        });
-        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;
-        const clearPending = (unresolvedBlockers > 0 && existingWakeRunType === "implementation" && !activeRun)
-            || undelegation.clearPending;
-        const agentSessionId = decideAgentSession({
-            sessionId: params.normalized.agentSession?.id,
-            triggerEvent: params.normalized.triggerEvent,
-            delegated,
-        });
-        const terminalRunRelease = effectiveRunRelease.release && terminal;
-        const resolvedPlan = resolveIssueUpdatePlan({
-            existingIssue: Boolean(existingIssue),
+        const workflowPlan = planIssueWebhookWorkflow({
+            existingIssue,
+            hydratedIssue,
+            latestRun,
             delegated,
+            linkedPrAdoption,
+            triggerAllowed,
+            triggerEvent: params.normalized.triggerEvent,
+            unresolvedBlockers,
+            hasActiveRun: Boolean(activeRun),
+            activeRunType: activeRun?.runType,
+            hasPendingWake,
+            existingWakeRunType,
             incomingAgentSessionId,
-            startupResume,
-            desiredStage,
-            terminalRunRelease,
-            blockerPausedImplementation,
-            undelegation,
-            clearPending,
-            effectiveRunRelease,
-            shouldEnterOrchestrationSettle,
-            agentSessionId,
-            computeOrchestrationSettleUntil,
+            childIssueCount,
         });
         const commitIssueUpdate = () => {
             const record = this.db.issues.upsertIssue({
@@ -166,8 +81,8 @@ export class DesiredStageRecorder {
                 ...(hydratedIssue.identifier ? { issueKey: hydratedIssue.identifier } : {}),
                 ...(hydratedIssue.parentId !== undefined ? { parentLinearIssueId: hydratedIssue.parentId ?? null } : {}),
                 ...(hydratedIssue.parentIdentifier !== undefined ? { parentIssueKey: hydratedIssue.parentIdentifier ?? null } : {}),
-                issueClass: classification.issueClass,
-                issueClassSource: classification.issueClassSource,
+                issueClass: workflowPlan.classification.issueClass,
+                issueClassSource: workflowPlan.classification.issueClassSource,
                 ...(hydratedIssue.title ? { title: hydratedIssue.title } : {}),
                 ...(hydratedIssue.description ? { description: hydratedIssue.description } : {}),
                 ...(hydratedIssue.url ? { url: hydratedIssue.url } : {}),
@@ -177,10 +92,10 @@ export class DesiredStageRecorder {
                 ...(hydratedIssue.stateType ? { currentLinearStateType: hydratedIssue.stateType } : {}),
                 ...linkedPrAdoption?.issueUpdates,
                 delegatedToPatchRelay: delegated,
-                ...resolvedPlan,
+                ...workflowPlan.resolvedIssueUpdate,
             });
-            if (effectiveRunRelease.release && activeRun && effectiveRunRelease.reason) {
-                this.db.runs.finishRun(activeRun.id, { status: "released", failureReason: effectiveRunRelease.reason });
+            if (workflowPlan.effectiveRunRelease.release && activeRun && workflowPlan.effectiveRunRelease.reason) {
+                this.db.runs.finishRun(activeRun.id, { status: "released", failureReason: workflowPlan.effectiveRunRelease.reason });
             }
             return record;
         };
@@ -196,7 +111,7 @@ export class DesiredStageRecorder {
         const currentParentIssueId = issue.parentLinearIssueId;
         const wasResolved = isResolvedLinearState(existingIssue?.currentLinearStateType, existingIssue?.currentLinearState);
         const isResolved = isResolvedLinearState(issue.currentLinearStateType, issue.currentLinearState);
-        if (undelegation.factoryState) {
+        if (workflowPlan.undelegation.factoryState) {
             if (activeRun?.threadId && activeRun.turnId) {
                 await params.stopActiveRun(activeRun, "STOP: The issue was un-delegated from PatchRelay. Stop working immediately and exit.");
             }
@@ -220,7 +135,7 @@ export class DesiredStageRecorder {
                     : `Issue un-delegated from PatchRelay; ${issue.factoryState} is now paused`,
             });
         }
-        else if (blockerPausedImplementation) {
+        else if (workflowPlan.blockerPausedImplementation) {
             if (activeRun?.threadId && activeRun.turnId) {
                 await params.stopActiveRun(activeRun, "STOP: The issue is now blocked by another task. Stop working immediately and exit without publishing.");
             }
@@ -236,14 +151,14 @@ export class DesiredStageRecorder {
                 summary: `Implementation paused because ${issue.issueKey ?? normalizedIssue.id} is now blocked`,
             });
         }
-        else if (startupResume.pendingRunType) {
+        else if (workflowPlan.startupResume.pendingRunType) {
             this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(params.project.id, normalizedIssue.id, {
                 projectId: params.project.id,
                 linearIssueId: normalizedIssue.id,
-                ...buildOperatorRetryEvent(issue, startupResume.pendingRunType, startupResume.source),
+                ...buildOperatorRetryEvent(issue, workflowPlan.startupResume.pendingRunType, workflowPlan.startupResume.source),
             });
         }
-        else if (shouldEnterOrchestrationSettle) {
+        else if (workflowPlan.shouldEnterOrchestrationSettle) {
             this.feed?.publish({
                 level: "info",
                 kind: "stage",
@@ -254,10 +169,9 @@ export class DesiredStageRecorder {
                 summary: "Waiting briefly for child issues to settle before orchestration starts",
             });
         }
-        else if (!startupResume.factoryState
-            && !startupResume.pendingRunType
-            &&
-                desiredStage === "implementation"
+        else if (!workflowPlan.startupResume.factoryState
+            && !workflowPlan.startupResume.pendingRunType
+            && workflowPlan.desiredStage === "implementation"
             && params.normalized.triggerEvent !== "commentCreated"
             && params.normalized.triggerEvent !== "commentUpdated"
             && params.normalized.triggerEvent !== "agentPrompted") {

package/dist/webhooks/issue-webhook-workflow-planner.js

@@ -0,0 +1,124 @@
+import { resolveAwaitingInputReason } from "../awaiting-input-reason.js";
+import { computeOrchestrationSettleUntil as computeDefaultOrchestrationSettleUntil } from "../orchestration-parent-wake.js";
+import { classifyIssue } from "../issue-class.js";
+import { decideActiveRunRelease, decideAgentSession, decideRunIntent, decideUnDelegation, isTerminalDelegationState, resolveReDelegationResume, } from "./decision-helpers.js";
+import { resolveIssueUpdatePlan } from "./issue-update-plan.js";
+function resolveStartupResume(input) {
+    if (input.linkedPrAdoption) {
+        return {
+            factoryState: input.linkedPrAdoption.factoryState,
+            pendingRunType: input.linkedPrAdoption.pendingRunType,
+            pendingRunContext: input.linkedPrAdoption.pendingRunContext,
+            source: "linked_pr_adoption",
+        };
+    }
+    const awaitingInputReason = input.existingIssue
+        ? resolveAwaitingInputReason({ issue: input.existingIssue, latestRun: input.latestRun })
+        : undefined;
+    return {
+        ...resolveReDelegationResume({
+            delegated: input.delegated,
+            previouslyDelegated: input.existingIssue?.delegatedToPatchRelay,
+            currentState: input.existingIssue?.factoryState,
+            awaitingInputReason,
+            unresolvedBlockers: input.unresolvedBlockers,
+            prNumber: input.existingIssue?.prNumber,
+            prState: input.existingIssue?.prState,
+            prIsDraft: input.existingIssue?.prIsDraft,
+            prReviewState: input.existingIssue?.prReviewState,
+            prCheckStatus: input.existingIssue?.prCheckStatus,
+            latestFailureSource: input.existingIssue?.lastGitHubFailureSource,
+        }),
+        source: "re_delegated",
+    };
+}
+export function planIssueWebhookWorkflow(input) {
+    const terminal = isTerminalDelegationState(input.existingIssue, input.hydratedIssue);
+    const openPrExists = input.existingIssue?.prNumber !== undefined
+        && input.existingIssue.prState !== "closed"
+        && input.existingIssue.prState !== "merged";
+    const blockerPausedImplementation = input.unresolvedBlockers > 0
+        && input.activeRunType === "implementation"
+        && !openPrExists;
+    const desiredStage = input.linkedPrAdoption
+        ? undefined
+        : decideRunIntent({
+            delegated: input.delegated,
+            triggerAllowed: input.triggerAllowed,
+            triggerEvent: input.triggerEvent,
+            unresolvedBlockers: input.unresolvedBlockers,
+            hasActiveRun: input.hasActiveRun,
+            hasPendingWake: input.hasPendingWake,
+            terminal,
+            currentState: input.existingIssue?.factoryState,
+        });
+    const classification = classifyIssue({
+        issue: {
+            issueClass: input.existingIssue?.issueClass,
+            issueClassSource: input.existingIssue?.issueClassSource,
+            title: input.hydratedIssue.title ?? input.existingIssue?.title,
+            description: input.hydratedIssue.description ?? input.existingIssue?.description,
+            parentLinearIssueId: input.hydratedIssue.parentId ?? input.existingIssue?.parentLinearIssueId,
+        },
+        childIssueCount: input.childIssueCount,
+    });
+    const shouldEnterOrchestrationSettle = Boolean(input.delegated
+        && desiredStage === "implementation"
+        && classification.issueClass === "orchestration"
+        && input.childIssueCount === 0
+        && !input.existingIssue?.threadId
+        && !input.hasActiveRun
+        && !terminal);
+    const runRelease = decideActiveRunRelease({
+        hasActiveRun: input.hasActiveRun,
+        terminal,
+        triggerEvent: input.triggerEvent,
+        delegated: input.delegated,
+    });
+    const effectiveRunRelease = blockerPausedImplementation
+        ? { release: true, reason: "Issue became blocked during implementation" }
+        : runRelease;
+    const undelegation = decideUnDelegation({
+        triggerEvent: input.triggerEvent,
+        delegated: input.delegated,
+        currentState: input.existingIssue?.factoryState,
+        hasPr: input.existingIssue?.prNumber !== undefined && input.existingIssue?.prState !== "merged",
+    });
+    const startupResume = resolveStartupResume(input);
+    const clearPending = (input.unresolvedBlockers > 0 && input.existingWakeRunType === "implementation" && !input.hasActiveRun)
+        || undelegation.clearPending;
+    const agentSessionId = decideAgentSession({
+        sessionId: input.incomingAgentSessionId,
+        triggerEvent: input.triggerEvent,
+        delegated: input.delegated,
+    });
+    const terminalRunRelease = effectiveRunRelease.release && terminal;
+    const resolvedIssueUpdate = resolveIssueUpdatePlan({
+        existingIssue: Boolean(input.existingIssue),
+        delegated: input.delegated,
+        incomingAgentSessionId: input.incomingAgentSessionId,
+        startupResume,
+        desiredStage,
+        terminalRunRelease,
+        blockerPausedImplementation,
+        undelegation,
+        clearPending,
+        effectiveRunRelease,
+        shouldEnterOrchestrationSettle,
+        agentSessionId,
+        computeOrchestrationSettleUntil: input.computeOrchestrationSettleUntil ?? computeDefaultOrchestrationSettleUntil,
+    });
+    return {
+        classification,
+        terminal,
+        desiredStage,
+        blockerPausedImplementation,
+        undelegation,
+        startupResume,
+        effectiveRunRelease,
+        clearPending,
+        agentSessionId,
+        shouldEnterOrchestrationSettle,
+        resolvedIssueUpdate,
+    };
+}

package/dist/workflow-wake-resolver.js

@@ -0,0 +1,108 @@
+import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
+function parseObjectJson(raw) {
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function hasUnattemptedFailureSignature(issue, fallbackHeadSha) {
+    const signature = issue.lastGitHubFailureSignature;
+    if (!signature)
+        return false;
+    const headSha = issue.lastGitHubFailureHeadSha ?? fallbackHeadSha;
+    return issue.lastAttemptedFailureSignature !== signature
+        || (headSha !== undefined && issue.lastAttemptedFailureHeadSha !== headSha);
+}
+export function deriveImplicitReactiveWake(issue) {
+    const reactiveIntent = deriveIssueSessionReactiveIntent({
+        delegatedToPatchRelay: issue.delegatedToPatchRelay,
+        activeRunId: issue.activeRunId,
+        prNumber: issue.prNumber,
+        prState: issue.prState,
+        prReviewState: issue.prReviewState,
+        prCheckStatus: issue.prCheckStatus,
+        latestFailureSource: issue.lastGitHubFailureSource,
+    });
+    if (!reactiveIntent)
+        return undefined;
+    if (reactiveIntent.runType === "ci_repair") {
+        const failureContext = parseObjectJson(issue.lastGitHubFailureContextJson) ?? {};
+        const snapshot = parseObjectJson(issue.lastGitHubCiSnapshotJson);
+        const fallbackHeadSha = typeof failureContext.failureHeadSha === "string"
+            ? failureContext.failureHeadSha
+            : issue.lastGitHubFailureHeadSha ?? issue.prHeadSha;
+        const failureSignature = issue.lastGitHubFailureSignature
+            ?? (fallbackHeadSha ? `implicit_branch_ci::${fallbackHeadSha}` : undefined);
+        if (!failureSignature || issue.prState !== "open")
+            return undefined;
+        if (issue.lastAttemptedFailureSignature === failureSignature
+            && (fallbackHeadSha === undefined || issue.lastAttemptedFailureHeadSha === fallbackHeadSha)) {
+            return undefined;
+        }
+        return {
+            runType: reactiveIntent.runType,
+            wakeReason: reactiveIntent.wakeReason,
+            context: {
+                ...failureContext,
+                failureSignature,
+                ...(fallbackHeadSha ? { failureHeadSha: fallbackHeadSha } : {}),
+                ...(issue.lastGitHubFailureCheckName ? { checkName: issue.lastGitHubFailureCheckName } : {}),
+                ...(snapshot ? { ciSnapshot: snapshot } : {}),
+            },
+        };
+    }
+    if (reactiveIntent.runType === "queue_repair") {
+        const failureContext = parseObjectJson(issue.lastGitHubFailureContextJson) ?? {};
+        const incidentContext = parseObjectJson(issue.lastQueueIncidentJson) ?? {};
+        const fallbackHeadSha = typeof failureContext.failureHeadSha === "string"
+            ? failureContext.failureHeadSha
+            : undefined;
+        if (!hasUnattemptedFailureSignature(issue, fallbackHeadSha))
+            return undefined;
+        return {
+            runType: reactiveIntent.runType,
+            wakeReason: reactiveIntent.wakeReason,
+            context: {
+                ...incidentContext,
+                ...failureContext,
+            },
+        };
+    }
+    return undefined;
+}
+export class WorkflowWakeResolver {
+    issues;
+    issueSessions;
+    constructor(issues, issueSessions) {
+        this.issues = issues;
+        this.issueSessions = issueSessions;
+    }
+    peekIssueWake(projectId, linearIssueId) {
+        const explicitWake = this.issueSessions.peekIssueSessionWake(projectId, linearIssueId);
+        if (explicitWake)
+            return explicitWake;
+        const issue = this.issues.getIssue(projectId, linearIssueId);
+        if (!issue)
+            return undefined;
+        const implicitWake = deriveImplicitReactiveWake(issue);
+        if (!implicitWake)
+            return undefined;
+        return {
+            eventIds: [],
+            runType: implicitWake.runType,
+            context: implicitWake.context,
+            wakeReason: implicitWake.wakeReason,
+            resumeThread: false,
+        };
+    }
+    hasPendingWake(projectId, linearIssueId) {
+        return this.peekIssueWake(projectId, linearIssueId) !== undefined;
+    }
+}

package/package.json

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