patchrelay 0.51.0 → 0.51.2

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.51.0",
-  "commit": "c8ad40f06a1c",
-  "builtAt": "2026-04-21T21:25:15.871Z"
+  "version": "0.51.2",
+  "commit": "525db768a1e0",
+  "builtAt": "2026-04-22T03:51:24.647Z"
 }

package/dist/cli/data.js

@@ -70,6 +70,9 @@ function summarizeRun(run) {
             : completionCheck.summary;
     }
     const summary = parseObjectJson(run.summaryJson);
+    if (typeof summary?.publicationRecapSummary === "string" && summary.publicationRecapSummary.trim()) {
+        return summary.publicationRecapSummary.trim();
+    }
     if (typeof summary?.latestAssistantMessage === "string" && summary.latestAssistantMessage.trim()) {
         return summary.latestAssistantMessage.trim();
     }

package/dist/codex-app-server.js

@@ -9,6 +9,14 @@ const COMPLETION_CHECK_DEVELOPER_INSTRUCTIONS = [
     "Use only the prior thread context and the facts in the current prompt.",
     "Return only the requested JSON object.",
 ].join("\n");
+const PUBLICATION_RECAP_DEVELOPER_INSTRUCTIONS = [
+    "You are PatchRelay's publication recap helper.",
+    "This is a read-only follow-up used only to produce one concise Linear-visible summary for a successful run.",
+    "Keep reasoning light and concise.",
+    "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 {
@@ -210,6 +218,14 @@ export class CodexAppServerClient extends EventEmitter {
             developerInstructions: COMPLETION_CHECK_DEVELOPER_INSTRUCTIONS,
         });
     }
