patchrelay 0.36.16 → 0.36.17

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.36.16",
-  "commit": "f8ad93bd7a05",
-  "builtAt": "2026-04-10T04:39:43.765Z"
+  "version": "0.36.17",
+  "commit": "a9609f2ce42d",
+  "builtAt": "2026-04-10T12:32:40.306Z"
 }

package/dist/cli/data.js

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs";
 import pino from "pino";
 import { CodexAppServerClient } from "../codex-app-server.js";
+import { extractCompletionCheck } from "../completion-check.js";
 import { getThreadTurns } from "../codex-thread-utils.js";
 import { PatchRelayDatabase } from "../db.js";
 import { WorktreeManager } from "../worktree-manager.js";
@@ -57,6 +58,12 @@ function parseObjectJson(value) {
     }
 }
 function summarizeRun(run) {
+    const completionCheck = extractCompletionCheck(run);
+    if (completionCheck) {
+        return completionCheck.outcome === "needs_input"
+            ? completionCheck.question ?? completionCheck.summary
+            : completionCheck.summary;
+    }
     const summary = parseObjectJson(run.summaryJson);
     if (typeof summary?.latestAssistantMessage === "string" && summary.latestAssistantMessage.trim()) {
         return summary.latestAssistantMessage.trim();
@@ -99,7 +106,9 @@ export class CliDataAccess extends CliOperatorApiClient {
         const latestRun = this.db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
         const latestReport = normalizeStageReport(latestRun?.reportJson, latestRun?.status);
         const latestSummary = safeJsonParse(latestRun?.summaryJson);
-        const statusNote = latestReport?.assistantMessages.at(-1) ??
+        const completionCheck = latestRun ? extractCompletionCheck(latestRun) : undefined;
+        const statusNote = (completionCheck?.outcome === "needs_input" ? completionCheck.question : completionCheck?.summary) ??
+            latestReport?.assistantMessages.at(-1) ??
             (typeof latestSummary?.latestAssistantMessage === "string" ? latestSummary.latestAssistantMessage : undefined) ??
             (latestRun?.status === "failed" ? "Latest run failed." : undefined) ??
             undefined;
@@ -114,6 +123,11 @@ export class CliDataAccess extends CliOperatorApiClient {
             ...((dbIssue.sessionState) ? { sessionState: dbIssue.sessionState } : {}),
             ...((dbIssue.waitingReason) ? { waitingReason: dbIssue.waitingReason } : {}),
             ...(statusNote ? { statusNote } : {}),
+            ...(completionCheck?.outcome ? { completionCheckOutcome: completionCheck.outcome } : {}),
+            ...(completionCheck?.summary ? { completionCheckSummary: completionCheck.summary } : {}),
+            ...(completionCheck?.question ? { completionCheckQuestion: completionCheck.question } : {}),
+            ...(completionCheck?.why ? { completionCheckWhy: completionCheck.why } : {}),
+            ...(completionCheck?.recommendedReply ? { completionCheckRecommendedReply: completionCheck.recommendedReply } : {}),
         };
     }
     async live(issueKey) {

package/dist/cli/formatters/text.js

@@ -21,6 +21,11 @@ export function formatInspect(result) {
         result.activeRun ? value("Active run", `${result.activeRun.runType} (${result.activeRun.status})`) : undefined,
         result.latestRun && !result.activeRun ? value("Latest run", `${result.latestRun.runType} (${result.latestRun.status})`) : undefined,
         result.prNumber ? value("PR", `#${result.prNumber}${result.prReviewState ? ` [${result.prReviewState}]` : ""}`) : undefined,
+        result.completionCheckOutcome ? value("Completion check", result.completionCheckOutcome) : undefined,
+        result.completionCheckSummary ? value("Completion summary", truncateLine(result.completionCheckSummary)) : undefined,
+        result.completionCheckQuestion ? value("Question", truncateLine(result.completionCheckQuestion)) : undefined,
+        result.completionCheckWhy ? value("Why", truncateLine(result.completionCheckWhy)) : undefined,
+        result.completionCheckRecommendedReply ? value("Suggested reply", truncateLine(result.completionCheckRecommendedReply)) : undefined,
         result.statusNote ? value("Status", truncateLine(result.statusNote)) : undefined,
     ].filter(Boolean);
     return `${lines.join("\n")}\n`;

package/dist/cli/watch/IssueRow.js

@@ -13,6 +13,8 @@ function effectiveState(issue) {
         return "done";
     if (issue.sessionState === "failed")
         return "failed";
+    if (issue.completionCheckActive)
+        return "completion_check";
     if (issue.blockedByCount > 0 && !issue.activeRunType)
         return "blocked";
     if (issue.sessionState === "waiting_input")
@@ -49,6 +51,7 @@ function stageLabel(issue) {
         case "ready": return "ready";
         case "delegated": return "delegated";
         case "implementing": return "implementing";
+        case "completion_check": return "completion check";
         case "pr_open": return "PR open";
         case "changes_requested": return "review changes";
         case "repairing_ci": return "repairing CI";
@@ -116,6 +119,8 @@ function blockerText(issue) {
         return issue.waitingReason ?? "Waiting for input";
     if (needsOperatorIntervention(issue))
         return issue.statusNote ?? issue.waitingReason ?? "Needs operator intervention";
+    if (issue.completionCheckActive)
+        return "No PR found; checking next step";
     if (issue.waitingReason && issue.activeRunType && issue.factoryState === "pr_open")
         return issue.waitingReason;
     if (issue.waitingReason && issue.activeRunType && issue.factoryState === "awaiting_queue")

package/dist/cli/watch/detail-rows.js

@@ -17,6 +17,7 @@ const STAGE_DISPLAY = {
     ready: "ready",
     delegated: "delegated",
     implementing: "implementing",
+    completion_check: "completion check",
     pr_open: "PR open",
     changes_requested: "review changes",
     repairing_ci: "repairing CI",
@@ -513,6 +514,8 @@ function effectiveState(issue) {
         return "done";
     if (issue.sessionState === "failed")
         return "failed";
+    if (issue.completionCheckActive)
+        return "completion_check";
     if (issue.blockedByCount > 0 && !issue.activeRunType)
         return "blocked";
     if (issue.sessionState === "waiting_input")
@@ -527,6 +530,8 @@ function blockerText(issue, issueContext) {
     const rereviewNeeded = isRereviewNeeded(issue);
     if (issue.sessionState === "waiting_input")
         return issue.waitingReason ?? "Waiting for input";
+    if (issue.completionCheckActive)
+        return "No PR found; checking next step";
     if (issue.sessionState === "failed" || issue.factoryState === "failed" || issue.factoryState === "escalated") {
         return issue.statusNote ?? issue.waitingReason ?? "Needs operator intervention";
     }

package/dist/codex-app-server.js

@@ -1,6 +1,14 @@
 import { EventEmitter } from "node:events";
 import { spawn } from "node:child_process";
+import { tmpdir } from "node:os";
 import { sanitizeDiagnosticText } from "./utils.js";
+const COMPLETION_CHECK_DEVELOPER_INSTRUCTIONS = [
+    "You are PatchRelay's completion check.",
+    "This is a read-only follow-up used only to decide what should happen after a task ended without a PR.",
+    "Do not run commands, do not call tools, do not edit files, and do not inspect or modify the repository.",
+    "Use only the prior thread context and the facts in the current prompt.",
+    "Return only the requested JSON object.",
+].join("\n");
 export function resolveCodexAppServerLaunch(config) {
     if (!config.sourceBashrc) {
         return {
@@ -165,16 +173,16 @@ export class CodexAppServerClient extends EventEmitter {
         const response = (await this.sendRequest("thread/resume", params));
         return this.mapThread(response.thread);
     }
-    async forkThread(threadId, cwd) {
+    async forkThread(threadId, cwd, overrides) {
         const params = {
             threadId,
-            cwd: cwd ?? null,
-            approvalPolicy: this.config.approvalPolicy,
-            sandbox: this.config.sandboxMode,
-            model: this.config.model ?? null,
-            modelProvider: this.config.modelProvider ?? null,
-            baseInstructions: this.config.baseInstructions ?? null,
-            developerInstructions: this.config.developerInstructions ?? null,
+            cwd: overrides?.cwd ?? cwd ?? null,
+            approvalPolicy: overrides?.approvalPolicy ?? this.config.approvalPolicy,
+            sandbox: overrides?.sandboxMode ?? this.config.sandboxMode,
+            model: overrides?.model ?? this.config.model ?? null,
+            modelProvider: overrides?.modelProvider ?? this.config.modelProvider ?? null,
+            baseInstructions: overrides?.baseInstructions ?? this.config.baseInstructions ?? null,
+            developerInstructions: overrides?.developerInstructions ?? this.config.developerInstructions ?? null,
         };
         if (this.config.persistExtendedHistory) {
             this.logger.warn("persistExtendedHistory is requested but not enabled in the active app-server capability handshake; ignoring");
@@ -182,6 +190,13 @@ export class CodexAppServerClient extends EventEmitter {
         const response = (await this.sendRequest("thread/fork", params));
         return this.mapThread(response.thread);
     }
+    async forkThreadForCompletionCheck(threadId) {
+        return await this.forkThread(threadId, tmpdir(), {
+            approvalPolicy: "never",
+            sandboxMode: "read-only",
+            developerInstructions: COMPLETION_CHECK_DEVELOPER_INSTRUCTIONS,
+        });
+    }
     async startTurn(options) {
         const response = (await this.sendRequest("turn/start", {
             threadId: options.threadId,

package/dist/completion-check-types.js

@@ -0,0 +1 @@
+export {};

package/dist/completion-check.js

@@ -0,0 +1,143 @@
+import { getThreadTurns } from "./codex-thread-utils.js";
+import { extractLatestAssistantSummary } from "./issue-session-events.js";
+import { sanitizeOperatorFacingText } from "./presentation-text.js";
+import { extractFirstJsonObject, safeJsonParse } from "./utils.js";
+const COMPLETION_CHECK_TIMEOUT_MS = 90_000;
+const COMPLETION_CHECK_POLL_MS = 1_000;
+export function extractCompletionCheck(run) {
+    if (!run?.completionCheckOutcome || !run.completionCheckSummary) {
+        return undefined;
+    }
+    return {
+        outcome: run.completionCheckOutcome,
+        summary: run.completionCheckSummary,
+        ...(run.completionCheckQuestion ? { question: run.completionCheckQuestion } : {}),
+        ...(run.completionCheckWhy ? { why: run.completionCheckWhy } : {}),
+        ...(run.completionCheckRecommendedReply ? { recommendedReply: run.completionCheckRecommendedReply } : {}),
+    };
+}
+export class CompletionCheckService {
+    codex;
+    logger;
+    constructor(codex, logger) {
+        this.codex = codex;
+        this.logger = logger;
+    }
+    async run(params) {
+        const threadId = params.run.threadId;
+        if (!threadId) {
+            return {
+                outcome: "failed",
+                summary: "No PR was found, and PatchRelay could not run the completion check because the main thread is missing.",
+                threadId: "missing-thread",
+                turnId: "missing-turn",
+            };
+        }
+        const fork = await this.codex.forkThreadForCompletionCheck(threadId);
+        const turn = await this.codex.startTurn({
+            threadId: fork.id,
+            ...(fork.cwd ? { cwd: fork.cwd } : {}),
+            input: buildCompletionCheckPrompt(params),
+        });
+        await params.onStarted?.({ threadId: fork.id, turnId: turn.turnId });
+        const completedThread = await this.waitForTurn(fork.id, turn.turnId);
+        const completedTurn = getThreadTurns(completedThread).find((entry) => entry.id === turn.turnId);
+        const latestMessage = completedTurn?.items
+            .filter((item) => item.type === "agentMessage")
+            .at(-1)?.text;
+        const parsed = parseCompletionCheckResult(latestMessage);
+        if (!parsed) {
+            this.logger.warn({ runId: params.run.id, issueKey: params.issue.issueKey, threadId: fork.id, turnId: turn.turnId }, "Completion check returned invalid JSON");
+            return {
+                outcome: "failed",
+                summary: "No PR was found, and the completion check returned an invalid result.",
+                threadId: fork.id,
+                turnId: turn.turnId,
+            };
+        }
+        return {
+            ...parsed,
+            threadId: fork.id,
+            turnId: turn.turnId,
+        };
+    }
+    async waitForTurn(threadId, turnId) {
+        const deadline = Date.now() + COMPLETION_CHECK_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            const thread = await this.codex.readThread(threadId, true);
+            const turn = getThreadTurns(thread).find((entry) => entry.id === turnId);
+            if (turn?.status === "completed") {
+                return thread;
+            }
+            if (turn?.status === "failed" || turn?.status === "interrupted") {
+                throw new Error(`Completion check turn ${turnId} ended with status ${turn.status}`);
+            }
+            await new Promise((resolve) => setTimeout(resolve, COMPLETION_CHECK_POLL_MS));
+        }
+        throw new Error(`Completion check timed out after ${COMPLETION_CHECK_TIMEOUT_MS}ms`);
+    }
+}
+function buildCompletionCheckPrompt(params) {
+    const latestSummary = extractLatestAssistantSummary(params.run);
+    return [
+        "PatchRelay completion check",
+        "",
+        "The main task run finished without a linked PR.",
+        "This is a read-only check. Do not run commands, call tools, edit files, or inspect the repository.",
+        "Return exactly one JSON object and no extra prose.",
+        "",
+        "Schema:",
+        '{',
+        '  "outcome": "continue" | "needs_input" | "done" | "failed",',
+        '  "summary": "short operator-facing summary",',
+        '  "question": "required only for needs_input",',
+        '  "why": "optional explanation",',
+        '  "recommendedReply": "optional suggested reply for needs_input"',
+        '}',
+        "",
+        "Choose:",
+        '- "continue" if PatchRelay should keep working automatically on the same thread.',
+        '- "needs_input" if a human must answer a concrete question before work can continue.',
+        '- "done" if the task was successfully completed without a PR.',
+        '- "failed" if the run stopped incorrectly and PatchRelay should not auto-continue.',
+        "",
+        "Facts:",
+        `- Issue: ${params.issue.issueKey ?? params.issue.linearIssueId}`,
+        ...(params.issue.title ? [`- Title: ${params.issue.title}`] : []),
+        `- Run type: ${params.run.runType}`,
+        `- No-PR summary: ${sanitizeOperatorFacingText(params.noPrSummary)}`,
+        ...(latestSummary ? [`- Latest assistant summary: ${sanitizeOperatorFacingText(latestSummary)}`] : []),
+        ...(params.run.failureReason ? [`- Failure reason: ${sanitizeOperatorFacingText(params.run.failureReason)}`] : []),
+        ...(params.issue.description ? ["", "Issue description:", params.issue.description] : []),
+    ].join("\n");
+}
+function parseCompletionCheckResult(text) {
+    const raw = sanitizeOperatorFacingText(text);
+    if (!raw)
+        return undefined;
+    const candidate = safeJsonParse(raw) ?? safeJsonParse(extractFirstJsonObject(raw) ?? "");
+    if (!candidate)
+        return undefined;
+    const outcome = typeof candidate.outcome === "string" ? candidate.outcome : undefined;
+    const summary = typeof candidate.summary === "string" ? sanitizeOperatorFacingText(candidate.summary) : undefined;
+    const question = typeof candidate.question === "string" ? sanitizeOperatorFacingText(candidate.question) : undefined;
+    const why = typeof candidate.why === "string" ? sanitizeOperatorFacingText(candidate.why) : undefined;
+    const recommendedReply = typeof candidate.recommendedReply === "string"
+        ? sanitizeOperatorFacingText(candidate.recommendedReply)
+        : undefined;
+    if (!summary)
+        return undefined;
+    if (outcome !== "continue" && outcome !== "needs_input" && outcome !== "done" && outcome !== "failed") {
+        return undefined;
+    }
+    if (outcome === "needs_input" && !question) {
+        return undefined;
+    }
+    return {
+        outcome,
+        summary,
+        ...(question ? { question } : {}),
+        ...(why ? { why } : {}),
+        ...(recommendedReply ? { recommendedReply } : {}),
+    };
+}

package/dist/db/migrations.js

@@ -45,6 +45,14 @@ CREATE TABLE IF NOT EXISTS runs (
   thread_id TEXT,
   turn_id TEXT,
   parent_thread_id TEXT,
+  completion_check_thread_id TEXT,
+  completion_check_turn_id TEXT,
+  completion_check_outcome TEXT,
+  completion_check_summary TEXT,
+  completion_check_question TEXT,
+  completion_check_why TEXT,
+  completion_check_recommended_reply TEXT,
+  completion_checked_at TEXT,
   summary_json TEXT,
   report_json TEXT,
   failure_reason TEXT,
@@ -244,6 +252,14 @@ export function runPatchRelayMigrations(connection) {
     // Preserve the PR head SHA seen when a run started so PatchRelay can
     // verify that requested-changes work actually published a new head.
     addColumnIfMissing(connection, "runs", "source_head_sha", "TEXT");
+    addColumnIfMissing(connection, "runs", "completion_check_thread_id", "TEXT");
+    addColumnIfMissing(connection, "runs", "completion_check_turn_id", "TEXT");
+    addColumnIfMissing(connection, "runs", "completion_check_outcome", "TEXT");
+    addColumnIfMissing(connection, "runs", "completion_check_summary", "TEXT");
+    addColumnIfMissing(connection, "runs", "completion_check_question", "TEXT");
+    addColumnIfMissing(connection, "runs", "completion_check_why", "TEXT");
+    addColumnIfMissing(connection, "runs", "completion_check_recommended_reply", "TEXT");
+    addColumnIfMissing(connection, "runs", "completion_checked_at", "TEXT");
     addColumnIfMissing(connection, "issues", "last_blocking_review_head_sha", "TEXT");
     // Collapse awaiting_review into pr_open (state normalization)
     connection.prepare("UPDATE issues SET factory_state = 'pr_open' WHERE factory_state = 'awaiting_review'").run();

package/dist/db/run-store.js

@@ -102,6 +102,38 @@ export class RunStore {
             });
         }
     }
+    saveCompletionCheck(runId, params) {
+        this.connection.prepare(`
+      UPDATE runs SET
+        completion_check_thread_id = COALESCE(?, completion_check_thread_id),
+        completion_check_turn_id = COALESCE(?, completion_check_turn_id),
+        completion_check_outcome = ?,
+        completion_check_summary = ?,
+        completion_check_question = ?,
+        completion_check_why = ?,
+        completion_check_recommended_reply = ?,
+        completion_checked_at = ?
+      WHERE id = ?
+    `).run(params.threadId ?? null, params.turnId ?? null, params.outcome, params.summary, params.question ?? null, params.why ?? null, params.recommendedReply ?? null, isoNow(), runId);
+    }
+    markCompletionCheckStarted(runId, params) {
+        this.connection.prepare(`
+      UPDATE runs SET
+        completion_check_thread_id = ?,
+        completion_check_turn_id = ?,
+        completion_checked_at = NULL
+      WHERE id = ?
+    `).run(params.threadId, params.turnId, runId);
+        const run = this.getRunById(runId);
+        if (!run)
+            return;
+        const issue = this.issues.getIssue(run.projectId, run.linearIssueId);
+        if (issue) {
+            this.syncIssueSessionFromIssue(issue, {
+                lastRunType: run.runType,
+            });
+        }
+    }
     saveThreadEvent(params) {
         this.connection.prepare(`
       INSERT INTO run_thread_events (run_id, thread_id, turn_id, method, event_json, created_at)

package/dist/db.js

@@ -267,6 +267,14 @@ function mapRunRow(row) {
         ...(row.thread_id !== null ? { threadId: String(row.thread_id) } : {}),
         ...(row.turn_id !== null ? { turnId: String(row.turn_id) } : {}),
         ...(row.parent_thread_id !== null ? { parentThreadId: String(row.parent_thread_id) } : {}),
+        ...(row.completion_check_thread_id !== null ? { completionCheckThreadId: String(row.completion_check_thread_id) } : {}),
+        ...(row.completion_check_turn_id !== null ? { completionCheckTurnId: String(row.completion_check_turn_id) } : {}),
+        ...(row.completion_check_outcome !== null ? { completionCheckOutcome: String(row.completion_check_outcome) } : {}),
+        ...(row.completion_check_summary !== null ? { completionCheckSummary: String(row.completion_check_summary) } : {}),
+        ...(row.completion_check_question !== null ? { completionCheckQuestion: String(row.completion_check_question) } : {}),
+        ...(row.completion_check_why !== null ? { completionCheckWhy: String(row.completion_check_why) } : {}),
+        ...(row.completion_check_recommended_reply !== null ? { completionCheckRecommendedReply: String(row.completion_check_recommended_reply) } : {}),
+        ...(row.completion_checked_at !== null ? { completionCheckedAt: String(row.completion_checked_at) } : {}),
         ...(row.summary_json !== null ? { summaryJson: String(row.summary_json) } : {}),
         ...(row.report_json !== null ? { reportJson: String(row.report_json) } : {}),
         ...(row.failure_reason !== null ? { failureReason: String(row.failure_reason) } : {}),

package/dist/implementation-outcome-policy.js

@@ -1,5 +1,4 @@
 import { execCommand } from "./utils.js";
-import { resolveImplementationDeliveryMode, } from "./prompting/patchrelay.js";
 export class ImplementationOutcomePolicy {
     config;
     db;
@@ -17,13 +16,6 @@ export class ImplementationOutcomePolicy {
         }
         const project = this.config.projects.find((entry) => entry.id === run.projectId);
         const baseBranch = project?.github?.baseBranch ?? "main";
-        const deliveryMode = resolveImplementationDeliveryMode(issue, undefined, run.promptText);
-        if (deliveryMode === "linear_only") {
-            if (issue.prNumber !== undefined) {
-                return `Planning-only implementation should not open a PR, but PR #${issue.prNumber} was observed`;
-            }
-            return this.describeLocalImplementationOutcome(issue, baseBranch, deliveryMode);
-        }
         if (issue.prNumber && issue.prState && issue.prState !== "closed") {
             return undefined;
         }
@@ -67,7 +59,7 @@ export class ImplementationOutcomePolicy {
                 }, "Failed to verify published PR state after implementation");
             }
         }
-        const details = await this.describeLocalImplementationOutcome(issue, baseBranch, deliveryMode);
+        const details = await this.describeLocalImplementationOutcome(issue, baseBranch);
         return details ?? `Implementation completed without opening a PR for branch ${issue.branchName ?? issue.linearIssueId}`;
     }
     upsertIssueIfLeaseHeld(projectId, linearIssueId, params, context) {
@@ -77,7 +69,7 @@ export class ImplementationOutcomePolicy {
         }
         return updated;
     }
-    async describeLocalImplementationOutcome(issue, baseBranch, deliveryMode = "publish_pr") {
+    async describeLocalImplementationOutcome(issue, baseBranch) {
         if (!issue.worktreePath) {
             return undefined;
         }
@@ -92,9 +84,6 @@ export class ImplementationOutcomePolicy {
                 ? status.stdout.split("\n").map((line) => line.trim()).filter(Boolean)
                 : [];
             if (dirtyEntries.length > 0) {
-                if (deliveryMode === "linear_only") {
-                    return `Planning-only implementation should not modify the repo; worktree still has ${dirtyEntries.length} uncommitted change(s)`;
-                }
                 return `Implementation completed without opening a PR; worktree still has ${dirtyEntries.length} uncommitted change(s)`;
             }
         }
@@ -112,9 +101,6 @@ export class ImplementationOutcomePolicy {
             if (ahead.exitCode === 0) {
                 const count = Number(ahead.stdout.trim());
                 if (Number.isFinite(count) && count > 0) {
-                    if (deliveryMode === "linear_only") {
-                        return `Planning-only implementation should not create repo commits; worktree is ${count} local commit(s) ahead of origin/${baseBranch}`;
-                    }
                     return `Implementation completed with ${count} local commit(s) ahead of origin/${baseBranch} but no PR was observed`;
                 }
             }

package/dist/issue-session-events.js

@@ -6,6 +6,10 @@ const TERMINAL_SESSION_EVENTS = new Set([
     "pr_closed",
     "pr_merged",
 ]);
+const RUN_TYPES = new Set(["implementation", "review_fix", "branch_upkeep", "ci_repair", "queue_repair"]);
+function parseRunType(value) {
+    return typeof value === "string" && RUN_TYPES.has(value) ? value : undefined;
+}
 export function deriveSessionWakePlan(issue, events) {
     if (events.length === 0)
         return undefined;
@@ -70,6 +74,19 @@ export function deriveSessionWakePlan(issue, events) {
                 resumeThread = true;
                 break;
             }
+            case "completion_check_continue": {
+                if (!runType) {
+                    runType = parseRunType(payload?.runType)
+                        ?? (issue.prReviewState === "changes_requested" ? "review_fix" : "implementation");
+                    wakeReason = "completion_check_continue";
+                }
+                if (typeof payload?.summary === "string" && payload.summary.trim()) {
+                    context.completionCheckSummary = payload.summary.trim();
+                }
+                context.completionCheckMode = true;
+                resumeThread = true;
+                break;
+            }
             case "followup_prompt":
             case "followup_comment":
             case "operator_prompt": {

package/dist/linear-session-reporting.js

@@ -115,6 +115,28 @@ export function buildRunFailureActivity(runType, reason) {
         body: reason ? `${label} failed.\n\n${reason}` : `${label} failed.`,
     };
 }
+export function buildCompletionCheckActivity(phase, result) {
+    switch (phase) {
+        case "started":
+            return { type: "thought", body: "No PR found; checking the next step." };
+        case "continue":
+            return { type: "thought", body: "No PR found; PatchRelay is continuing automatically." };
+        case "needs_input":
+            return {
+                type: "response",
+                body: result?.question
+                    ? `PatchRelay needs an answer before it can continue.\n\nQuestion: ${result.question}${result.why ? `\n\nWhy: ${result.why}` : ""}${result.recommendedReply ? `\n\nSuggested reply: ${result.recommendedReply}` : ""}`
+                    : "PatchRelay needs more input before it can continue.",
+            };
+        case "done":
+            return {
+                type: "response",
+                body: result?.summary
+                    ? `Completed without a PR.\n\n${result.summary}`
+                    : "Completed without a PR.",
+            };
+    }
+}
 export function buildStopConfirmationActivity() {
     return {
         type: "response",

package/dist/linear-session-sync.js

@@ -1,3 +1,4 @@
+import { extractCompletionCheck } from "./completion-check.js";
 import { buildAgentSessionPlanForIssue } from "./agent-session-plan.js";
 import { buildAgentSessionExternalUrls } from "./agent-session-presentation.js";
 import { deriveIssueStatusNote } from "./status-note.js";
@@ -326,6 +327,17 @@ function renderStatusComment(db, issue, trackedIssue, options) {
                 : "Note";
         lines.push("", `${label}: ${statusNote}`);
     }
+    const completionCheck = extractCompletionCheck(latestRun);
+    if (completionCheck?.outcome === "needs_input") {
+        if (completionCheck.why) {
+            lines.push("", `Why: ${completionCheck.why}`);
+        }
+        if (completionCheck.recommendedReply) {
+            lines.push("", `Suggested reply: ${completionCheck.recommendedReply}`);
+        }
+        const issueRef = issue.issueKey ?? issue.linearIssueId;
+        lines.push("", `Reply in a Linear comment to continue, or run \`patchrelay issue prompt ${issueRef} "..."\`.`);
+    }
     if (issue.prNumber !== undefined || issue.prUrl) {
         const prLabel = issue.prNumber !== undefined ? `#${issue.prNumber}` : "open";
         lines.push("", `PR: ${issue.prUrl ? `[${prLabel}](${issue.prUrl})` : prLabel}`);
@@ -335,6 +347,9 @@ function renderStatusComment(db, issue, trackedIssue, options) {
         if (latestRun.failureReason) {
             lines.push("", `Failure: ${latestRun.failureReason}`);
         }
+        if (completionCheck && completionCheck.outcome !== "needs_input" && completionCheck.summary !== statusNote) {
+            lines.push("", `Completion check: ${completionCheck.summary}`);
+        }
     }
     if (issue.lastGitHubFailureCheckName && (issue.factoryState === "repairing_ci" || issue.prCheckStatus === "failed" || issue.prCheckStatus === "failure")) {
         lines.push("", `Latest failing check: ${issue.lastGitHubFailureCheckName}`);

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/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,5 +1,6 @@
 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 { QueueHealthMonitor } from "./queue-health-monitor.js";
@@ -49,6 +50,7 @@ export class RunOrchestrator {
     runWakePlanner;
     interruptedRunRecovery;
     runCompletionPolicy;
+    completionCheck;
     runNotificationHandler;
     runReconciler;
     activeSessionLeases;
@@ -66,7 +68,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);

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),
             };
         });

package/dist/status-note.js

@@ -1,3 +1,4 @@
+import { extractCompletionCheck } from "./completion-check.js";
 import { extractLatestAssistantSummary } from "./issue-session-events.js";
 import { sanitizeOperatorFacingText } from "./presentation-text.js";
 function clean(value) {
@@ -27,26 +28,41 @@ export function deriveIssueStatusNote(params) {
         return `Blocked by ${blockedByKeys.join(", ")}`;
     }
     const sessionSummary = clean(params.sessionSummary);
+    const completionCheckActive = Boolean(params.latestRun?.status === "running"
+        && params.latestRun.completionCheckThreadId
+        && !params.latestRun.completionCheckOutcome);
+    const completionCheck = extractCompletionCheck(params.latestRun);
+    const completionCheckNote = clean(completionCheck?.outcome === "needs_input"
+        ? completionCheck.question ?? completionCheck.summary
+        : completionCheck?.summary);
     const latestRunNote = clean(extractLatestAssistantSummary(params.latestRun));
     const latestEventNote = clean(eventStatusNote(params.latestEvent));
     const failureSummary = clean(params.failureSummary);
     const waitingReason = clean(params.waitingReason);
     let note;
-    switch (params.issue.factoryState) {
-        case "awaiting_input":
-            note = latestRunNote ?? latestEventNote ?? sessionSummary;
-            break;
-        case "failed":
-        case "escalated":
-            note = latestEventNote ?? failureSummary ?? latestRunNote ?? sessionSummary;
-            break;
-        case "repairing_ci":
-        case "repairing_queue":
-            note = failureSummary ?? sessionSummary ?? latestRunNote;
-            break;
-        default:
-            note = sessionSummary ?? latestRunNote ?? failureSummary;
-            break;
+    if (completionCheckActive) {
+        note = "No PR found; checking next step";
+    }
+    else {
+        switch (params.issue.factoryState) {
+            case "awaiting_input":
+                note = completionCheckNote ?? latestRunNote ?? latestEventNote ?? sessionSummary;
+                break;
+            case "failed":
+            case "escalated":
+                note = latestEventNote ?? completionCheckNote ?? failureSummary ?? latestRunNote ?? sessionSummary;
+                break;
+            case "done":
+                note = completionCheckNote ?? sessionSummary ?? latestRunNote ?? failureSummary;
+                break;
+            case "repairing_ci":
+            case "repairing_queue":
+                note = failureSummary ?? sessionSummary ?? latestRunNote;
+                break;
+            default:
+                note = sessionSummary ?? latestRunNote ?? failureSummary;
+                break;
+        }
     }
     if (!note)
         return undefined;

package/dist/tracked-issue-projector.js

@@ -30,6 +30,11 @@ export function buildTrackedIssueRecord(params) {
         blockedByKeys,
         waitingReason,
     });
+    const completionCheckActive = Boolean(params.issue.activeRunId !== undefined
+        && params.latestRun?.id === params.issue.activeRunId
+        && params.latestRun.status === "running"
+        && params.latestRun.completionCheckThreadId
+        && !params.latestRun.completionCheckOutcome);
     return {
         id: params.issue.id,
         projectId: params.issue.projectId,
@@ -62,6 +67,7 @@ export function buildTrackedIssueRecord(params) {
         ...(failureContext?.stepName ? { latestFailureStepName: failureContext.stepName } : {}),
         ...(failureContext?.summary ? { latestFailureSummary: failureContext.summary } : {}),
         ...(waitingReason ? { waitingReason } : {}),
+        ...(completionCheckActive ? { completionCheckActive } : {}),
         ...(params.issue.activeRunId !== undefined ? { activeRunId: params.issue.activeRunId } : {}),
         ...(params.issue.agentSessionId ? { activeAgentSessionId: params.issue.agentSessionId } : {}),
         updatedAt: params.issue.updatedAt,

package/package.json

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