patchrelay 0.36.18 → 0.37.0

package/dist/run-finalizer.js

@@ -1,5 +1,6 @@
 import { buildStageReport, countEventMethods } from "./run-reporting.js";
-import { buildCompletionCheckActivity, buildRunCompletedActivity, buildRunFailureActivity } from "./linear-session-reporting.js";
+import { buildRunCompletedActivity, buildRunFailureActivity } from "./linear-session-reporting.js";
+import { handleNoPrCompletionCheck } from "./no-pr-completion-check.js";
 import { resolveCompletedRunState } from "./run-completion-policy.js";
 export class RunFinalizer {
     db;
@@ -39,6 +40,50 @@ export class RunFinalizer {
         this.linearSync.clearProgress(run.id);
         this.releaseLease(run.projectId, run.linearIssueId);
     }
+    publishTurnEvent(params) {
+        this.feed?.publish({
+            level: params.level,
+            kind: "turn",
+            issueKey: params.issueKey,
+            projectId: params.run.projectId,
+            stage: params.run.runType,
+            status: params.status,
+            summary: params.summary,
+            ...(params.detail ? { detail: params.detail } : {}),
+        });
+    }
+    syncFailureOutcome(params) {
+        const issue = this.db.issues.getIssue(params.run.projectId, params.run.linearIssueId) ?? params.fallbackIssue;
+        this.publishTurnEvent({
+            level: params.level,
+            run: params.run,
+            issueKey: params.fallbackIssue.issueKey,
+            status: params.status,
+            summary: params.summary,
+            ...(params.detail ? { detail: params.detail } : {}),
+        });
+        void this.linearSync.emitActivity(issue, buildRunFailureActivity(params.run.runType, params.message));
+        void this.linearSync.syncSession(issue, { activeRunType: params.run.runType });
+        this.clearProgressAndRelease(params.run);
+    }
+    syncCompletionCheckOutcome(params) {
+        const issue = this.db.issues.getIssue(params.run.projectId, params.run.linearIssueId) ?? params.fallbackIssue;
+        this.publishTurnEvent({
+            level: params.level,
+            run: params.run,
+            issueKey: params.fallbackIssue.issueKey,
+            status: params.status,
+            summary: params.summary,
+            ...(params.detail ? { detail: params.detail } : {}),
+        });
+        void this.linearSync.emitActivity(issue, params.activity, { ephemeral: true });
+        void this.linearSync.syncSession(issue);
+        this.linearSync.clearProgress(params.run.id);
+        if (params.enqueue) {
+            this.enqueueIssue(params.run.projectId, params.run.linearIssueId);
+        }
+        this.releaseLease(params.run.projectId, params.run.linearIssueId);
+    }
     async finalizeCompletedRun(params) {
         const { run, issue, thread, threadId } = params;
         const trackedIssue = this.db.issueToTrackedIssue(issue);
@@ -48,257 +93,49 @@ export class RunFinalizer {
         if (verifiedRepairError) {
             const holdState = params.resolveRecoverableRunState(freshIssue) ?? "failed";
             this.failRunAndClear(run, verifiedRepairError, holdState);
-            const heldIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? freshIssue;
-            this.feed?.publish({
+            this.syncFailureOutcome({
+                run,
+                fallbackIssue: freshIssue,
+                message: verifiedRepairError,
                 level: "warn",
-                kind: "turn",
-                issueKey: freshIssue.issueKey,
-                projectId: run.projectId,
-                stage: run.runType,
                 status: "branch_not_advanced",
                 summary: verifiedRepairError,
             });
-            void this.linearSync.emitActivity(heldIssue, buildRunFailureActivity(run.runType, verifiedRepairError));
-            void this.linearSync.syncSession(heldIssue, { activeRunType: run.runType });
-            this.linearSync.clearProgress(run.id);
-            this.releaseLease(run.projectId, run.linearIssueId);
             return;
         }
         const missingReviewFixHeadError = await this.completionPolicy.verifyReviewFixAdvancedHead(run, freshIssue);
         if (missingReviewFixHeadError) {
             this.failRunAndClear(run, missingReviewFixHeadError, "escalated");
-            const failedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? freshIssue;
-            this.feed?.publish({
+            this.syncFailureOutcome({
+                run,
+                fallbackIssue: freshIssue,
+                message: missingReviewFixHeadError,
                 level: "error",
-                kind: "turn",
-                issueKey: freshIssue.issueKey,
-                projectId: run.projectId,
-                stage: run.runType,
                 status: "same_head_review_handoff_blocked",
                 summary: missingReviewFixHeadError,
             });
-            void this.linearSync.emitActivity(failedIssue, buildRunFailureActivity(run.runType, missingReviewFixHeadError));
-            void this.linearSync.syncSession(failedIssue, { activeRunType: run.runType });
-            this.linearSync.clearProgress(run.id);
-            this.releaseLease(run.projectId, run.linearIssueId);
             return;
         }
         const publishedOutcomeError = await this.completionPolicy.verifyPublishedRunOutcome(run, freshIssue);
         if (publishedOutcomeError) {
-            this.feed?.publish({
-                level: "info",
-                kind: "turn",
-                issueKey: freshIssue.issueKey,
-                projectId: run.projectId,
-                stage: run.runType,
-                status: "completion_check_started",
-                summary: "No PR found; checking next step",
-                detail: publishedOutcomeError,
-            });
-            void this.linearSync.emitActivity(freshIssue, buildCompletionCheckActivity("started"), { ephemeral: true });
-            let completionCheck;
-            try {
-                completionCheck = await this.completionCheck.run({
-                    issue: freshIssue,
-                    run,
-                    noPrSummary: publishedOutcomeError,
-                    onStarted: ({ threadId: completionCheckThreadId, turnId: completionCheckTurnId }) => {
-                        this.db.runs.markCompletionCheckStarted(run.id, {
-                            threadId: completionCheckThreadId,
-                            turnId: completionCheckTurnId,
-                        });
-                    },
-                });
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                this.failRunAndClear(run, `No PR observed and the completion check failed: ${message}`, "failed");
-                const failedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? freshIssue;
-                this.feed?.publish({
-                    level: "error",
-                    kind: "turn",
-                    issueKey: freshIssue.issueKey,
-                    projectId: run.projectId,
-                    stage: run.runType,
-                    status: "completion_check_failed",
-                    summary: "No PR found; completion check failed",
-                    detail: message,
-                });
-                void this.linearSync.emitActivity(failedIssue, buildRunFailureActivity(run.runType, `No PR observed and the completion check failed: ${message}`));
-                void this.linearSync.syncSession(failedIssue, { activeRunType: run.runType });
-                this.clearProgressAndRelease(run);
-                return;
-            }
-            const completedRunUpdate = this.buildCompletedRunUpdate({
+            await handleNoPrCompletionCheck({
+                db: this.db,
+                logger: this.logger,
+                withHeldLease: this.withHeldLease,
+                completionCheck: this.completionCheck,
+                run,
+                issue: freshIssue,
+                report,
                 threadId,
                 ...(params.completedTurnId ? { completedTurnId: params.completedTurnId } : {}),
-                report,
+                publishedOutcomeError,
+                failRunAndClear: this.failRunAndClear,
+                emitActivity: (issueRecord, activity, options) => this.linearSync.emitActivity(issueRecord, activity, options),
+                publishTurnEvent: (event) => this.publishTurnEvent(event),
+                syncFailureOutcome: (event) => this.syncFailureOutcome(event),
+                syncCompletionCheckOutcome: (event) => this.syncCompletionCheckOutcome(event),
+                clearProgressAndRelease: (releaseRun) => this.clearProgressAndRelease(releaseRun),
             });
-            if (completionCheck.outcome === "continue") {
-                const continued = this.withHeldLease(run.projectId, run.linearIssueId, (lease) => {
-                    this.db.runs.finishRun(run.id, completedRunUpdate);
-                    this.db.runs.saveCompletionCheck(run.id, completionCheck);
-                    this.db.issues.upsertIssue({
-                        projectId: run.projectId,
-                        linearIssueId: run.linearIssueId,
-                        activeRunId: null,
-                        factoryState: "delegated",
-                        pendingRunType: null,
-                        pendingRunContextJson: null,
-                    });
-                    return Boolean(this.db.issueSessions.appendIssueSessionEventWithLease(lease, {
-                        projectId: run.projectId,
-                        linearIssueId: run.linearIssueId,
-                        eventType: "completion_check_continue",
-                        eventJson: JSON.stringify({
-                            runType: run.runType,
-                            summary: completionCheck.summary,
-                        }),
-                        dedupeKey: `completion_check_continue:${run.id}`,
-                    }));
-                });
-                if (!continued) {
-                    this.logger.warn({ runId: run.id, issueId: run.linearIssueId }, "Skipping completion-check continue writes after losing issue-session lease");
-                    this.clearProgressAndRelease(run);
-                    return;
-                }
-                const continuedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? freshIssue;
-                this.feed?.publish({
-                    level: "info",
-                    kind: "turn",
-                    issueKey: freshIssue.issueKey,
-                    projectId: run.projectId,
-                    stage: run.runType,
-                    status: "completion_check_continue",
-                    summary: "No PR found; continuing automatically",
-                    detail: completionCheck.summary,
-                });
-                void this.linearSync.emitActivity(continuedIssue, buildCompletionCheckActivity("continue"), { ephemeral: true });
-                void this.linearSync.syncSession(continuedIssue);
-                this.linearSync.clearProgress(run.id);
-                this.enqueueIssue(run.projectId, run.linearIssueId);
-                this.releaseLease(run.projectId, run.linearIssueId);
-                return;
-            }
-            if (completionCheck.outcome === "needs_input") {
-                const completed = this.withHeldLease(run.projectId, run.linearIssueId, (lease) => {
-                    this.db.runs.finishRun(run.id, completedRunUpdate);
-                    this.db.runs.saveCompletionCheck(run.id, completionCheck);
-                    this.db.issueSessions.clearPendingIssueSessionEventsWithLease(lease);
-                    this.db.issues.upsertIssue({
-                        projectId: run.projectId,
-                        linearIssueId: run.linearIssueId,
-                        activeRunId: null,
-                        factoryState: "awaiting_input",
-                        pendingRunType: null,
-                        pendingRunContextJson: null,
-                    });
-                    return true;
-                });
-                if (!completed) {
-                    this.logger.warn({ runId: run.id, issueId: run.linearIssueId }, "Skipping completion-check needs-input writes after losing issue-session lease");
-                    this.clearProgressAndRelease(run);
-                    return;
-                }
-                const awaitingIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? freshIssue;
-                this.feed?.publish({
-                    level: "warn",
-                    kind: "turn",
-                    issueKey: freshIssue.issueKey,
-                    projectId: run.projectId,
-                    stage: run.runType,
-                    status: "completion_check_needs_input",
-                    summary: "No PR found; waiting for answer",
-                    detail: completionCheck.question ?? completionCheck.summary,
-                });
-                void this.linearSync.emitActivity(awaitingIssue, buildCompletionCheckActivity("needs_input", completionCheck));
-                void this.linearSync.syncSession(awaitingIssue);
-                this.clearProgressAndRelease(run);
-                return;
-            }
-            if (completionCheck.outcome === "done") {
-                const completed = this.withHeldLease(run.projectId, run.linearIssueId, (lease) => {
-                    this.db.runs.finishRun(run.id, completedRunUpdate);
-                    this.db.runs.saveCompletionCheck(run.id, completionCheck);
-                    this.db.issueSessions.clearPendingIssueSessionEventsWithLease(lease);
-                    this.db.issues.upsertIssue({
-                        projectId: run.projectId,
-                        linearIssueId: run.linearIssueId,
-                        activeRunId: null,
-                        factoryState: "done",
-                        pendingRunType: null,
-                        pendingRunContextJson: null,
-                        lastGitHubFailureSource: null,
-                        lastGitHubFailureHeadSha: null,
-                        lastGitHubFailureSignature: null,
-                        lastGitHubFailureCheckName: null,
-                        lastGitHubFailureCheckUrl: null,
-                        lastGitHubFailureContextJson: null,
-                        lastGitHubFailureAt: null,
-                        lastQueueIncidentJson: null,
-                        lastAttemptedFailureHeadSha: null,
-                        lastAttemptedFailureSignature: null,
-                    });
-                    return true;
-                });
-                if (!completed) {
-                    this.logger.warn({ runId: run.id, issueId: run.linearIssueId }, "Skipping completion-check done writes after losing issue-session lease");
-                    this.clearProgressAndRelease(run);
-                    return;
-                }
-                const doneIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? freshIssue;
-                this.feed?.publish({
-                    level: "info",
-                    kind: "turn",
-                    issueKey: freshIssue.issueKey,
-                    projectId: run.projectId,
-                    stage: run.runType,
-                    status: "completion_check_done",
-                    summary: "No PR found; confirmed done",
-                    detail: completionCheck.summary,
-                });
-                void this.linearSync.emitActivity(doneIssue, buildCompletionCheckActivity("done", completionCheck));
-                void this.linearSync.syncSession(doneIssue);
-                this.clearProgressAndRelease(run);
-                return;
-            }
-            const failureReason = `No PR observed and the completion check failed this run: ${completionCheck.summary}`;
-            const failed = this.withHeldLease(run.projectId, run.linearIssueId, () => {
-                this.db.runs.finishRun(run.id, {
-                    ...completedRunUpdate,
-                    status: "failed",
-                    failureReason,
-                });
-                this.db.runs.saveCompletionCheck(run.id, completionCheck);
-                this.db.issues.upsertIssue({
-                    projectId: run.projectId,
-                    linearIssueId: run.linearIssueId,
-                    activeRunId: null,
-                    factoryState: "failed",
-                    pendingRunType: null,
-                    pendingRunContextJson: null,
-                });
-                return true;
-            });
-            if (!failed) {
-                this.logger.warn({ runId: run.id, issueId: run.linearIssueId }, "Skipping completion-check failed writes after losing issue-session lease");
-                this.clearProgressAndRelease(run);
-                return;
-            }
-            const failedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? freshIssue;
-            this.feed?.publish({
-                level: "warn",
-                kind: "turn",
-                issueKey: freshIssue.issueKey,
-                projectId: run.projectId,
-                stage: run.runType,
-                status: "completion_check_failed",
-                summary: "No PR found; completion check failed",
-                detail: completionCheck.summary,
-            });
-            void this.linearSync.emitActivity(failedIssue, buildRunFailureActivity(run.runType, failureReason));
-            void this.linearSync.syncSession(failedIssue, { activeRunType: run.runType });
-            this.clearProgressAndRelease(run);
             return;
         }
         const refreshedIssue = await this.completionPolicy.refreshIssueAfterReactivePublish(run, freshIssue);
@@ -357,17 +194,15 @@ export class RunFinalizer {
             });
             this.enqueueIssue(run.projectId, run.linearIssueId);
         }
-        this.feed?.publish({
+        this.publishTurnEvent({
             level: "info",
-            kind: "turn",
+            run,
             issueKey: issue.issueKey,
-            projectId: run.projectId,
-            stage: run.runType,
             status: "completed",
             summary: params.source === "notification"
                 ? `Turn completed for ${run.runType}`
                 : `Reconciliation: ${run.runType} completed${postRunState ? ` -> ${postRunState}` : ""}`,
-            ...(report.assistantMessages.at(-1) ? { detail: report.assistantMessages.at(-1) } : {}),
+            detail: report.assistantMessages.at(-1),
         });
         const updatedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? refreshedIssue;
         const completionSummary = report.assistantMessages.at(-1)?.slice(0, 300) ?? `${run.runType} completed.`;

package/dist/service-issue-actions.js

@@ -0,0 +1,164 @@
+import { buildOperatorRetryEvent } from "./operator-retry-event.js";
+export class ServiceIssueActions {
+    db;
+    codex;
+    runtime;
+    feed;
+    logger;
+    constructor(db, codex, runtime, feed, logger) {
+        this.db = db;
+        this.codex = codex;
+        this.runtime = runtime;
+        this.feed = feed;
+        this.logger = logger;
+    }
+    async promptIssue(issueKey, text, source = "watch") {
+        const issue = this.db.issues.getIssueByKey(issueKey);
+        if (!issue)
+            return undefined;
+        this.feed.publish({
+            level: "info",
+            kind: "comment",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: issue.factoryState,
+            status: "operator_prompt",
+            summary: `Operator prompt (${source})`,
+            detail: text.slice(0, 200),
+        });
+        if (!issue.activeRunId) {
+            this.queueOperatorPrompt(issue, text, source);
+            return { delivered: false, queued: true };
+        }
+        const run = this.db.runs.getRunById(issue.activeRunId);
+        if (!run?.threadId || !run.turnId) {
+            return { error: "Active run has no thread or turn yet" };
+        }
+        try {
+            await this.codex.steerTurn({
+                threadId: run.threadId,
+                turnId: run.turnId,
+                input: `Operator prompt (${source}):\n\n${text}`,
+            });
+            return { delivered: true };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger.warn({ issueKey, error: msg }, "steerTurn failed, queuing prompt for next run");
+            this.queueOperatorPrompt(issue, text, source);
+            return { delivered: false, queued: true };
+        }
+    }
+    async stopIssue(issueKey) {
+        const issue = this.db.issues.getIssueByKey(issueKey);
+        if (!issue)
+            return undefined;
+        if (!issue.activeRunId)
+            return { error: "No active run to stop" };
+        const run = this.db.runs.getRunById(issue.activeRunId);
+        if (run?.threadId && run.turnId) {
+            try {
+                await this.codex.steerTurn({
+                    threadId: run.threadId,
+                    turnId: run.turnId,
+                    input: "STOP: The operator has requested this run to halt immediately. Finish your current action, commit any partial progress, and stop.",
+                });
+            }
+            catch {
+                // Turn may already be done.
+            }
+        }
+        this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            eventType: "stop_requested",
+            dedupeKey: `operator_stop:${issue.linearIssueId}`,
+        });
+        this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(issue.projectId, issue.linearIssueId);
+        this.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            factoryState: "awaiting_input",
+        });
+        this.feed.publish({
+            level: "warn",
+            kind: "workflow",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            status: "stopped",
+            summary: "Operator stopped the run",
+        });
+        return { stopped: true };
+    }
+    retryIssue(issueKey) {
+        const issue = this.db.issues.getIssueByKey(issueKey);
+        if (!issue)
+            return undefined;
+        if (issue.activeRunId)
+            return { error: "Issue already has an active run" };
+        const issueSession = this.db.issueSessions.getIssueSession(issue.projectId, issue.linearIssueId);
+        if (issue.prState === "merged") {
+            this.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                factoryState: "done",
+            });
+            return { issueKey, runType: "none" };
+        }
+        let runType = "implementation";
+        let factoryState = "delegated";
+        if (issue.prNumber && issue.lastGitHubFailureSource === "queue_eviction") {
+            runType = "queue_repair";
+            factoryState = "repairing_queue";
+        }
+        else if (issue.prNumber && (issue.prCheckStatus === "failed" || issue.prCheckStatus === "failure" || issue.lastGitHubFailureSource === "branch_ci")) {
+            runType = "ci_repair";
+            factoryState = "repairing_ci";
+        }
+        else if (issue.prNumber && issue.prReviewState === "changes_requested") {
+            runType = issue.pendingRunType === "branch_upkeep" || issueSession?.lastRunType === "branch_upkeep"
+                ? "branch_upkeep"
+                : "review_fix";
+            factoryState = "changes_requested";
+        }
+        else if (issue.prNumber) {
+            runType = "implementation";
+            factoryState = "implementing";
+        }
+        this.appendOperatorRetryEvent(issue, runType);
+        this.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            factoryState: factoryState,
+        });
+        this.feed.publish({
+            level: "info",
+            kind: "stage",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: factoryState,
+            status: "retry",
+            summary: `Retry queued: ${runType}`,
+        });
+        if (this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
+            this.runtime.enqueueIssue(issue.projectId, issue.linearIssueId);
+        }
+        return { issueKey, runType };
+    }
+    queueOperatorPrompt(issue, text, source) {
+        this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            eventType: "operator_prompt",
+            eventJson: JSON.stringify({ text, source }),
+        });
+        this.runtime.enqueueIssue(issue.projectId, issue.linearIssueId);
+    }
+    appendOperatorRetryEvent(issue, runType) {
+        this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            ...buildOperatorRetryEvent(issue, runType),
+        });
+    }
+}

