patchrelay 0.35.11 → 0.35.12

package/dist/webhook-handler.js

@@ -2,10 +2,12 @@ import { buildAgentSessionPlanForIssue, } from "./agent-session-plan.js";
 import { buildAgentSessionExternalUrls } from "./agent-session-presentation.js";
 import { TERMINAL_STATES } from "./factory-state.js";
 import { buildAlreadyRunningThought, buildDelegationThought, buildPromptDeliveredThought, buildStopConfirmationActivity, } from "./linear-session-reporting.js";
+import { deriveIssueStatusNote } from "./status-note.js";
 import { resolveProject, triggerEventAllowed, trustedActorAllowed } from "./project-resolution.js";
 import { normalizeWebhook } from "./webhooks.js";
 import { InstallationWebhookHandler } from "./webhook-installation-handler.js";
 import { safeJsonParse, sanitizeDiagnosticText } from "./utils.js";
+import { extractLatestAssistantSummary } from "./issue-session-events.js";
 export class WebhookHandler {
     config;
     db;
@@ -101,27 +103,51 @@ export class WebhookHandler {
             // Handle issue removal: release active runs, mark as failed.
             if (hydrated.triggerEvent === "issueRemoved" && trackedIssue) {
                 const removedIssue = this.db.getIssue(project.id, issue.id);
+                const activeLease = this.db.getActiveIssueSessionLease(project.id, issue.id);
+                const commitRemoval = () => {
+                    if (removedIssue?.activeRunId) {
+                        const run = this.db.getRun(removedIssue.activeRunId);
+                        if (run) {
+                            this.db.finishRun(run.id, { status: "released", failureReason: "Issue removed from Linear" });
+                        }
+                        return this.db.upsertIssue({
+                            projectId: project.id,
+                            linearIssueId: issue.id,
+                            activeRunId: null,
+                            pendingRunType: null,
+                            factoryState: "failed",
+                        });
+                    }
+                    if (removedIssue && !TERMINAL_STATES.has(removedIssue.factoryState)) {
+                        return this.db.upsertIssue({
+                            projectId: project.id,
+                            linearIssueId: issue.id,
+                            pendingRunType: null,
+                            factoryState: "failed",
+                        });
+                    }
+                    return removedIssue;
+                };
                 if (removedIssue?.activeRunId) {
                     const run = this.db.getRun(removedIssue.activeRunId);
                     if (run) {
-                        this.db.finishRun(run.id, { status: "released", failureReason: "Issue removed from Linear" });
+                        await this.stopActiveRun(run, "STOP: The Linear issue was removed. Stop working immediately and exit.");
                     }
-                    this.db.upsertIssue({
-                        projectId: project.id,
-                        linearIssueId: issue.id,
-                        activeRunId: null,
-                        pendingRunType: null,
-                        factoryState: "failed",
-                    });
                 }
-                else if (removedIssue && !TERMINAL_STATES.has(removedIssue.factoryState)) {
-                    this.db.upsertIssue({
-                        projectId: project.id,
-                        linearIssueId: issue.id,
-                        pendingRunType: null,
-                        factoryState: "failed",
-                    });
+                if (activeLease) {
+                    this.db.withIssueSessionLease(project.id, issue.id, activeLease.leaseId, commitRemoval);
                 }
+                else {
+                    commitRemoval();
+                }
+                this.db.appendIssueSessionEvent({
+                    projectId: project.id,
+                    linearIssueId: issue.id,
+                    eventType: "issue_removed",
+                    dedupeKey: `issue_removed:${issue.id}`,
+                });
+                this.db.clearPendingIssueSessionEventsRespectingActiveLease(project.id, issue.id);
+                this.db.releaseIssueSessionLeaseRespectingActiveLease(project.id, issue.id);
                 this.feed?.publish({
                     level: "warn",
                     kind: "stage",
@@ -133,36 +159,39 @@ export class WebhookHandler {
                 });
             }
             // Handle agent session events
-            await this.handleAgentSession(hydrated, project, trackedIssue, result.desiredStage, result.delegated);
+            await this.handleAgentSession(hydrated, project, trackedIssue, result.wakeRunType, result.delegated);
             // Handle comments during active run
             await this.handleComment(hydrated, project, trackedIssue);
             this.db.markWebhookProcessed(webhookEventId, "processed");
-            if (result.desiredStage) {
+            const wakeAlreadyQueuedByFollowUpHandler = normalized.triggerEvent === "commentCreated"
+                || normalized.triggerEvent === "commentUpdated"
+                || normalized.triggerEvent === "agentPrompted";
+            if (result.wakeRunType && !wakeAlreadyQueuedByFollowUpHandler) {
+                const queuedRunType = this.enqueuePendingSessionWake(project.id, issue.id);
                 this.feed?.publish({
                     level: "info",
                     kind: "stage",
                     issueKey: issue.identifier,
                     projectId: project.id,
-                    stage: result.desiredStage,
+                    stage: queuedRunType ?? result.wakeRunType,
                     status: "queued",
-                    summary: `Queued ${result.desiredStage} workflow`,
+                    summary: `Queued ${(queuedRunType ?? result.wakeRunType)} workflow`,
                     detail: `Triggered by ${hydrated.triggerEvent}.`,
                 });
-                this.enqueueIssue(project.id, issue.id);
             }
             for (const dependentIssueId of newlyReadyDependents) {
                 const dependent = this.db.getTrackedIssue(project.id, dependentIssueId);
+                const queuedRunType = this.enqueuePendingSessionWake(project.id, dependentIssueId);
                 this.feed?.publish({
                     level: "info",
                     kind: "stage",
                     issueKey: dependent?.issueKey,
                     projectId: project.id,
-                    stage: "implementation",
+                    stage: queuedRunType ?? "implementation",
                     status: "queued",
-                    summary: "Queued implementation after blockers resolved",
+                    summary: `Queued ${(queuedRunType ?? "implementation")} after blockers resolved`,
                     detail: `All blockers are now done for ${dependent?.issueKey ?? dependentIssueId}.`,
                 });
-                this.enqueueIssue(project.id, dependentIssueId);
             }
         }
         catch (error) {
@@ -183,26 +212,28 @@ export class WebhookHandler {
     async recordDesiredStage(project, normalized) {
         const normalizedIssue = normalized.issue;
         if (!normalizedIssue) {
-            return { issue: undefined, desiredStage: undefined, delegated: false };
+            return { issue: undefined, wakeRunType: undefined, delegated: false };
         }
         // ── 1. Fetch data ────────────────────────────────────────────
         const existingIssue = this.db.getIssue(project.id, normalizedIssue.id);
         const activeRun = existingIssue?.activeRunId ? this.db.getRun(existingIssue.activeRunId) : undefined;
         const delegated = this.isDelegatedToPatchRelay(project, normalized);
         const triggerAllowed = triggerEventAllowed(project, normalized.triggerEvent);
-        if (!existingIssue && !delegated) {
-            return { issue: undefined, desiredStage: undefined, delegated };
+        const incomingAgentSessionId = normalized.agentSession?.id;
+        const hasPendingWake = this.db.peekIssueSessionWake(project.id, normalizedIssue.id) !== undefined;
+        if (!existingIssue && !delegated && !incomingAgentSessionId) {
+            return { issue: undefined, wakeRunType: undefined, delegated };
         }
         const hydratedIssue = await this.syncIssueDependencies(project.id, normalizedIssue);
         const unresolvedBlockers = this.db.countUnresolvedBlockers(project.id, normalizedIssue.id);
-        const pendingRunContextJson = mergePendingImplementationContext(existingIssue?.pendingRunContextJson, normalized);
         const terminal = isTerminalDelegationState(existingIssue, hydratedIssue);
         // ── 2. Pure decisions ────────────────────────────────────────
-        const pendingRunType = decideRunIntent({
-            delegated, triggerAllowed, unresolvedBlockers,
+        const desiredStage = decideRunIntent({
+            delegated, triggerAllowed, triggerEvent: normalized.triggerEvent, unresolvedBlockers,
             hasActiveRun: Boolean(activeRun),
-            hasPendingRun: Boolean(existingIssue?.pendingRunType),
+            hasPendingWake,
             terminal,
+            currentState: existingIssue?.factoryState,
         });
         const runRelease = decideActiveRunRelease({
             hasActiveRun: Boolean(activeRun),
@@ -215,17 +246,20 @@ export class WebhookHandler {
             delegated,
             currentState: existingIssue?.factoryState,
         });
-        const clearPending = (unresolvedBlockers > 0 && existingIssue?.pendingRunType === "implementation" && !activeRun)
+        const delegatedStateRecovery = delegated
+            && !terminal
+            && existingIssue?.factoryState === "awaiting_input"
+            && !undelegation.factoryState;
+        const existingWakeRunType = existingIssue ? this.peekPendingSessionWakeRunType(project.id, normalizedIssue.id) : undefined;
+        const clearPending = (unresolvedBlockers > 0 && existingWakeRunType === "implementation" && !activeRun)
             || undelegation.clearPending;
         const agentSessionId = decideAgentSession({
             sessionId: normalized.agentSession?.id,
-            hasActiveRun: Boolean(activeRun),
-            hasPendingRun: Boolean(pendingRunType),
             triggerEvent: normalized.triggerEvent,
             delegated,
         });
         // ── 3. Transactional commit ──────────────────────────────────
-        const issue = this.db.transaction(() => {
+        const commitIssueUpdate = () => {
             const record = this.db.upsertIssue({
                 projectId: project.id,
                 linearIssueId: normalizedIssue.id,
@@ -237,11 +271,10 @@ export class WebhookHandler {
                 ...(hydratedIssue.estimate != null ? { estimate: hydratedIssue.estimate } : {}),
                 ...(hydratedIssue.stateName ? { currentLinearState: hydratedIssue.stateName } : {}),
                 ...(hydratedIssue.stateType ? { currentLinearStateType: hydratedIssue.stateType } : {}),
-                ...(pendingRunType ? { pendingRunType, factoryState: "delegated" } : {}),
-                ...(clearPending ? { pendingRunType: null } : {}),
-                ...((pendingRunType || existingIssue?.pendingRunType === "implementation") && pendingRunContextJson
-                    ? { pendingRunContextJson }
-                    : {}),
+                ...(!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 } : {}),
@@ -250,9 +283,28 @@ export class WebhookHandler {
                 this.db.finishRun(activeRun.id, { status: "released", failureReason: runRelease.reason });
             }
             return record;
-        });
+        };
+        const activeLease = this.db.getActiveIssueSessionLease(project.id, normalizedIssue.id);
+        const issue = activeLease
+            ? this.db.withIssueSessionLease(project.id, normalizedIssue.id, activeLease.leaseId, commitIssueUpdate) ?? (existingIssue ?? this.db.upsertIssue({
+                projectId: project.id,
+                linearIssueId: normalizedIssue.id,
+                ...(hydratedIssue.identifier ? { issueKey: hydratedIssue.identifier } : {}),
+            }))
+            : this.db.transaction(commitIssueUpdate);
         // ── 4. Side effects (after transaction) ──────────────────────
         if (undelegation.factoryState) {
+            if (activeRun?.threadId && activeRun.turnId) {
+                await this.stopActiveRun(activeRun, "STOP: The issue was un-delegated from PatchRelay. Stop working immediately and exit.");
+            }
+            this.db.appendIssueSessionEvent({
+                projectId: project.id,
+                linearIssueId: normalizedIssue.id,
+                eventType: "undelegated",
+                dedupeKey: `undelegated:${normalizedIssue.id}`,
+            });
+            this.db.clearPendingIssueSessionEventsRespectingActiveLease(project.id, normalizedIssue.id);
+            this.db.releaseIssueSessionLeaseRespectingActiveLease(project.id, normalizedIssue.id);
             this.feed?.publish({
                 level: "warn",
                 kind: "stage",
@@ -263,9 +315,25 @@ export class WebhookHandler {
                 summary: "Issue un-delegated from PatchRelay",
             });
         }
+        else if (desiredStage === "implementation"
+            && normalized.triggerEvent !== "commentCreated"
+            && normalized.triggerEvent !== "commentUpdated"
+            && normalized.triggerEvent !== "agentPrompted") {
+            this.db.appendIssueSessionEventRespectingActiveLease(project.id, normalizedIssue.id, {
+                projectId: project.id,
+                linearIssueId: normalizedIssue.id,
+                eventType: "delegated",
+                eventJson: JSON.stringify({
+                    promptContext: normalized.agentSession?.promptContext?.trim()
+                        ?? (issue.issueKey ? `Linear issue ${issue.issueKey} was delegated to PatchRelay.` : undefined),
+                    promptBody: normalized.agentSession?.promptBody?.trim(),
+                }),
+                dedupeKey: `delegated:${normalizedIssue.id}`,
+            });
+        }
         return {
             issue: this.db.issueToTrackedIssue(issue),
-            desiredStage: pendingRunType,
+            wakeRunType: this.peekPendingSessionWakeRunType(project.id, normalizedIssue.id),
             delegated,
         };
     }
@@ -314,29 +382,41 @@ export class WebhookHandler {
             }
             const unresolved = this.db.countUnresolvedBlockers(projectId, dependent.linearIssueId);
             if (unresolved > 0) {
-                if (issue.pendingRunType === "implementation" && issue.activeRunId === undefined) {
+                if (this.peekPendingSessionWakeRunType(projectId, dependent.linearIssueId) === "implementation"
+                    && issue.activeRunId === undefined
+                    && !this.db.hasPendingIssueSessionEvents(projectId, dependent.linearIssueId)) {
                     this.db.upsertIssue({
                         projectId,
                         linearIssueId: dependent.linearIssueId,
                         pendingRunType: null,
+                        pendingRunContextJson: null,
                     });
                 }
                 continue;
             }
-            if (issue.factoryState !== "delegated" || issue.activeRunId !== undefined || issue.pendingRunType !== undefined) {
+            if (issue.factoryState !== "delegated" || issue.activeRunId !== undefined || this.db.hasPendingIssueSessionEvents(projectId, dependent.linearIssueId)) {
                 continue;
             }
-            this.db.upsertIssue({
+            if (this.peekPendingSessionWakeRunType(projectId, dependent.linearIssueId) === "implementation") {
+                this.db.upsertIssue({
+                    projectId,
+                    linearIssueId: dependent.linearIssueId,
+                    pendingRunType: null,
+                    pendingRunContextJson: null,
+                });
+            }
+            this.db.appendIssueSessionEventRespectingActiveLease(projectId, dependent.linearIssueId, {
                 projectId,
                 linearIssueId: dependent.linearIssueId,
-                pendingRunType: "implementation",
+                eventType: "delegated",
+                dedupeKey: `delegated:${dependent.linearIssueId}`,
             });
             newlyReady.push(dependent.linearIssueId);
         }
         return newlyReady;
     }
     // ─── Agent session handling (inlined) ─────────────────────────────
-    async handleAgentSession(normalized, project, trackedIssue, desiredStage, delegated) {
+    async handleAgentSession(normalized, project, trackedIssue, wakeRunType, delegated) {
         if (!normalized.agentSession?.id || !normalized.issue)
             return;
         const linear = await this.linearProvider.forProject(project.id);
@@ -346,14 +426,16 @@ export class WebhookHandler {
         const activeRun = existingIssue?.activeRunId ? this.db.getRun(existingIssue.activeRunId) : undefined;
         if (normalized.triggerEvent === "agentSessionCreated") {
             if (!delegated) {
-                const body = "PatchRelay received your mention. Delegate the issue to PatchRelay to start work.";
-                await this.publishAgentActivity(linear, normalized.agentSession.id, { type: "elicitation", body });
+                const latestIssue = this.db.getIssue(project.id, normalized.issue.id);
+                if (latestIssue ?? trackedIssue) {
+                    await this.syncAgentSession(linear, normalized.agentSession.id, latestIssue ?? trackedIssue);
+                }
                 return;
             }
-            if (desiredStage) {
+            if (wakeRunType) {
                 const latestIssue = this.db.getIssue(project.id, normalized.issue.id);
-                await this.syncAgentSession(linear, normalized.agentSession.id, latestIssue ?? trackedIssue, { pendingRunType: desiredStage });
-                await this.publishAgentActivity(linear, normalized.agentSession.id, buildDelegationThought(desiredStage));
+                await this.syncAgentSession(linear, normalized.agentSession.id, latestIssue ?? trackedIssue, { pendingRunType: wakeRunType });
+                await this.publishAgentActivity(linear, normalized.agentSession.id, buildDelegationThought(wakeRunType));
                 return;
             }
             if (activeRun) {
@@ -411,10 +493,32 @@ export class WebhookHandler {
             await this.publishAgentActivity(linear, normalized.agentSession.id, buildPromptDeliveredThought(activeRun.runType), { ephemeral: true });
             return;
         }
-        if (desiredStage) {
+        if (promptBody && existingIssue && (delegated || existingIssue.factoryState === "awaiting_input")) {
+            const hadPendingWake = this.db.peekIssueSessionWake(project.id, normalized.issue.id) !== undefined;
+            const directReply = this.isDirectReplyToOutstandingQuestion(existingIssue);
+            this.db.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
+                ? this.peekPendingSessionWakeRunType(project.id, normalized.issue.id)
+                : this.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, {
+                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, { pendingRunType: desiredStage });
-            await this.publishAgentActivity(linear, normalized.agentSession.id, buildDelegationThought(desiredStage, "prompt"), { ephemeral: true });
+            await this.syncAgentSession(linear, normalized.agentSession.id, latestIssue ?? trackedIssue, { pendingRunType: wakeRunType });
+            await this.publishAgentActivity(linear, normalized.agentSession.id, buildDelegationThought(wakeRunType, "prompt"), { ephemeral: true });
         }
     }
     // ─── Stop signal handling ────────────────────────────────────────
@@ -435,13 +539,21 @@ export class WebhookHandler {
             }
             this.db.finishRun(activeRun.id, { status: "released", threadId: activeRun.threadId, turnId: activeRun.turnId });
         }
-        this.db.upsertIssue({
+        this.db.upsertIssueRespectingActiveLease(project.id, issueId, {
             projectId: project.id,
             linearIssueId: issueId,
             activeRunId: null,
             factoryState: "awaiting_input",
             agentSessionId: sessionId,
         });
+        this.db.appendIssueSessionEvent({
+            projectId: project.id,
+            linearIssueId: issueId,
+            eventType: "stop_requested",
+            dedupeKey: `stop_requested:${issueId}`,
+        });
+        this.db.clearPendingIssueSessionEventsRespectingActiveLease(project.id, issueId);
+        this.db.releaseIssueSessionLeaseRespectingActiveLease(project.id, issueId);
         this.feed?.publish({
             level: "info",
             kind: "agent",
@@ -454,6 +566,16 @@ export class WebhookHandler {
         await this.publishAgentActivity(linear, sessionId, buildStopConfirmationActivity());
         await this.syncAgentSession(linear, sessionId, updatedIssue ?? trackedIssue);
     }
+    async stopActiveRun(run, input) {
+        if (!run.threadId || !run.turnId)
+            return;
+        try {
+            await this.codex.steerTurn({ threadId: run.threadId, turnId: run.turnId, input });
+        }
+        catch (error) {
+            this.logger.warn({ runId: run.id, error: error instanceof Error ? error.message : String(error) }, "Failed to steer active run during session shutdown");
+        }
+    }
     // ─── Comment handling (inlined) ───────────────────────────────────
     async handleComment(normalized, project, trackedIssue) {
         if ((normalized.triggerEvent !== "commentCreated" && normalized.triggerEvent !== "commentUpdated") ||
@@ -468,6 +590,15 @@ export class WebhookHandler {
         // commentCreated webhook back — without this guard that re-enqueues a new run.
         const installation = this.db.linearInstallations.getLinearInstallationForProject(project.id);
         if (installation?.actorId && normalized.actor?.id === installation.actorId) {
+            this.db.appendIssueSessionEventRespectingActiveLease(project.id, normalized.issue.id, {
+                projectId: project.id,
+                linearIssueId: normalized.issue.id,
+                eventType: "self_comment",
+                eventJson: JSON.stringify({
+                    body: normalized.comment.body.trim(),
+                    author: normalized.comment.userName,
+                }),
+            });
             return;
         }
         const issue = this.db.getIssue(project.id, normalized.issue.id);
@@ -475,23 +606,30 @@ export class WebhookHandler {
             return;
         // No active run — enqueue a run with the comment as context if appropriate
         if (!issue.activeRunId) {
-            const ENQUEUEABLE_STATES = new Set(["pr_open", "changes_requested", "implementing", "delegated"]);
+            const ENQUEUEABLE_STATES = new Set(["pr_open", "changes_requested", "implementing", "delegated", "awaiting_input"]);
             if (ENQUEUEABLE_STATES.has(issue.factoryState)) {
                 const runType = issue.prReviewState === "changes_requested" ? "review_fix" : "implementation";
-                this.db.upsertIssue({
+                const hadPendingWake = this.db.peekIssueSessionWake(project.id, normalized.issue.id) !== undefined;
+                const directReply = this.isDirectReplyToOutstandingQuestion(issue);
+                this.db.appendIssueSessionEventRespectingActiveLease(project.id, normalized.issue.id, {
                     projectId: project.id,
                     linearIssueId: normalized.issue.id,
-                    pendingRunType: runType,
-                    pendingRunContextJson: JSON.stringify({ userComment: normalized.comment.body.trim() }),
+                    eventType: directReply ? "direct_reply" : "followup_comment",
+                    eventJson: JSON.stringify({
+                        body: normalized.comment.body.trim(),
+                        author: normalized.comment.userName,
+                    }),
                 });
-                this.enqueueIssue(project.id, normalized.issue.id);
+                const queuedRunType = hadPendingWake
+                    ? this.peekPendingSessionWakeRunType(project.id, normalized.issue.id)
+                    : this.enqueuePendingSessionWake(project.id, normalized.issue.id);
                 this.feed?.publish({
                     level: "info",
                     kind: "comment",
                     projectId: project.id,
                     issueKey: trackedIssue?.issueKey,
                     status: "enqueued",
-                    summary: `Comment enqueued ${runType} run`,
+                    summary: `Comment enqueued ${(queuedRunType ?? runType)} run`,
                     detail: normalized.comment.body.slice(0, 200),
                 });
             }
@@ -520,6 +658,20 @@ export class WebhookHandler {
         }
         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.hasPendingIssueSessionEvents(project.id, normalized.issue.id);
+            const directReply = this.isDirectReplyToOutstandingQuestion(issue);
+            this.db.appendIssueSessionEventRespectingActiveLease(project.id, normalized.issue.id, {
+                projectId: project.id,
+                linearIssueId: normalized.issue.id,
+                eventType: directReply ? "direct_reply" : "followup_comment",
+                eventJson: JSON.stringify({
+                    body: normalized.comment.body.trim(),
+                    author: normalized.comment.userName,
+                }),
+            });
+            if (!hadPendingWake) {
+                this.enqueuePendingSessionWake(project.id, normalized.issue.id);
+            }
             this.feed?.publish({
                 level: "warn",
                 kind: "comment",
@@ -531,6 +683,17 @@ export class WebhookHandler {
             });
         }
     }
+    peekPendingSessionWakeRunType(projectId, issueId) {
+        return this.db.peekIssueSessionWake(projectId, issueId)?.runType;
+    }
+    enqueuePendingSessionWake(projectId, issueId) {
+        const wake = this.db.peekIssueSessionWake(projectId, issueId);
+        if (!wake) {
+            return undefined;
+        }
+        this.enqueueIssue(projectId, issueId);
+        return wake.runType;
+    }
     // ─── Helpers ──────────────────────────────────────────────────────
     async publishAgentActivity(linear, agentSessionId, content, options) {
         try {
@@ -544,6 +707,18 @@ export class WebhookHandler {
             this.logger.warn({ agentSessionId, error: error instanceof Error ? error.message : String(error) }, "Failed to publish Linear agent activity");
         }
     }
+    async isCurrentLinearIssueDelegatedToPatchRelay(linear, projectId, issueId) {
+        const installation = this.db.linearInstallations.getLinearInstallationForProject(projectId);
+        if (!installation?.actorId)
+            return false;
+        try {
+            const issue = await linear.getIssue(issueId);
+            return issue.delegateId === installation.actorId;
+        }
+        catch {
+            return false;
+        }
+    }
     async syncAgentSession(linear, agentSessionId, issue, options) {
         if (!linear.updateAgentSession)
             return;
@@ -560,7 +735,7 @@ export class WebhookHandler {
                     ? {
                         plan: buildAgentSessionPlanForIssue({
                             factoryState: issue.factoryState,
-                            pendingRunType: options?.pendingRunType ?? ("pendingRunType" in issue ? issue.pendingRunType : undefined),
+                            pendingRunType: options?.pendingRunType ?? this.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),
@@ -611,11 +786,40 @@ export class WebhookHandler {
         }
         return undefined;
     }
+    isDirectReplyToOutstandingQuestion(issue) {
+        if (!issue)
+            return false;
+        const linearNeedsInput = issue.currentLinearState?.trim().toLowerCase().includes("input") ?? false;
+        if (issue.factoryState !== "awaiting_input" && !linearNeedsInput)
+            return false;
+        if (issue.threadId) {
+            return true;
+        }
+        const latestRun = this.db.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
+        const latestRunNote = extractLatestAssistantSummary(latestRun)?.trim();
+        if (latestRunNote?.endsWith("?")) {
+            return true;
+        }
+        const latestEvent = this.db.listIssueSessionEvents(issue.projectId, issue.linearIssueId).at(-1);
+        const statusNote = deriveIssueStatusNote({
+            issue,
+            latestRun,
+            latestEvent,
+            waitingReason: undefined,
+        })?.trim();
+        return Boolean(statusNote?.endsWith("?"));
+    }
 }
 // ─── Pure decision functions for recordDesiredStage ──────────────
 function decideRunIntent(p) {
-    if (p.delegated && p.triggerAllowed && p.unresolvedBlockers === 0
-        && !p.hasActiveRun && !p.hasPendingRun && !p.terminal) {
+    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;
@@ -642,7 +846,7 @@ function decideUnDelegation(p) {
 function decideAgentSession(p) {
     if (p.sessionId)
         return p.sessionId;
-    if (!p.hasActiveRun && (p.hasPendingRun || (p.triggerEvent === "delegateChanged" && !p.delegated)))
+    if (p.triggerEvent === "delegateChanged" && !p.delegated)
         return null;
     return undefined;
 }
@@ -654,7 +858,7 @@ function isTerminalDelegationState(existingIssue, hydratedIssue) {
     if (existingIssue?.prState === "merged") {
         return true;
     }
-    if (existingIssue?.factoryState && TERMINAL_STATES.has(existingIssue.factoryState)) {
+    if (existingIssue?.factoryState && existingIssue.factoryState !== "awaiting_input" && TERMINAL_STATES.has(existingIssue.factoryState)) {
         return true;
     }
     return isResolvedLinearState(hydratedIssue.stateType, hydratedIssue.stateName);
@@ -662,19 +866,6 @@ function isTerminalDelegationState(existingIssue, hydratedIssue) {
 function hasCompleteIssueContext(issue) {
     return Boolean(issue.stateName && issue.delegateId && issue.teamId && issue.teamKey);
 }
-function mergePendingImplementationContext(existingJson, normalized) {
-    const existing = existingJson ? safeJsonParse(existingJson) ?? {} : {};
-    const next = { ...existing };
-    const promptContext = normalized.agentSession?.promptContext?.trim();
-    const promptBody = normalized.agentSession?.promptBody?.trim();
-    if (promptContext) {
-        next.promptContext = promptContext;
-    }
-    if (promptBody) {
-        next.promptBody = promptBody;
-    }
-    return Object.keys(next).length > 0 ? JSON.stringify(next) : undefined;
-}
 function mergeIssueMetadata(issue, liveIssue) {
     return {
         ...issue,

package/package.json

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