patchrelay 0.36.16 → 0.36.18

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.18",
+  "commit": "2d0aa4ca856e",
+  "builtAt": "2026-04-10T12:35:59.590Z"
 }

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-query-service.js

@@ -1,13 +1,13 @@
-import { extractStageSummary, summarizeCurrentThread } from "./run-reporting.js";
-import { IssueOverviewQuery, parseStageReport, } from "./issue-overview-query.js";
+import { IssueOverviewQuery, } from "./issue-overview-query.js";
+import { PublicAgentSessionStatusQuery } from "./public-agent-session-status-query.js";
 export class IssueQueryService {
-    db;
     runStatusProvider;
     overviewQuery;
+    publicStatusQuery;
     constructor(db, codex, runStatusProvider) {
-        this.db = db;
         this.runStatusProvider = runStatusProvider;
         this.overviewQuery = new IssueOverviewQuery(db, codex, runStatusProvider);
+        this.publicStatusQuery = new PublicAgentSessionStatusQuery(db, this.overviewQuery);
     }
     async getIssueOverview(issueKey) {
         return await this.overviewQuery.getIssueOverview(issueKey);
@@ -16,45 +16,6 @@ export class IssueQueryService {
         return await this.runStatusProvider.getActiveRunStatus(issueKey);
     }
     async getPublicAgentSessionStatus(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(),
-        };
+        return await this.publicStatusQuery.getStatus(issueKey);
     }
 }

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