package/dist/service-startup-recovery.js

@@ -0,0 +1,104 @@
+export class ServiceStartupRecovery {
+    db;
+    linearProvider;
+    linearSync;
+    enqueueIssue;
+    logger;
+    constructor(db, linearProvider, linearSync, enqueueIssue, logger) {
+        this.db = db;
+        this.linearProvider = linearProvider;
+        this.linearSync = linearSync;
+        this.enqueueIssue = enqueueIssue;
+        this.logger = logger;
+    }
+    async syncKnownAgentSessions() {
+        for (const issue of this.db.issues.listIssues()) {
+            if (issue.factoryState === "done") {
+                continue;
+            }
+            const syncedIssue = issue.agentSessionId
+                ? issue
+                : (() => {
+                    const recoveredAgentSessionId = this.db.webhookEvents.findLatestAgentSessionIdForIssue(issue.linearIssueId);
+                    return recoveredAgentSessionId
+                        ? this.db.issues.upsertIssue({
+                            projectId: issue.projectId,
+                            linearIssueId: issue.linearIssueId,
+                            agentSessionId: recoveredAgentSessionId,
+                        })
+                        : issue;
+                })();
+            if (!syncedIssue.agentSessionId) {
+                continue;
+            }
+            const activeRun = syncedIssue.activeRunId ? this.db.runs.getRunById(syncedIssue.activeRunId) : undefined;
+            await this.linearSync.syncSession(syncedIssue, activeRun ? { activeRunType: activeRun.runType } : undefined);
+        }
+    }
+    async recoverDelegatedIssueStateFromLinear() {
+        for (const issue of this.db.issues.listIssuesWithAgentSessions()) {
+            if (issue.factoryState === "done" || issue.activeRunId !== undefined) {
+                continue;
+            }
+            const linear = await this.linearProvider.forProject(issue.projectId).catch(() => undefined);
+            if (!linear) {
+                continue;
+            }
+            const installation = this.db.linearInstallations.getLinearInstallationForProject(issue.projectId);
+            if (!installation?.actorId) {
+                continue;
+            }
+            const liveIssue = await linear.getIssue(issue.linearIssueId).catch(() => undefined);
+            if (!liveIssue) {
+                continue;
+            }
+            this.db.issues.replaceIssueDependencies({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                blockers: liveIssue.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 } : {}),
+                })),
+            });
+            const delegated = liveIssue.delegateId === installation.actorId;
+            const unresolvedBlockers = this.db.issues.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
+            const shouldRecoverAwaitingInput = delegated
+                && issue.factoryState === "awaiting_input"
+                && this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId) === undefined;
+            const updated = this.db.issues.upsertIssue({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                ...(liveIssue.identifier ? { issueKey: liveIssue.identifier } : {}),
+                ...(liveIssue.title ? { title: liveIssue.title } : {}),
+                ...(liveIssue.description ? { description: liveIssue.description } : {}),
+                ...(liveIssue.url ? { url: liveIssue.url } : {}),
+                ...(liveIssue.priority != null ? { priority: liveIssue.priority } : {}),
+                ...(liveIssue.estimate != null ? { estimate: liveIssue.estimate } : {}),
+                ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
+                ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
+                ...(shouldRecoverAwaitingInput ? { factoryState: "delegated" } : {}),
+            });
+            if (!shouldRecoverAwaitingInput) {
+                continue;
+            }
+            if (unresolvedBlockers === 0) {
+                this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+                    projectId: issue.projectId,
+                    linearIssueId: issue.linearIssueId,
+                    eventType: "delegated",
+                    dedupeKey: `delegated:${issue.linearIssueId}`,
+                });
+                if (this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
+                    this.enqueueIssue(issue.projectId, issue.linearIssueId);
+                }
+                this.logger.info({ issueKey: updated.issueKey }, "Recovered delegated issue from stale awaiting_input state and re-queued implementation");
+            }
+            else {
+                this.logger.info({ issueKey: updated.issueKey, unresolvedBlockers }, "Recovered delegated blocked issue from stale awaiting_input state");
+            }
+        }
+    }
+}