patchrelay 0.36.16 → 0.36.18

package/dist/merged-linear-completion-reconciler.js

@@ -0,0 +1,48 @@
+import { resolvePreferredCompletedLinearState } from "./linear-workflow.js";
+export class MergedLinearCompletionReconciler {
+    db;
+    linearProvider;
+    logger;
+    constructor(db, linearProvider, logger) {
+        this.db = db;
+        this.linearProvider = linearProvider;
+        this.logger = logger;
+    }
+    async reconcile() {
+        for (const issue of this.db.issues.listIssues()) {
+            if (issue.prState !== "merged")
+                continue;
+            if (issue.currentLinearStateType?.trim().toLowerCase() === "completed")
+                continue;
+            const linear = await this.linearProvider.forProject(issue.projectId).catch(() => undefined);
+            if (!linear)
+                continue;
+            try {
+                const liveIssue = await linear.getIssue(issue.linearIssueId);
+                const targetState = resolvePreferredCompletedLinearState(liveIssue);
+                if (!targetState)
+                    continue;
+                const normalizedCurrent = liveIssue.stateName?.trim().toLowerCase();
+                if (normalizedCurrent === targetState.trim().toLowerCase()) {
+                    this.db.issues.upsertIssue({
+                        projectId: issue.projectId,
+                        linearIssueId: issue.linearIssueId,
+                        ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
+                        ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
+                    });
+                    continue;
+                }
+                const updated = await linear.setIssueState(issue.linearIssueId, targetState);
+                this.db.issues.upsertIssue({
+                    projectId: issue.projectId,
+                    linearIssueId: issue.linearIssueId,
+                    ...(updated.stateName ? { currentLinearState: updated.stateName } : {}),
+                    ...(updated.stateType ? { currentLinearStateType: updated.stateType } : {}),
+                });
+            }
+            catch (error) {
+                this.logger.warn({ issueKey: issue.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to reconcile merged issue to a completed Linear state");
+            }
+        }
+    }
+}

package/dist/prompting/patchrelay.js

@@ -29,62 +29,6 @@ function readWorkflowFile(repoPath, runType) {
         return undefined;
     return readFileSync(filePath, "utf8").trim();
 }
-function collectImplementationInstructionText(issue, context, promptText) {
-    const parts = [];
-    if (issue.title)
-        parts.push(issue.title);
-    if (issue.description)
-        parts.push(issue.description);
-    if (promptText)
-        parts.push(promptText);
-    const stringFields = ["promptContext", "promptBody", "operatorPrompt", "userComment"];
-    for (const field of stringFields) {
-        const value = context?.[field];
-        if (typeof value === "string" && value.trim()) {
-            parts.push(value);
-        }
-    }
-    if (Array.isArray(context?.followUps)) {
-        for (const entry of context.followUps) {
-            if (!entry || typeof entry !== "object")
-                continue;
-            const text = entry.text;
-            if (typeof text === "string" && text.trim()) {
-                parts.push(text);
-            }
-        }
-    }
-    return parts.join("\n").toLowerCase();
-}
-export function resolveImplementationDeliveryMode(issue, context, promptText) {
-    const instructionText = collectImplementationInstructionText(issue, context, promptText);
-    if (!instructionText)
-        return "publish_pr";
-    const hasExplicitNoPr = [
-        /\bdo not open (?:a |any )?pr\b/,
-        /\bdo not open (?:a |any )?pull request\b/,
-        /\bno pr is opened\b/,
-        /\bpatchrelay should not open a pr\b/,
-        /\bwithout opening a pr\b/,
-    ].some((pattern) => pattern.test(instructionText));
-    const forbidsRepoChanges = [
-        /\bdo not make repository changes\b/,
-        /\bdo not make repo changes\b/,
-        /\bno repository changes\b/,
-        /\bno repo changes\b/,
-        /\bdo not modify repo files\b/,
-    ].some((pattern) => pattern.test(instructionText));
-    const planningOnly = [
-        /\bplanning\/specification issue only\b/,
-        /\bplanning[- ]only\b/,
-        /\bspecification[- ]only\b/,
-        /\bplanning issue only\b/,
-    ].some((pattern) => pattern.test(instructionText));
-    if (hasExplicitNoPr || (planningOnly && forbidsRepoChanges)) {
-        return "linear_only";
-    }
-    return "publish_pr";
-}
 function buildPromptHeader(issue) {
     return [
         `Issue: ${issue.issueKey ?? issue.linearIssueId}`,
@@ -338,16 +282,23 @@ function buildFollowUpPromptPrelude(issue, runType, context) {
         "",
         wakeReason === "direct_reply"
             ? "Why this turn exists: A human reply arrived for the outstanding question from the previous turn."
-            : wakeReason === "branch_upkeep"
-                ? "Why this turn exists: GitHub still shows the PR branch as needing upkeep after the requested code change was addressed."
-                : wakeReason === "followup_comment"
-                    ? "Why this turn exists: A human follow-up comment arrived after the previous turn."
-                    : `Why this turn exists: Continue the existing ${runType} run from the latest issue state.`,
+            : wakeReason === "completion_check_continue"
+                ? "Why this turn exists: The previous turn ended without a PR, and PatchRelay's completion check decided the work should continue automatically."
+                : wakeReason === "branch_upkeep"
+                    ? "Why this turn exists: GitHub still shows the PR branch as needing upkeep after the requested code change was addressed."
+                    : wakeReason === "followup_comment"
+                        ? "Why this turn exists: A human follow-up comment arrived after the previous turn."
+                        : `Why this turn exists: Continue the existing ${runType} run from the latest issue state.`,
         wakeReason === "direct_reply"
             ? "Required action now: Apply the latest human answer, continue from the current branch/session context, and publish the next concrete result."
-            : "Required action now: Continue from the latest branch state, refresh any stale assumptions, and publish the next concrete result.",
+            : wakeReason === "completion_check_continue"
+                ? "Required action now: Continue from the current branch and thread context, finish the task, and publish the next concrete result."
+                : "Required action now: Continue from the latest branch state, refresh any stale assumptions, and publish the next concrete result.",
         "",
     ];
+    if (wakeReason === "completion_check_continue" && typeof context?.completionCheckSummary === "string" && context.completionCheckSummary.trim()) {
+        lines.push(`Completion check summary: ${context.completionCheckSummary.trim()}`, "");
+    }
     if (followUpLines.length > 0) {
         lines.push("Recent updates:");
         followUpLines.forEach((line) => lines.push(`- ${line}`));
@@ -391,25 +342,13 @@ function buildWorkflowGuidance(repoPath, runType) {
     }
     return "";
 }
-function buildPublicationContract(runType, issue, context) {
-    const deliveryMode = runType === "implementation" && issue
-        ? resolveImplementationDeliveryMode(issue, context)
-        : "publish_pr";
-    if (runType === "implementation" && deliveryMode === "linear_only") {
-        return [
-            "## Delivery Requirements",
-            "",
-            "This issue is planning/specification only.",
-            "Do not modify repo files or open a PR for this issue.",
-            "Deliver the result through Linear artifacts such as follow-up issues, documents, and a concise summary.",
-            "Leave the worktree clean before stopping.",
-        ].join("\n");
-    }
+function buildPublicationContract(runType) {
     if (runType === "implementation") {
         return [
             "## Publication Requirements",
             "",
             "Before finishing, publish the result instead of leaving it only in the worktree.",
+            "If the task is genuinely complete without a PR, say so clearly in your normal summary instead of inventing one.",
             "If the worktree already contains relevant changes for this issue, verify them and publish them.",
             "If you changed files for this issue, commit them, push the issue branch, and open or update the PR before stopping.",
             "Do not stop with only local commits or uncommitted changes.",
@@ -444,7 +383,7 @@ function buildSections(issue, runType, repoPath, context, followUp = false) {
     if (workflow) {
         sections.push({ id: "workflow-guidance", content: workflow });
     }
-    sections.push({ id: "publication-contract", content: buildPublicationContract(runType, issue, context) });
+    sections.push({ id: "publication-contract", content: buildPublicationContract(runType) });
     return sections;
 }
 function filterAllowedReplacements(promptLayer) {

package/dist/public-agent-session-status-query.js

@@ -0,0 +1,52 @@
+import { extractStageSummary, summarizeCurrentThread } from "./run-reporting.js";
+import { parseStageReport } from "./issue-overview-query.js";
+export class PublicAgentSessionStatusQuery {
+    db;
+    overviewQuery;
+    constructor(db, overviewQuery) {
+        this.db = db;
+        this.overviewQuery = overviewQuery;
+    }
+    async getStatus(issueKey) {
+        const overview = await this.overviewQuery.getIssueOverview(issueKey);
+        if (!overview)
+            return undefined;
+        const issueRecord = this.db.issues.getIssueByKey(issueKey);
+        const latestRunReport = parseStageReport(overview.latestRun?.reportJson, overview.latestRun?.status ?? "unknown");
+        const runs = (overview.runs ?? this.overviewQuery.buildRuns(overview.issue.projectId, overview.issue.linearIssueId)).map((run) => ({
+            run: {
+                id: run.id,
+                runType: run.runType,
+                status: run.status,
+                startedAt: run.startedAt,
+                ...(run.endedAt ? { endedAt: run.endedAt } : {}),
+            },
+            ...(run.report ? { report: run.report } : {}),
+        }));
+        return {
+            issue: {
+                issueKey: overview.issue.issueKey,
+                title: overview.issue.title,
+                issueUrl: overview.issue.issueUrl,
+                currentLinearState: overview.issue.currentLinearState,
+                ...(overview.session?.sessionState ? { sessionState: overview.session.sessionState } : {}),
+                factoryState: overview.issue.factoryState,
+                ...(overview.session?.prNumber !== undefined ? { prNumber: overview.session.prNumber } : {}),
+                ...(issueRecord?.prUrl ? { prUrl: issueRecord.prUrl } : {}),
+                ...(issueRecord?.prState ? { prState: issueRecord.prState } : {}),
+                ...(issueRecord?.prReviewState ? { prReviewState: issueRecord.prReviewState } : {}),
+                ...(issueRecord?.prCheckStatus ? { prCheckStatus: issueRecord.prCheckStatus } : {}),
+                ...(issueRecord ? { ciRepairAttempts: issueRecord.ciRepairAttempts, queueRepairAttempts: issueRecord.queueRepairAttempts } : {}),
+                ...(overview.issue.waitingReason ? { waitingReason: overview.issue.waitingReason } : {}),
+                ...(overview.issue.statusNote ? { statusNote: overview.issue.statusNote } : {}),
+                ...(overview.session?.lastWakeReason ? { lastWakeReason: overview.session.lastWakeReason } : {}),
+            },
+            ...(overview.activeRun ? { activeRun: overview.activeRun } : {}),
+            ...(overview.latestRun ? { latestRun: overview.latestRun } : {}),
+            ...(overview.liveThread ? { liveThread: summarizeCurrentThread(overview.liveThread) } : {}),
+            ...(latestRunReport ? { latestReportSummary: extractStageSummary(latestRunReport) } : {}),
+            runs,
+            generatedAt: new Date().toISOString(),
+        };
+    }
+}

package/dist/run-completion-policy.js

@@ -1,5 +1,4 @@
 import { ACTIVE_RUN_STATES } from "./factory-state.js";
-import { resolveImplementationDeliveryMode, } from "./prompting/patchrelay.js";
 import { ImplementationOutcomePolicy } from "./implementation-outcome-policy.js";
 import { ReactiveRunPolicy } from "./reactive-run-policy.js";
 function resolvePostRunState(issue) {
@@ -12,10 +11,7 @@ function resolvePostRunState(issue) {
     }
     return undefined;
 }
-export function resolveCompletedRunState(issue, run) {
-    if (run.runType === "implementation" && resolveImplementationDeliveryMode(issue, undefined, run.promptText) === "linear_only") {
-        return "done";
-    }
+export function resolveCompletedRunState(issue, _run) {
     return resolvePostRunState(issue);
 }
 export class RunCompletionPolicy {

package/dist/run-finalizer.js

@@ -1,5 +1,5 @@
 import { buildStageReport, countEventMethods } from "./run-reporting.js";
-import { buildRunCompletedActivity, buildRunFailureActivity } from "./linear-session-reporting.js";
+import { buildCompletionCheckActivity, buildRunCompletedActivity, buildRunFailureActivity } from "./linear-session-reporting.js";
 import { resolveCompletedRunState } from "./run-completion-policy.js";
 export class RunFinalizer {
     db;
@@ -11,8 +11,9 @@ export class RunFinalizer {
     appendWakeEventWithLease;
     failRunAndClear;
     completionPolicy;
+    completionCheck;
     feed;
-    constructor(db, logger, linearSync, enqueueIssue, withHeldLease, releaseLease, appendWakeEventWithLease, failRunAndClear, completionPolicy, feed) {
+    constructor(db, logger, linearSync, enqueueIssue, withHeldLease, releaseLease, appendWakeEventWithLease, failRunAndClear, completionPolicy, completionCheck, feed) {
         this.db = db;
         this.logger = logger;
         this.linearSync = linearSync;
@@ -22,8 +23,22 @@ export class RunFinalizer {
         this.appendWakeEventWithLease = appendWakeEventWithLease;
         this.failRunAndClear = failRunAndClear;
         this.completionPolicy = completionPolicy;
+        this.completionCheck = completionCheck;
         this.feed = feed;
     }
+    buildCompletedRunUpdate(params) {
+        return {
+            status: "completed",
+            threadId: params.threadId,
+            ...(params.completedTurnId ? { turnId: params.completedTurnId } : {}),
+            summaryJson: JSON.stringify({ latestAssistantMessage: params.report.assistantMessages.at(-1) ?? null }),
+            reportJson: JSON.stringify(params.report),
+        };
+    }
+    clearProgressAndRelease(run) {
+        this.linearSync.clearProgress(run.id);
+        this.releaseLease(run.projectId, run.linearIssueId);
+    }
     async finalizeCompletedRun(params) {
         const { run, issue, thread, threadId } = params;
         const trackedIssue = this.db.issueToTrackedIssue(issue);
@@ -70,7 +85,206 @@ export class RunFinalizer {
         }
         const publishedOutcomeError = await this.completionPolicy.verifyPublishedRunOutcome(run, freshIssue);
         if (publishedOutcomeError) {
-            this.failRunAndClear(run, publishedOutcomeError, "failed");
+            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({
+                threadId,
+                ...(params.completedTurnId ? { completedTurnId: params.completedTurnId } : {}),
+                report,
+            });
+            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",
@@ -78,15 +292,13 @@ export class RunFinalizer {
                 issueKey: freshIssue.issueKey,
                 projectId: run.projectId,
                 stage: run.runType,
-                status: "publish_incomplete",
-                summary: publishedOutcomeError,
+                status: "completion_check_failed",
+                summary: "No PR found; completion check failed",
+                detail: completionCheck.summary,
             });
-            void this.linearSync.emitActivity(failedIssue, buildRunFailureActivity(run.runType, publishedOutcomeError));
+            void this.linearSync.emitActivity(failedIssue, buildRunFailureActivity(run.runType, failureReason));
             void this.linearSync.syncSession(failedIssue, { activeRunType: run.runType });
-            this.linearSync.clearProgress(run.id);
-            if (params.source === "notification") {
-                this.releaseLease(run.projectId, run.linearIssueId);
-            }
+            this.clearProgressAndRelease(run);
             return;
         }
         const refreshedIssue = await this.completionPolicy.refreshIssueAfterReactivePublish(run, freshIssue);

package/dist/run-orchestrator.js

@@ -1,7 +1,8 @@
 import { summarizeCurrentThread } from "./run-reporting.js";
 import { buildRunStartedActivity, } from "./linear-session-reporting.js";
+import { CompletionCheckService } from "./completion-check.js";
 import { WorktreeManager } from "./worktree-manager.js";
-import { resolvePreferredCompletedLinearState } from "./linear-workflow.js";
+import { MergedLinearCompletionReconciler } from "./merged-linear-completion-reconciler.js";
 import { QueueHealthMonitor } from "./queue-health-monitor.js";
 import { IdleIssueReconciler, resolveBranchOwnerForStateTransition } from "./idle-reconciliation.js";
 import { LinearSessionSync } from "./linear-session-sync.js";
@@ -49,8 +50,10 @@ export class RunOrchestrator {
     runWakePlanner;
     interruptedRunRecovery;
     runCompletionPolicy;
+    completionCheck;
     runNotificationHandler;
     runReconciler;
+    mergedLinearCompletionReconciler;
     activeSessionLeases;
     botIdentity;
     constructor(config, db, codex, linearProvider, enqueueIssue, logger, feed) {
@@ -66,7 +69,8 @@ export class RunOrchestrator {
         this.leaseService = new IssueSessionLeaseService(db, logger, this.workerId, (threadId, maxRetries) => this.readThreadWithRetry(threadId, maxRetries));
         this.activeSessionLeases = this.leaseService.activeSessionLeases;
         this.runCompletionPolicy = new RunCompletionPolicy(config, db, logger, (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn));
-        this.runFinalizer = new RunFinalizer(db, logger, this.linearSync, this.enqueueIssue, (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn), (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId), (lease, issue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, issue, runType, context, dedupeScope), (run, message, nextState) => this.failRunAndClear(run, message, nextState), this.runCompletionPolicy, feed);
+        this.completionCheck = new CompletionCheckService(codex, logger);
+        this.runFinalizer = new RunFinalizer(db, logger, this.linearSync, this.enqueueIssue, (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn), (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId), (lease, issue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, issue, runType, context, dedupeScope), (run, message, nextState) => this.failRunAndClear(run, message, nextState), this.runCompletionPolicy, this.completionCheck, feed);
         this.runLauncher = new RunLauncher(config, db, codex, logger, this.worktreeManager);
         this.runNotificationHandler = new RunNotificationHandler(config, db, logger, this.linearSync, this.runFinalizer, (threadId, maxRetries) => this.readThreadWithRetry(threadId, maxRetries), (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn), (projectId, linearIssueId) => this.heartbeatIssueSessionLease(projectId, linearIssueId), (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId), feed);
         this.runRecovery = new RunRecoveryService(db, logger, this.linearSync, (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn), (projectId, linearIssueId) => this.getHeldIssueSessionLease(projectId, linearIssueId), (lease, issue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, issue, runType, context, dedupeScope), (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId), (projectId, issueId) => this.enqueueIssue(projectId, issueId), (newState, pendingRunType) => this.resolveBranchOwnerForStateTransition(newState, pendingRunType), feed);
@@ -76,6 +80,7 @@ export class RunOrchestrator {
         this.idleReconciler = new IdleIssueReconciler(db, config, {
             enqueueIssue: (projectId, issueId) => this.enqueueIssue(projectId, issueId),
         }, logger, feed);
+        this.mergedLinearCompletionReconciler = new MergedLinearCompletionReconciler(db, linearProvider, logger);
         this.queueHealthMonitor = new QueueHealthMonitor(db, config, {
             advanceIdleIssue: (issue, newState, options) => this.idleReconciler.advanceIdleIssue(issue, newState, options),
             enqueueIssue: (projectId, issueId) => this.enqueueIssue(projectId, issueId),
@@ -251,44 +256,7 @@ export class RunOrchestrator {
         // Advance issues stuck in pr_open whose stored PR metadata already
         // shows they should transition (e.g. approved PR, missed webhook).
         await this.idleReconciler.reconcile();
-        await this.reconcileMergedLinearCompletion();
-    }
-    async reconcileMergedLinearCompletion() {
-        for (const issue of this.db.issues.listIssues()) {
-            if (issue.prState !== "merged")
-                continue;
-            if (issue.currentLinearStateType?.trim().toLowerCase() === "completed")
-                continue;
-            const linear = await this.linearProvider.forProject(issue.projectId).catch(() => undefined);
-            if (!linear)
-                continue;
-            try {
-                const liveIssue = await linear.getIssue(issue.linearIssueId);
-                const targetState = resolvePreferredCompletedLinearState(liveIssue);
-                if (!targetState)
-                    continue;
-                const normalizedCurrent = liveIssue.stateName?.trim().toLowerCase();
-                if (normalizedCurrent === targetState.trim().toLowerCase()) {
-                    this.db.issues.upsertIssue({
-                        projectId: issue.projectId,
-                        linearIssueId: issue.linearIssueId,
-                        ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
-                        ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
-                    });
-                    continue;
-                }
-                const updated = await linear.setIssueState(issue.linearIssueId, targetState);
-                this.db.issues.upsertIssue({
-                    projectId: issue.projectId,
-                    linearIssueId: issue.linearIssueId,
-                    ...(updated.stateName ? { currentLinearState: updated.stateName } : {}),
-                    ...(updated.stateType ? { currentLinearStateType: updated.stateType } : {}),
-                });
-            }
-            catch (error) {
-                this.logger.warn({ issueKey: issue.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to reconcile merged issue to a completed Linear state");
-            }
-        }
+        await this.mergedLinearCompletionReconciler.reconcile();
     }
     // advanceIdleIssue is now on IdleIssueReconciler — delegate for internal callers
     advanceIdleIssue(issue, newState, options) {

package/dist/service.js

@@ -371,10 +371,18 @@ export class PatchRelayService {
           i.last_github_failure_check_name,
           i.last_github_failure_context_json,
           active_run.run_type AS active_run_type,
+          active_run.completion_check_thread_id AS active_completion_check_thread_id,
+          active_run.completion_check_outcome AS active_completion_check_outcome,
           latest_run.run_type AS latest_run_type,
           latest_run.status AS latest_run_status,
           latest_run.summary_json AS latest_run_summary_json,
           latest_run.report_json AS latest_run_report_json,
+          latest_run.completion_check_thread_id AS latest_run_completion_check_thread_id,
+          latest_run.completion_check_outcome AS latest_run_completion_check_outcome,
+          latest_run.completion_check_summary AS latest_run_completion_check_summary,
+          latest_run.completion_check_question AS latest_run_completion_check_question,
+          latest_run.completion_check_why AS latest_run_completion_check_why,
+          latest_run.completion_check_recommended_reply AS latest_run_completion_check_recommended_reply,
           (
             SELECT COUNT(*)
             FROM issue_session_events e
@@ -470,6 +478,12 @@ export class PatchRelayService {
                     status: String(row.latest_run_status),
                     ...(typeof row.latest_run_summary_json === "string" ? { summaryJson: row.latest_run_summary_json } : {}),
                     ...(typeof row.latest_run_report_json === "string" ? { reportJson: row.latest_run_report_json } : {}),
+                    ...(typeof row.latest_run_completion_check_thread_id === "string" ? { completionCheckThreadId: row.latest_run_completion_check_thread_id } : {}),
+                    ...(typeof row.latest_run_completion_check_outcome === "string" ? { completionCheckOutcome: row.latest_run_completion_check_outcome } : {}),
+                    ...(typeof row.latest_run_completion_check_summary === "string" ? { completionCheckSummary: row.latest_run_completion_check_summary } : {}),
+                    ...(typeof row.latest_run_completion_check_question === "string" ? { completionCheckQuestion: row.latest_run_completion_check_question } : {}),
+                    ...(typeof row.latest_run_completion_check_why === "string" ? { completionCheckWhy: row.latest_run_completion_check_why } : {}),
+                    ...(typeof row.latest_run_completion_check_recommended_reply === "string" ? { completionCheckRecommendedReply: row.latest_run_completion_check_recommended_reply } : {}),
                     startedAt: String(row.updated_at),
                 }
                 : undefined;
@@ -490,6 +504,10 @@ export class PatchRelayService {
             })
                 ? undefined
                 : statusNoteCandidate;
+            const completionCheckActive = typeof row.active_completion_check_thread_id === "string"
+                && row.active_completion_check_thread_id.length > 0
+                && row.active_completion_check_outcome === null
+                && row.active_run_type !== null;
             return {
                 ...(row.issue_key !== null ? { issueKey: String(row.issue_key) } : {}),
                 ...(row.title !== null ? { title: String(row.title) } : {}),
@@ -515,6 +533,7 @@ export class PatchRelayService {
                 ...(failureContext?.stepName ? { latestFailureStepName: failureContext.stepName } : {}),
                 ...(failureContext?.summary ? { latestFailureSummary: failureContext.summary } : {}),
                 ...(waitingReason ? { waitingReason } : {}),
+                ...(completionCheckActive ? { completionCheckActive } : {}),
                 updatedAt: String(row.updated_at),
             };
         });