patchrelay 0.36.7 → 0.36.8

package/dist/webhooks/agent-session-handler.js

@@ -0,0 +1,212 @@
+import { buildAgentSessionPlanForIssue, } from "../agent-session-plan.js";
+import { buildAgentSessionExternalUrls } from "../agent-session-presentation.js";
+import { buildAlreadyRunningThought, buildDelegationThought, buildPromptDeliveredThought, buildStopConfirmationActivity, } from "../linear-session-reporting.js";
+import { triggerEventAllowed } from "../project-resolution.js";
+export class AgentSessionHandler {
+    config;
+    db;
+    linearProvider;
+    codex;
+    logger;
+    feed;
+    constructor(config, db, linearProvider, codex, logger, feed) {
+        this.config = config;
+        this.db = db;
+        this.linearProvider = linearProvider;
+        this.codex = codex;
+        this.logger = logger;
+        this.feed = feed;
+    }
+    async handle(params) {
+        const { normalized, project, trackedIssue, wakeRunType, delegated } = params;
+        if (!normalized.agentSession?.id || !normalized.issue)
+            return;
+        const linear = await this.linearProvider.forProject(project.id);
+        if (!linear)
+            return;
+        const existingIssue = this.db.getIssue(project.id, normalized.issue.id);
+        const activeRun = existingIssue?.activeRunId ? this.db.runs.getRunById(existingIssue.activeRunId) : undefined;
+        if (normalized.triggerEvent === "agentSessionCreated") {
+            if (!delegated) {
+                const latestIssue = this.db.getIssue(project.id, normalized.issue.id);
+                if (latestIssue ?? trackedIssue) {
+                    await this.syncAgentSession(linear, normalized.agentSession.id, latestIssue ?? trackedIssue, params.peekPendingSessionWakeRunType);
+                }
+                return;
+            }
+            if (wakeRunType) {
+                const latestIssue = this.db.getIssue(project.id, normalized.issue.id);
+                await this.syncAgentSession(linear, normalized.agentSession.id, latestIssue ?? trackedIssue, params.peekPendingSessionWakeRunType, { pendingRunType: wakeRunType });
+                await this.publishAgentActivity(linear, normalized.agentSession.id, buildDelegationThought(wakeRunType));
+                return;
+            }
+            if (activeRun) {
+                const latestIssue = this.db.getIssue(project.id, normalized.issue.id);
+                await this.syncAgentSession(linear, normalized.agentSession.id, latestIssue ?? trackedIssue, params.peekPendingSessionWakeRunType, { activeRunType: activeRun.runType });
+                await this.publishAgentActivity(linear, normalized.agentSession.id, buildAlreadyRunningThought(activeRun.runType));
+                return;
+            }
+            const blockerSummary = trackedIssue?.blockedByCount
+                ? `PatchRelay is delegated and waiting on blockers to reach Done: ${trackedIssue.blockedByKeys.join(", ")}.`
+                : "PatchRelay is delegated, but no work is queued. Delegate the issue or move it to Start to trigger implementation.";
+            await this.publishAgentActivity(linear, normalized.agentSession.id, {
+                type: "elicitation",
+                body: blockerSummary,
+            });
+            return;
+        }
+        if (normalized.triggerEvent === "agentSignal" && normalized.agentSession.signal === "stop") {
+            await this.handleStopSignal({
+                normalized,
+                project,
+                trackedIssue,
+                activeRun,
+                linear,
+                syncAgentSession: (agentSessionId, issue, options) => this.syncAgentSession(linear, agentSessionId, issue, params.peekPendingSessionWakeRunType, options),
+            });
+            return;
+        }
+        if (normalized.triggerEvent !== "agentPrompted")
+            return;
+        if (!triggerEventAllowed(project, normalized.triggerEvent))
+            return;
+        const promptBody = normalized.agentSession.promptBody?.trim();
+        if (activeRun && promptBody && activeRun.threadId && activeRun.turnId) {
+            const input = `New Linear agent prompt received while you are working.\n\n${promptBody}`;
+            try {
+                await this.codex.steerTurn({ threadId: activeRun.threadId, turnId: activeRun.turnId, input });
+                this.feed?.publish({
+                    level: "info",
+                    kind: "agent",
+                    projectId: project.id,
+                    issueKey: trackedIssue?.issueKey,
+                    stage: activeRun.runType,
+                    status: "delivered",
+                    summary: `Delivered follow-up prompt to active ${activeRun.runType} workflow`,
+                });
+            }
+            catch (error) {
+                this.logger.warn({ issueKey: trackedIssue?.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to deliver follow-up prompt");
+                this.feed?.publish({
+                    level: "warn",
+                    kind: "agent",
+                    projectId: project.id,
+                    issueKey: trackedIssue?.issueKey,
+                    stage: activeRun.runType,
+                    status: "delivery_failed",
+                    summary: `Could not deliver follow-up prompt to active ${activeRun.runType} workflow`,
+                });
+            }
+            await this.publishAgentActivity(linear, normalized.agentSession.id, buildPromptDeliveredThought(activeRun.runType), { ephemeral: true });
+            return;
+        }
+        if (promptBody && existingIssue && (delegated || existingIssue.factoryState === "awaiting_input")) {
+            const hadPendingWake = this.db.issueSessions.peekIssueSessionWake(project.id, normalized.issue.id) !== undefined;
+            const directReply = params.isDirectReplyToOutstandingQuestion(existingIssue);
+            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(project.id, normalized.issue.id, {
+                projectId: project.id,
+                linearIssueId: normalized.issue.id,
+                eventType: directReply ? "direct_reply" : "followup_prompt",
+                eventJson: JSON.stringify({
+                    text: promptBody,
+                    source: "linear_agent_prompt",
+                }),
+            });
+            const queuedRunType = hadPendingWake
+                ? params.peekPendingSessionWakeRunType(project.id, normalized.issue.id)
+                : params.enqueuePendingSessionWake(project.id, normalized.issue.id);
+            const latestIssue = this.db.getIssue(project.id, normalized.issue.id);
+            await this.syncAgentSession(linear, normalized.agentSession.id, latestIssue ?? trackedIssue, params.peekPendingSessionWakeRunType, { pendingRunType: queuedRunType ?? wakeRunType ?? (existingIssue.prReviewState === "changes_requested" ? "review_fix" : "implementation") });
+            await this.publishAgentActivity(linear, normalized.agentSession.id, buildPromptDeliveredThought(queuedRunType ?? wakeRunType ?? "implementation"), { ephemeral: true });
+            return;
+        }
+        if (wakeRunType) {
+            const latestIssue = this.db.getIssue(project.id, normalized.issue.id);
+            await this.syncAgentSession(linear, normalized.agentSession.id, latestIssue ?? trackedIssue, params.peekPendingSessionWakeRunType, { pendingRunType: wakeRunType });
+            await this.publishAgentActivity(linear, normalized.agentSession.id, buildDelegationThought(wakeRunType, "prompt"), { ephemeral: true });
+        }
+    }
+    async handleStopSignal(params) {
+        const issueId = params.normalized.issue.id;
+        const sessionId = params.normalized.agentSession.id;
+        if (params.activeRun?.threadId && params.activeRun.turnId) {
+            try {
+                await this.codex.steerTurn({
+                    threadId: params.activeRun.threadId,
+                    turnId: params.activeRun.turnId,
+                    input: "STOP: The user has requested you stop working immediately. Do not make further changes. Wrap up and exit.",
+                });
+            }
+            catch (error) {
+                this.logger.warn({ issueKey: params.trackedIssue?.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to steer Codex turn for stop signal");
+            }
+            this.db.runs.finishRun(params.activeRun.id, { status: "released", threadId: params.activeRun.threadId, turnId: params.activeRun.turnId });
+        }
+        this.db.issueSessions.upsertIssueRespectingActiveLease(params.project.id, issueId, {
+            projectId: params.project.id,
+            linearIssueId: issueId,
+            activeRunId: null,
+            factoryState: "awaiting_input",
+            agentSessionId: sessionId,
+        });
+        this.db.issueSessions.appendIssueSessionEvent({
+            projectId: params.project.id,
+            linearIssueId: issueId,
+            eventType: "stop_requested",
+            dedupeKey: `stop_requested:${issueId}`,
+        });
+        this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(params.project.id, issueId);
+        this.db.issueSessions.releaseIssueSessionLeaseRespectingActiveLease(params.project.id, issueId);
+        this.feed?.publish({
+            level: "info",
+            kind: "agent",
+            projectId: params.project.id,
+            issueKey: params.trackedIssue?.issueKey,
+            status: "stopped",
+            summary: "Stop signal received - work halted",
+        });
+        const updatedIssue = this.db.getIssue(params.project.id, issueId);
+        await this.publishAgentActivity(params.linear, sessionId, buildStopConfirmationActivity());
+        await params.syncAgentSession(sessionId, updatedIssue ?? params.trackedIssue);
+    }
+    async publishAgentActivity(linear, agentSessionId, content, options) {
+        try {
+            await linear.createAgentActivity({
+                agentSessionId,
+                content,
+                ephemeral: options?.ephemeral ?? content.type === "thought",
+            });
+        }
+        catch (error) {
+            this.logger.warn({ agentSessionId, error: error instanceof Error ? error.message : String(error) }, "Failed to publish Linear agent activity");
+        }
+    }
+    async syncAgentSession(linear, agentSessionId, issue, peekPendingSessionWakeRunType, options) {
+        if (!linear.updateAgentSession)
+            return;
+        try {
+            const prUrl = issue && "prUrl" in issue ? issue.prUrl : undefined;
+            const externalUrls = buildAgentSessionExternalUrls(this.config, {
+                ...(issue?.issueKey ? { issueKey: issue.issueKey } : {}),
+                ...(prUrl ? { prUrl } : {}),
+            });
+            await linear.updateAgentSession({
+                agentSessionId,
+                ...(externalUrls ? { externalUrls } : {}),
+                ...(issue
+                    ? {
+                        plan: buildAgentSessionPlanForIssue({
+                            factoryState: issue.factoryState,
+                            pendingRunType: options?.pendingRunType ?? peekPendingSessionWakeRunType(issue.projectId, issue.linearIssueId),
+                            ciRepairAttempts: "ciRepairAttempts" in issue ? issue.ciRepairAttempts : 0,
+                            queueRepairAttempts: "queueRepairAttempts" in issue ? issue.queueRepairAttempts : 0,
+                        }, options?.activeRunType ? { activeRunType: options.activeRunType } : undefined),
+                    }
+                    : {}),
+            });
+        }
+        catch (error) {
+            this.logger.warn({ agentSessionId, error: error instanceof Error ? error.message : String(error) }, "Failed to update Linear agent session");
+        }
+    }
+}

package/dist/webhooks/comment-policy.js

@@ -0,0 +1,41 @@
+export function isInertPatchRelayComment(issue, commentId, body, actorType) {
+    if (commentId === issue.statusCommentId) {
+        return true;
+    }
+    if (body.startsWith("## PatchRelay status")
+        && body.includes("_PatchRelay updates this comment as it works. Review and merge remain downstream._")) {
+        return true;
+    }
+    const normalizedActorType = actorType?.trim().toLowerCase();
+    if (normalizedActorType && normalizedActorType !== "user") {
+        return isPatchRelayGeneratedActivityComment(body);
+    }
+    return false;
+}
+export function isPatchRelayManagedCommentAuthor(installation, actor, commentUserName) {
+    const actorName = actor?.name?.trim().toLowerCase();
+    const commentAuthor = commentUserName?.trim().toLowerCase();
+    const installationName = installation?.actorName?.trim().toLowerCase();
+    if (installation?.actorId && actor?.id === installation.actorId) {
+        return true;
+    }
+    if (installationName && actorName === installationName) {
+        return true;
+    }
+    if (actorName === "patchrelay" || commentAuthor === "patchrelay") {
+        return true;
+    }
+    return false;
+}
+export function isPatchRelayGeneratedActivityComment(body) {
+    return body.startsWith("PatchRelay needs human help to continue.")
+        || body.startsWith("PatchRelay is already working on ")
+        || body.startsWith("PatchRelay received the ")
+        || body.startsWith("PatchRelay routed your latest instructions into ")
+        || body.startsWith("PatchRelay has stopped work as requested.")
+        || body.startsWith("Merge preparation failed ")
+        || body === "This thread is for an agent session with patchrelay.";
+}
+export function hasExplicitPatchRelayWakeIntent(body) {
+    return /\bpatchrelay\b/i.test(body);
+}

package/dist/webhooks/comment-wake-handler.js

@@ -0,0 +1,133 @@
+import { triggerEventAllowed } from "../project-resolution.js";
+import { hasExplicitPatchRelayWakeIntent, isInertPatchRelayComment, isPatchRelayManagedCommentAuthor, } from "./comment-policy.js";
+const ENQUEUEABLE_STATES = new Set(["pr_open", "changes_requested", "implementing", "delegated", "awaiting_input"]);
+export class CommentWakeHandler {
+    db;
+    codex;
+    logger;
+    feed;
+    constructor(db, codex, logger, feed) {
+        this.db = db;
+        this.codex = codex;
+        this.logger = logger;
+        this.feed = feed;
+    }
+    async handle(params) {
+        const { normalized, project, trackedIssue } = params;
+        if ((normalized.triggerEvent !== "commentCreated" && normalized.triggerEvent !== "commentUpdated")
+            || !normalized.comment?.body
+            || !normalized.issue) {
+            return;
+        }
+        if (!triggerEventAllowed(project, normalized.triggerEvent))
+            return;
+        const issue = this.db.getIssue(project.id, normalized.issue.id);
+        if (!issue)
+            return;
+        const trimmedBody = normalized.comment.body.trim();
+        const installation = this.db.linearInstallations.getLinearInstallationForProject(project.id);
+        const selfAuthored = isPatchRelayManagedCommentAuthor(installation, normalized.actor, normalized.comment.userName);
+        const inertPatchRelayComment = isInertPatchRelayComment(issue, normalized.comment.id, trimmedBody, normalized.actor?.type);
+        if (selfAuthored || inertPatchRelayComment) {
+            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(project.id, normalized.issue.id, {
+                projectId: project.id,
+                linearIssueId: normalized.issue.id,
+                eventType: "self_comment",
+                eventJson: JSON.stringify({
+                    body: trimmedBody,
+                    author: normalized.comment.userName,
+                }),
+            });
+            return;
+        }
+        if (!issue.activeRunId) {
+            if (ENQUEUEABLE_STATES.has(issue.factoryState)) {
+                const directReply = params.isDirectReplyToOutstandingQuestion(issue);
+                const wakeIntent = directReply || hasExplicitPatchRelayWakeIntent(trimmedBody);
+                if (!wakeIntent) {
+                    this.feed?.publish({
+                        level: "info",
+                        kind: "comment",
+                        projectId: project.id,
+                        issueKey: trackedIssue?.issueKey,
+                        status: "ignored",
+                        summary: "Ignored comment with no explicit PatchRelay wake intent",
+                        detail: trimmedBody.slice(0, 200),
+                    });
+                    return;
+                }
+                const runType = issue.prReviewState === "changes_requested" ? "review_fix" : "implementation";
+                const hadPendingWake = this.db.issueSessions.peekIssueSessionWake(project.id, normalized.issue.id) !== undefined;
+                this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(project.id, normalized.issue.id, {
+                    projectId: project.id,
+                    linearIssueId: normalized.issue.id,
+                    eventType: directReply ? "direct_reply" : "followup_comment",
+                    eventJson: JSON.stringify({
+                        body: trimmedBody,
+                        author: normalized.comment.userName,
+                    }),
+                });
+                const queuedRunType = hadPendingWake
+                    ? params.peekPendingSessionWakeRunType(project.id, normalized.issue.id)
+                    : params.enqueuePendingSessionWake(project.id, normalized.issue.id);
+                this.feed?.publish({
+                    level: "info",
+                    kind: "comment",
+                    projectId: project.id,
+                    issueKey: trackedIssue?.issueKey,
+                    status: "enqueued",
+                    summary: `Comment enqueued ${(queuedRunType ?? runType)} run`,
+                    detail: trimmedBody.slice(0, 200),
+                });
+            }
+            return;
+        }
+        const run = this.db.runs.getRunById(issue.activeRunId);
+        if (!run?.threadId || !run.turnId)
+            return;
+        const body = [
+            "New Linear comment received while you are working.",
+            normalized.comment.userName ? `Author: ${normalized.comment.userName}` : undefined,
+            "",
+            trimmedBody,
+        ].filter(Boolean).join("\n");
+        try {
+            await this.codex.steerTurn({ threadId: run.threadId, turnId: run.turnId, input: body });
+            this.feed?.publish({
+                level: "info",
+                kind: "comment",
+                projectId: project.id,
+                issueKey: trackedIssue?.issueKey,
+                stage: run.runType,
+                status: "delivered",
+                summary: `Delivered follow-up comment to active ${run.runType} workflow`,
+            });
+        }
+        catch (error) {
+            this.logger.warn({ issueKey: trackedIssue?.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to deliver follow-up comment");
+            const hadPendingWake = this.db.issueSessions.hasPendingIssueSessionEvents(project.id, normalized.issue.id);
+            const directReply = params.isDirectReplyToOutstandingQuestion(issue);
+            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(project.id, normalized.issue.id, {
+                projectId: project.id,
+                linearIssueId: normalized.issue.id,
+                eventType: directReply ? "direct_reply" : "followup_comment",
+                eventJson: JSON.stringify({
+                    body: trimmedBody,
+                    author: normalized.comment.userName,
+                }),
+            });
+            if (!hadPendingWake) {
+                params.enqueuePendingSessionWake(project.id, normalized.issue.id);
+            }
+            this.feed?.publish({
+                level: "warn",
+                kind: "comment",
+                projectId: project.id,
+                issueKey: trackedIssue?.issueKey,
+                stage: run.runType,
+                status: "delivery_failed",
+                summary: `Could not deliver follow-up comment to active ${run.runType} workflow`,
+            });
+        }
+    }
+}

package/dist/webhooks/decision-helpers.js

@@ -0,0 +1,74 @@
+import { TERMINAL_STATES } from "../factory-state.js";
+export function decideRunIntent(p) {
+    const wakeEligibleState = p.currentState === undefined
+        || p.currentState === "delegated"
+        || p.currentState === "awaiting_input";
+    const delegatedStartupRecovery = p.delegated
+        && p.currentState === "awaiting_input"
+        && p.triggerEvent === "issueCreated";
+    if (p.delegated && (p.triggerAllowed || delegatedStartupRecovery) && p.unresolvedBlockers === 0
+        && !p.hasActiveRun && !p.hasPendingWake && !p.terminal && wakeEligibleState) {
+        return "implementation";
+    }
+    return undefined;
+}
+export function decideActiveRunRelease(p) {
+    if (!p.hasActiveRun)
+        return { release: false };
+    if (p.terminal)
+        return { release: true, reason: "Issue reached terminal state during active run" };
+    if (p.triggerEvent === "delegateChanged" && !p.delegated)
+        return { release: true, reason: "Un-delegated from PatchRelay" };
+    return { release: false };
+}
+export function decideUnDelegation(p) {
+    if (p.triggerEvent !== "delegateChanged" || p.delegated)
+        return { clearPending: false };
+    if (!p.currentState)
+        return { clearPending: false };
+    const pastNoReturn = p.currentState === "awaiting_queue" || TERMINAL_STATES.has(p.currentState);
+    if (pastNoReturn)
+        return { clearPending: false };
+    return { factoryState: "awaiting_input", clearPending: true };
+}
+export function decideAgentSession(p) {
+    if (p.sessionId)
+        return p.sessionId;
+    if (p.triggerEvent === "delegateChanged" && !p.delegated)
+        return null;
+    return undefined;
+}
+export function isResolvedLinearState(stateType, stateName) {
+    return stateType === "completed" || stateName?.trim().toLowerCase() === "done";
+}
+export function isTerminalDelegationState(existingIssue, hydratedIssue) {
+    if (existingIssue?.prState === "merged") {
+        return true;
+    }
+    if (existingIssue?.factoryState && existingIssue.factoryState !== "awaiting_input" && TERMINAL_STATES.has(existingIssue.factoryState)) {
+        return true;
+    }
+    return isResolvedLinearState(hydratedIssue.stateType, hydratedIssue.stateName);
+}
+export function hasCompleteIssueContext(issue) {
+    return Boolean(issue.stateName && issue.delegateId && issue.teamId && issue.teamKey);
+}
+export function mergeIssueMetadata(issue, liveIssue) {
+    return {
+        ...issue,
+        ...(issue.identifier ? {} : liveIssue.identifier ? { identifier: liveIssue.identifier } : {}),
+        ...(issue.title ? {} : liveIssue.title ? { title: liveIssue.title } : {}),
+        ...(issue.url ? {} : liveIssue.url ? { url: liveIssue.url } : {}),
+        ...(issue.teamId ? {} : liveIssue.teamId ? { teamId: liveIssue.teamId } : {}),
+        ...(issue.teamKey ? {} : liveIssue.teamKey ? { teamKey: liveIssue.teamKey } : {}),
+        ...(issue.stateId ? {} : liveIssue.stateId ? { stateId: liveIssue.stateId } : {}),
+        ...(issue.stateName ? {} : liveIssue.stateName ? { stateName: liveIssue.stateName } : {}),
+        ...(issue.stateType ? {} : liveIssue.stateType ? { stateType: liveIssue.stateType } : {}),
+        ...(issue.delegateId ? {} : liveIssue.delegateId ? { delegateId: liveIssue.delegateId } : {}),
+        ...(issue.delegateName ? {} : liveIssue.delegateName ? { delegateName: liveIssue.delegateName } : {}),
+        relationsKnown: issue.relationsKnown || liveIssue.blockedBy !== undefined || liveIssue.blocks !== undefined,
+        labelNames: issue.labelNames.length > 0 ? issue.labelNames : (liveIssue.labels ?? []).map((l) => l.name),
+        blockedBy: issue.relationsKnown ? issue.blockedBy : (liveIssue.blockedBy ?? issue.blockedBy),
+        blocks: issue.relationsKnown ? issue.blocks : (liveIssue.blocks ?? issue.blocks),
+    };
+}

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

@@ -0,0 +1,177 @@
+import { triggerEventAllowed } from "../project-resolution.js";
+import { decideActiveRunRelease, decideAgentSession, decideRunIntent, decideUnDelegation, isTerminalDelegationState, mergeIssueMetadata, } from "./decision-helpers.js";
+export class DesiredStageRecorder {
+    db;
+    linearProvider;
+    feed;
+    constructor(db, linearProvider, feed) {
+        this.db = db;
+        this.linearProvider = linearProvider;
+        this.feed = feed;
+    }
+    async record(params) {
+        const normalizedIssue = params.normalized.issue;
+        if (!normalizedIssue) {
+            return { issue: undefined, wakeRunType: undefined, delegated: false };
+        }
+        const existingIssue = this.db.getIssue(params.project.id, normalizedIssue.id);
+        const activeRun = existingIssue?.activeRunId ? this.db.runs.getRunById(existingIssue.activeRunId) : undefined;
+        const delegated = this.isDelegatedToPatchRelay(params.project, params.normalized);
+        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 && !delegated && !incomingAgentSessionId) {
+            return { issue: undefined, wakeRunType: undefined, delegated };
+        }
+        const hydratedIssue = await this.syncIssueDependencies(params.project.id, normalizedIssue);
+        const unresolvedBlockers = this.db.countUnresolvedBlockers(params.project.id, normalizedIssue.id);
+        const terminal = isTerminalDelegationState(existingIssue, hydratedIssue);
+        const desiredStage = decideRunIntent({
+            delegated,
+            triggerAllowed,
+            triggerEvent: params.normalized.triggerEvent,
+            unresolvedBlockers,
+            hasActiveRun: Boolean(activeRun),
+            hasPendingWake,
+            terminal,
+            currentState: existingIssue?.factoryState,
+        });
+        const runRelease = decideActiveRunRelease({
+            hasActiveRun: Boolean(activeRun),
+            terminal,
+            triggerEvent: params.normalized.triggerEvent,
+            delegated,
+        });
+        const undelegation = decideUnDelegation({
+            triggerEvent: params.normalized.triggerEvent,
+            delegated,
+            currentState: existingIssue?.factoryState,
+        });
+        const delegatedStateRecovery = delegated
+            && !terminal
+            && existingIssue?.factoryState === "awaiting_input"
+            && !undelegation.factoryState;
+        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 commitIssueUpdate = () => {
+            const record = this.db.upsertIssue({
+                projectId: params.project.id,
+                linearIssueId: normalizedIssue.id,
+                ...(hydratedIssue.identifier ? { issueKey: hydratedIssue.identifier } : {}),
+                ...(hydratedIssue.title ? { title: hydratedIssue.title } : {}),
+                ...(hydratedIssue.description ? { description: hydratedIssue.description } : {}),
+                ...(hydratedIssue.url ? { url: hydratedIssue.url } : {}),
+                ...(hydratedIssue.priority != null ? { priority: hydratedIssue.priority } : {}),
+                ...(hydratedIssue.estimate != null ? { estimate: hydratedIssue.estimate } : {}),
+                ...(hydratedIssue.stateName ? { currentLinearState: hydratedIssue.stateName } : {}),
+                ...(hydratedIssue.stateType ? { currentLinearStateType: hydratedIssue.stateType } : {}),
+                ...(!existingIssue && !delegated && incomingAgentSessionId ? { factoryState: "awaiting_input" } : {}),
+                ...(delegatedStateRecovery ? { factoryState: "delegated" } : {}),
+                ...(desiredStage ? { pendingRunType: null, pendingRunContextJson: null, factoryState: "delegated" } : {}),
+                ...(clearPending ? { pendingRunType: null, pendingRunContextJson: null } : {}),
+                ...(agentSessionId !== undefined ? { agentSessionId } : {}),
+                ...(runRelease.release ? { activeRunId: null } : {}),
+                ...(undelegation.factoryState ? { factoryState: undelegation.factoryState } : {}),
+            });
+            if (runRelease.release && activeRun && runRelease.reason) {
+                this.db.runs.finishRun(activeRun.id, { status: "released", failureReason: runRelease.reason });
+            }
+            return record;
+        };
+        const activeLease = this.db.issueSessions.getActiveIssueSessionLease(params.project.id, normalizedIssue.id);
+        const issue = activeLease
+            ? this.db.issueSessions.withIssueSessionLease(params.project.id, normalizedIssue.id, activeLease.leaseId, commitIssueUpdate) ?? (existingIssue ?? this.db.upsertIssue({
+                projectId: params.project.id,
+                linearIssueId: normalizedIssue.id,
+                ...(hydratedIssue.identifier ? { issueKey: hydratedIssue.identifier } : {}),
+            }))
+            : this.db.transaction(commitIssueUpdate);
+        if (undelegation.factoryState) {
+            if (activeRun?.threadId && activeRun.turnId) {
+                await params.stopActiveRun(activeRun, "STOP: The issue was un-delegated from PatchRelay. Stop working immediately and exit.");
+            }
+            this.db.issueSessions.appendIssueSessionEvent({
+                projectId: params.project.id,
+                linearIssueId: normalizedIssue.id,
+                eventType: "undelegated",
+                dedupeKey: `undelegated:${normalizedIssue.id}`,
+            });
+            this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(params.project.id, normalizedIssue.id);
+            this.db.issueSessions.releaseIssueSessionLeaseRespectingActiveLease(params.project.id, normalizedIssue.id);
+            this.feed?.publish({
+                level: "warn",
+                kind: "stage",
+                issueKey: issue.issueKey,
+                projectId: params.project.id,
+                stage: "awaiting_input",
+                status: "un_delegated",
+                summary: "Issue un-delegated from PatchRelay",
+            });
+        }
+        else if (desiredStage === "implementation"
+            && params.normalized.triggerEvent !== "commentCreated"
+            && params.normalized.triggerEvent !== "commentUpdated"
+            && params.normalized.triggerEvent !== "agentPrompted") {
+            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(params.project.id, normalizedIssue.id, {
+                projectId: params.project.id,
+                linearIssueId: normalizedIssue.id,
+                eventType: "delegated",
+                eventJson: JSON.stringify({
+                    promptContext: params.normalized.agentSession?.promptContext?.trim()
+                        ?? (issue.issueKey ? `Linear issue ${issue.issueKey} was delegated to PatchRelay.` : undefined),
+                    promptBody: params.normalized.agentSession?.promptBody?.trim(),
+                }),
+                dedupeKey: `delegated:${normalizedIssue.id}`,
+            });
+        }
+        return {
+            issue: this.db.issueToTrackedIssue(issue),
+            wakeRunType: params.peekPendingSessionWakeRunType(params.project.id, normalizedIssue.id),
+            delegated,
+        };
+    }
+    isDelegatedToPatchRelay(project, normalized) {
+        if (!normalized.issue)
+            return false;
+        const installation = this.db.linearInstallations.getLinearInstallationForProject(project.id);
+        if (!installation?.actorId)
+            return false;
+        return normalized.issue.delegateId === installation.actorId;
+    }
+    async syncIssueDependencies(projectId, issue) {
+        let source = issue;
+        if (!source.relationsKnown) {
+            const linear = await this.linearProvider.forProject(projectId);
+            if (linear) {
+                try {
+                    source = mergeIssueMetadata(source, await linear.getIssue(issue.id));
+                }
+                catch {
+                    // Preserve existing dependency rows when webhook relation data is incomplete.
+                }
+            }
+        }
+        if (source.relationsKnown) {
+            this.db.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 } : {}),
+                })),
+            });
+        }
+        return source;
+    }
+}