+    async forkThreadForPublicationRecap(threadId) {
+        return await this.forkThread(threadId, tmpdir(), {
+            approvalPolicy: "never",
+            sandboxMode: "read-only",
+            reasoningEffort: "low",
+            developerInstructions: PUBLICATION_RECAP_DEVELOPER_INSTRUCTIONS,
+        });
+    }
     async startTurn(options) {
         const response = (await this.sendRequest("turn/start", {
             threadId: options.threadId,

package/dist/issue-session-events.js

@@ -149,6 +149,9 @@ export function extractLatestAssistantSummary(run) {
     if (run.summaryJson) {
         try {
             const parsed = JSON.parse(run.summaryJson);
+            if (typeof parsed.publicationRecapSummary === "string" && parsed.publicationRecapSummary.trim()) {
+                return sanitizeOperatorFacingText(parsed.publicationRecapSummary);
+            }
             if (typeof parsed.latestAssistantMessage === "string" && parsed.latestAssistantMessage.trim()) {
                 return sanitizeOperatorFacingText(parsed.latestAssistantMessage);
             }

package/dist/main-branch-health-monitor.js

@@ -2,6 +2,13 @@ import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
 import { buildMainRepairBranchName, buildMainRepairDescription, buildMainRepairPromptContext, buildMainRepairTitle, isMainRepairIssue, } from "./main-repair.js";
 import { execCommand } from "./utils.js";
 const MAIN_BRANCH_HEALTH_GRACE_MS = 120_000;
+function isUnhealthyMainConclusion(conclusion) {
+    return conclusion === "failure"
+        || conclusion === "timed_out"
+        || conclusion === "cancelled"
+        || conclusion === "action_required"
+        || conclusion === "stale";
+}
 export class MainBranchHealthMonitor {
     db;
     config;
@@ -36,17 +43,20 @@ export class MainBranchHealthMonitor {
             && issue.factoryState !== "done"
             && issue.factoryState !== "failed"
             && issue.factoryState !== "escalated"));
+        const summary = await this.readMainBranchFailure(project.github.repoFullName, baseBranch);
+        if (!summary) {
+            if (existing) {
+                this.resolveRecoveredMainRepair(existing);
+            }
+            return;
+        }
+        const protocol = resolveMergeQueueProtocol(project);
         if (existing) {
             const age = Date.now() - Date.parse(existing.updatedAt);
             if (age < MAIN_BRANCH_HEALTH_GRACE_MS) {
                 return;
             }
         }
-        const summary = await this.readMainBranchFailure(project.github.repoFullName, baseBranch);
-        if (!summary) {
-            return;
-        }
-        const protocol = resolveMergeQueueProtocol(project);
         if (existing) {
             this.queueExistingMainRepair(existing, summary, protocol.priorityLabel);
             return;
@@ -128,6 +138,29 @@ export class MainBranchHealthMonitor {
             this.enqueueIssue(issue.projectId, issue.linearIssueId);
         }
     }
+    resolveRecoveredMainRepair(issue) {
+        if (issue.activeRunId !== undefined)
+            return;
+        if (issue.prState === "open" || issue.factoryState === "awaiting_queue" || issue.factoryState === "pr_open") {
+            return;
+        }
+        this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(issue.projectId, issue.linearIssueId);
+        this.db.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            factoryState: "done",
+            pendingRunType: null,
+        });
+        this.feed?.publish({
+            level: "info",
+            kind: "github",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: "done",
+            status: "main_repair_resolved",
+            summary: "Closed stale main_repair after main recovered externally",
+        });
+    }
     async readMainBranchFailure(repoFullName, baseBranch) {
         const { stdout: shaOut } = await execCommand("gh", [
             "api",
@@ -146,7 +179,7 @@ export class MainBranchHealthMonitor {
         ], { timeoutMs: 10_000 });
         const runs = JSON.parse(checksOut || "[]");
         const failingChecks = runs
-            .filter((run) => run.status === "completed" && run.conclusion === "failure" && typeof run.name === "string" && run.name.trim())
+            .filter((run) => run.status === "completed" && isUnhealthyMainConclusion(run.conclusion) && typeof run.name === "string" && run.name.trim())
             .map((run) => ({ name: run.name.trim(), ...(run.details_url ? { url: run.details_url } : {}) }));
         if (failingChecks.length === 0) {
             return undefined;

package/dist/publication-recap.js

@@ -0,0 +1,113 @@
+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 PUBLICATION_RECAP_TIMEOUT_MS = 45_000;
+const PUBLICATION_RECAP_POLL_MS = 1_000;
+export class PublicationRecapService {
+    codex;
+    logger;
+    constructor(codex, logger) {
+        this.codex = codex;
+        this.logger = logger;
+    }
+    async run(params) {
+        const threadId = params.run.threadId;
+        if (!threadId) {
+            throw new Error("Publication recap could not run because the main thread is missing.");
+        }
+        const fork = await this.codex.forkThreadForPublicationRecap(threadId);
+        const turn = await this.codex.startTurn({
+            threadId: fork.id,
+            ...(fork.cwd ? { cwd: fork.cwd } : {}),
+            input: buildPublicationRecapPrompt(params),
+        });
+        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 = parsePublicationRecapResult(latestMessage);
+        if (!parsed) {
+            this.logger.warn({ runId: params.run.id, issueKey: params.issue.issueKey, threadId: fork.id, turnId: turn.turnId }, "Publication recap returned invalid JSON");
+            throw new Error("Publication recap returned an invalid result.");
+        }
+        return {
+            ...parsed,
+            threadId: fork.id,
+            turnId: turn.turnId,
+        };
+    }
+    async waitForTurn(threadId, turnId) {
+        const deadline = Date.now() + PUBLICATION_RECAP_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(`Publication recap turn ${turnId} ended with status ${turn.status}`);
+            }
+            await new Promise((resolve) => setTimeout(resolve, PUBLICATION_RECAP_POLL_MS));
+        }
+        throw new Error(`Publication recap timed out after ${PUBLICATION_RECAP_TIMEOUT_MS}ms`);
+    }
+}
+function buildPublicationRecapPrompt(params) {
+    const latestSummary = params.facts?.latestAssistantSummary
+        ? sanitizeOperatorFacingText(params.facts.latestAssistantSummary)
+        : extractLatestAssistantSummary(params.run);
+    return [
+        "PatchRelay publication recap",
+        "",
+        "The main task run succeeded.",
+        "This is a read-only follow-up used only to produce one concise Linear-visible recap for that successful run.",
+        "Do not run commands, call tools, edit files, or inspect the repository.",
+        "Use only the prior thread context and the facts in this prompt.",
+        "Return exactly one JSON object and no extra prose.",
+        "",
+        "Schema:",
+        '{',
+        '  "summary": "one short sentence, max 30 words"',
+        '}',
+        "",
+        "Writing rules:",
+        "- Focus on what this session chunk achieved.",
+        "- Mention the wake reason only when it makes the change clearer, for example requested changes, a failing CI check, or a merge queue incident.",
+        "- Do not list touched files, test commands, branch names, commit SHAs, or internal process details.",
+        "- Do not say that you reviewed files or ran checks unless that is the only meaningful achievement.",
+        "- For implementation runs, summarize the delivered user-facing or system-facing change.",
+        "- For review-fix runs, summarize the concern that was addressed and imply that a newer head was published.",
+        "- For CI repair runs, summarize the failure that was fixed if known.",
+        "- For queue repair runs, summarize the queue or merge issue that was resolved if known.",
+        "",
+        "Facts:",
+        `- Issue: ${params.issue.issueKey ?? params.issue.linearIssueId}`,
+        ...(params.issue.title ? [`- Title: ${params.issue.title}`] : []),
+        `- Run type: ${params.run.runType}`,
+        ...(params.facts?.postRunState ? [`- Post-run state: ${params.facts.postRunState}`] : []),
+        ...(params.facts?.wakeReason ? [`- Wake reason: ${params.facts.wakeReason}`] : []),
+        ...(params.facts?.prNumber !== undefined ? [`- PR number: ${params.facts.prNumber}`] : []),
+        ...(params.facts?.reviewerName ? [`- Reviewer: ${params.facts.reviewerName}`] : []),
+        ...(params.facts?.reviewSummary ? [`- Review summary: ${sanitizeOperatorFacingText(params.facts.reviewSummary)}`] : []),
+        ...(params.facts?.failingCheckName ? [`- Failing check: ${params.facts.failingCheckName}`] : []),
+        ...(params.facts?.failureSummary ? [`- Failure summary: ${sanitizeOperatorFacingText(params.facts.failureSummary)}`] : []),
+        ...(params.facts?.queueIncidentSummary ? [`- Queue incident: ${sanitizeOperatorFacingText(params.facts.queueIncidentSummary)}`] : []),
+        ...(latestSummary ? [`- Latest assistant summary: ${latestSummary}`] : []),
+        ...(params.run.failureReason ? [`- Failure reason: ${sanitizeOperatorFacingText(params.run.failureReason)}`] : []),
+        ...(params.issue.description ? ["", "Issue description:", params.issue.description] : []),
+    ].join("\n");
+}
+function parsePublicationRecapResult(text) {
+    const raw = sanitizeOperatorFacingText(text);
+    if (!raw)
+        return undefined;
+    const candidate = safeJsonParse(raw) ?? safeJsonParse(extractFirstJsonObject(raw) ?? "");
+    if (!candidate)
+        return undefined;
+    const summary = typeof candidate.summary === "string" ? sanitizeOperatorFacingText(candidate.summary) : undefined;
+    if (!summary)
+        return undefined;
+    return { summary };
+}

package/dist/run-finalizer.js

@@ -2,6 +2,30 @@ import { buildStageReport, countEventMethods } from "./run-reporting.js";
 import { buildRunCompletedActivity, buildRunFailureActivity } from "./linear-session-reporting.js";
 import { handleNoPrCompletionCheck } from "./no-pr-completion-check.js";
 import { resolveCompletedRunState } from "./run-completion-policy.js";
+function parseEventJson(eventJson) {
+    if (!eventJson)
+        return undefined;
+    try {
+        const parsed = JSON.parse(eventJson);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function buildRunSummaryJson(report, publicationRecapSummary) {
+    return JSON.stringify({
+        latestAssistantMessage: report.assistantMessages.at(-1) ?? null,
+        publicationRecapSummary: publicationRecapSummary ?? null,
+    });
+}
+function shouldGeneratePublicationRecap(runType) {
+    return runType === "implementation"
+        || runType === "review_fix"
+        || runType === "branch_upkeep"
+        || runType === "ci_repair"
+        || runType === "queue_repair";
+}
 export class RunFinalizer {
     db;
     logger;
@@ -13,8 +37,9 @@ export class RunFinalizer {
     failRunAndClear;
     completionPolicy;
     completionCheck;
+    publicationRecap;
     feed;
-    constructor(db, logger, linearSync, enqueueIssue, withHeldLease, releaseLease, appendWakeEventWithLease, failRunAndClear, completionPolicy, completionCheck, feed) {
+    constructor(db, logger, linearSync, enqueueIssue, withHeldLease, releaseLease, appendWakeEventWithLease, failRunAndClear, completionPolicy, completionCheck, publicationRecap, feed) {
         this.db = db;
         this.logger = logger;
         this.linearSync = linearSync;
@@ -25,6 +50,7 @@ export class RunFinalizer {
         this.failRunAndClear = failRunAndClear;
         this.completionPolicy = completionPolicy;
         this.completionCheck = completionCheck;
+        this.publicationRecap = publicationRecap;
         this.feed = feed;
     }
     buildCompletedRunUpdate(params) {
@@ -32,10 +58,79 @@ export class RunFinalizer {
             status: "completed",
             threadId: params.threadId,
             ...(params.completedTurnId ? { turnId: params.completedTurnId } : {}),
-            summaryJson: JSON.stringify({ latestAssistantMessage: params.report.assistantMessages.at(-1) ?? null }),
+            summaryJson: buildRunSummaryJson(params.report, params.publicationRecapSummary),
             reportJson: JSON.stringify(params.report),
         };
     }
+    resolveConsumedWakeEvent(run) {
+        return this.db.issueSessions
+            .listIssueSessionEvents(run.projectId, run.linearIssueId)
+            .filter((event) => event.consumedByRunId === run.id)
+            .at(-1);
+    }
+    resolvePublicationRecapFacts(params) {
+        const session = this.db.issueSessions.getIssueSession(params.run.projectId, params.run.linearIssueId);
+        const facts = {
+            ...(session?.lastWakeReason ? { wakeReason: session.lastWakeReason } : {}),
+            ...(params.postRunState ? { postRunState: params.postRunState } : {}),
+            ...(params.issue.prNumber !== undefined ? { prNumber: params.issue.prNumber } : {}),
+            ...(params.latestAssistantSummary ? { latestAssistantSummary: params.latestAssistantSummary } : {}),
+        };
+        const wakeEvent = this.resolveConsumedWakeEvent(params.run);
+        const payload = parseEventJson(wakeEvent?.eventJson);
+        if (!wakeEvent || !payload) {
+            return facts;
+        }
+        switch (wakeEvent.eventType) {
+            case "review_changes_requested":
+                return {
+                    ...facts,
+                    ...(typeof payload.reviewerName === "string" ? { reviewerName: payload.reviewerName } : {}),
+                    ...(typeof payload.reviewBody === "string" ? { reviewSummary: payload.reviewBody } : {}),
+                };
+            case "settled_red_ci":
+                return {
+                    ...facts,
+                    ...(typeof payload.jobName === "string"
+                        ? { failingCheckName: payload.jobName }
+                        : typeof payload.checkName === "string" ? { failingCheckName: payload.checkName } : {}),
+                    ...(typeof payload.summary === "string" ? { failureSummary: payload.summary } : {}),
+                };
+            case "merge_steward_incident":
+                return {
+                    ...facts,
+                    ...(typeof payload.incidentSummary === "string" ? { queueIncidentSummary: payload.incidentSummary } : {}),
+                };
+            default:
+                return facts;
+        }
+    }
+    async generatePublicationRecap(params) {
+        if (!this.publicationRecap || !shouldGeneratePublicationRecap(params.run.runType)) {
+            return undefined;
+        }
+        try {
+            const result = await this.publicationRecap.run({
+                issue: params.issue,
+                run: params.run,
+                facts: this.resolvePublicationRecapFacts({
+                    run: params.run,
+                    issue: params.issue,
+                    postRunState: params.postRunState,
+                    latestAssistantSummary: params.latestAssistantSummary,
+                }),
+            });
+            return result.summary;
+        }
+        catch (error) {
+            this.logger.warn({
+                runId: params.run.id,
+                issueKey: params.issue.issueKey,
+                error: error instanceof Error ? error.message : String(error),
+            }, "Publication recap failed; falling back to the main run summary");
+            return undefined;
+        }
+    }
     clearProgressAndRelease(run) {
         this.linearSync.clearProgress(run.id);
         this.releaseLease(run.projectId, run.linearIssueId);
@@ -142,14 +237,19 @@ export class RunFinalizer {
         const refreshedIssue = await this.completionPolicy.refreshIssueAfterReactivePublish(run, freshIssue);
         const postRunFollowUp = await this.completionPolicy.resolvePostRunFollowUp(run, refreshedIssue);
         const postRunState = postRunFollowUp?.factoryState ?? resolveCompletedRunState(refreshedIssue, run);
+        const publicationRecapSummary = await this.generatePublicationRecap({
+            run,
+            issue: refreshedIssue,
+            postRunState,
+            latestAssistantSummary: report.assistantMessages.at(-1),
+        });
         const completed = this.withHeldLease(run.projectId, run.linearIssueId, (lease) => {
-            this.db.runs.finishRun(run.id, {
-                status: "completed",
+            this.db.runs.finishRun(run.id, this.buildCompletedRunUpdate({
                 threadId,
-                ...(params.completedTurnId ? { turnId: params.completedTurnId } : {}),
-                summaryJson: JSON.stringify({ latestAssistantMessage: report.assistantMessages.at(-1) ?? null }),
-                reportJson: JSON.stringify(report),
-            });
+                ...(params.completedTurnId ? { completedTurnId: params.completedTurnId } : {}),
+                report,
+                publicationRecapSummary,
+            }));
             this.db.issues.upsertIssue({
                 projectId: run.projectId,
                 linearIssueId: run.linearIssueId,
@@ -204,10 +304,12 @@ export class RunFinalizer {
             summary: params.source === "notification"
                 ? `Turn completed for ${run.runType}`
                 : `Reconciliation: ${run.runType} completed${postRunState ? ` -> ${postRunState}` : ""}`,
-            detail: report.assistantMessages.at(-1),
+            detail: publicationRecapSummary ?? report.assistantMessages.at(-1),
         });
         const updatedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? refreshedIssue;
-        const completionSummary = report.assistantMessages.at(-1)?.slice(0, 300) ?? `${run.runType} completed.`;
+        const completionSummary = publicationRecapSummary
+            ?? report.assistantMessages.at(-1)?.slice(0, 300)
+            ?? `${run.runType} completed.`;
         const linearActivity = buildRunCompletedActivity({
             runType: run.runType,
             completionSummary,

package/dist/run-orchestrator.js

@@ -1,6 +1,7 @@
 import { summarizeCurrentThread } from "./run-reporting.js";
 import { buildRunStartedActivity, } from "./linear-session-reporting.js";
 import { CompletionCheckService } from "./completion-check.js";
+import { PublicationRecapService } from "./publication-recap.js";
 import { WorktreeManager } from "./worktree-manager.js";
 import { MergedLinearCompletionReconciler } from "./merged-linear-completion-reconciler.js";
 import { MainBranchHealthMonitor } from "./main-branch-health-monitor.js";
@@ -59,6 +60,7 @@ export class RunOrchestrator {
     interruptedRunRecovery;
     runCompletionPolicy;
     completionCheck;
+    publicationRecap;
     runNotificationHandler;
     runReconciler;
     mergedLinearCompletionReconciler;
@@ -95,7 +97,8 @@ export class RunOrchestrator {
         this.activeSessionLeases = this.leaseService.activeSessionLeases;
         this.runCompletionPolicy = new RunCompletionPolicy(config, db, logger, this.leasePorts.withHeldLease);
         this.completionCheck = new CompletionCheckService(codex, logger);
-        this.runFinalizer = new RunFinalizer(db, logger, this.linearSync, this.enqueueIssue, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, (lease, issue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, issue, runType, context, dedupeScope), this.recoveryPorts.failRunAndClear, this.runCompletionPolicy, this.completionCheck, feed);
+        this.publicationRecap = new PublicationRecapService(codex, logger);
+        this.runFinalizer = new RunFinalizer(db, logger, this.linearSync, this.enqueueIssue, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, (lease, issue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, issue, runType, context, dedupeScope), this.recoveryPorts.failRunAndClear, this.runCompletionPolicy, this.completionCheck, this.publicationRecap, feed);
         this.runLauncher = new RunLauncher(config, db, codex, logger, this.worktreeManager);
         this.runNotificationHandler = new RunNotificationHandler(config, db, logger, this.linearSync, this.runFinalizer, this.threadPorts.readThreadWithRetry, this.leasePorts.withHeldLease, this.leasePorts.heartbeatLease, this.leasePorts.releaseLease, feed);
         this.runRecovery = new RunRecoveryService(db, logger, this.linearSync, this.leasePorts.withHeldLease, this.leasePorts.getHeldLease, (lease, issue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, issue, runType, context, dedupeScope), this.leasePorts.releaseLease, (projectId, issueId) => this.enqueueIssue(projectId, issueId), feed);

package/package.json

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