patchrelay 0.51.1 → 0.51.3

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.51.1",
-  "commit": "0b16fe78f8c9",
-  "builtAt": "2026-04-21T22:06:12.939Z"
+  "version": "0.51.3",
+  "commit": "7bb8f3bef8bf",
+  "builtAt": "2026-04-22T04:21:59.470Z"
 }

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/linear-session-sync.js

@@ -1,4 +1,4 @@
-import { shouldSyncVisibleIssueComment, syncVisibleStatusComment, } from "./linear-status-comment-sync.js";
+import { collapseVisibleStatusComment, shouldSyncVisibleIssueComment, syncVisibleStatusComment, } from "./linear-status-comment-sync.js";
 import { LinearAgentSessionClient } from "./linear-agent-session-client.js";
 import { LinearProgressReporter } from "./linear-progress-reporter.js";
 import { syncActiveWorkflowState } from "./linear-workflow-state-sync.js";
@@ -49,6 +49,13 @@ export class LinearSessionSync {
                     ...(options ? { options } : {}),
                 });
             }
+            else if (syncedIssue.statusCommentId) {
+                await collapseVisibleStatusComment({
+                    issue: syncedIssue,
+                    linear,
+                    logger: this.logger,
+                });
+            }
         }
         catch (error) {
             const msg = error instanceof Error ? error.message : String(error);

package/dist/linear-status-comment-sync.js

@@ -25,8 +25,40 @@ export async function syncVisibleStatusComment(params) {
         logger.warn({ issueKey: issue.issueKey, error: msg }, "Failed to sync Linear status comment");
     }
 }
-export function shouldSyncVisibleIssueComment(_issue, _hasAgentSession) {
-    return true;
+export function shouldSyncVisibleIssueComment(issue, hasAgentSession) {
+    if (!hasAgentSession) {
+        return true;
+    }
+    if (!issue.delegatedToPatchRelay) {
+        return true;
+    }
+    if (issue.sessionState === "waiting_input" || issue.factoryState === "awaiting_input") {
+        return true;
+    }
+    if (issue.sessionState === "failed" || issue.factoryState === "failed" || issue.factoryState === "escalated") {
+        return true;
+    }
+    if (issue.factoryState === "done") {
+        return issue.prState !== "merged";
+    }
+    return false;
+}
+export async function collapseVisibleStatusComment(params) {
+    const { issue, linear, logger } = params;
+    if (!issue.statusCommentId) {
+        return;
+    }
+    try {
+        await linear.upsertIssueComment({
+            issueId: issue.linearIssueId,
+            commentId: issue.statusCommentId,
+            body: renderCollapsedStatusComment(),
+        });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        logger.warn({ issueId: issue.linearIssueId, error: msg }, "Failed to collapse Linear status comment");
+    }
 }
 function renderStatusComment(db, issue, trackedIssue, options) {
     const activeRun = issue.activeRunId ? db.runs.getRunById(issue.activeRunId) : undefined;
@@ -97,21 +129,18 @@ function renderStatusComment(db, issue, trackedIssue, options) {
                     : `PR: ${linkedLabel}`;
         lines.push("", prLine);
     }
-    if (latestRun) {
-        lines.push("", `Latest run: ${formatLatestRun(latestRun)}`);
-        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}`);
     }
-    lines.push("", "_PatchRelay updates this comment as it works. Review and merge remain downstream._");
     return lines.join("\n");
 }
+function renderCollapsedStatusComment() {
+    return [
+        "## PatchRelay status",
+        "",
+        "Live status is in the agent session and activity feed. This comment is reused only when PatchRelay needs human input or intervention.",
+    ].join("\n");
+}
 function statusHeadline(issue, activeRunType) {
     const prContext = derivePrDisplayContext(issue);
     if (activeRunType) {
@@ -193,10 +222,6 @@ function statusHeadline(issue, activeRunType) {
             return humanize(issue.factoryState);
     }
 }
-function formatLatestRun(run) {
-    const at = run.endedAt ?? run.startedAt;
-    return `${humanize(run.runType)} ${run.status} at ${at}`;
-}
 function humanize(value) {
     return value.replaceAll("_", " ");
 }

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/dist/status-note.js

@@ -36,6 +36,7 @@ export function deriveIssueStatusNote(params) {
         ? completionCheck.question ?? completionCheck.summary
         : completionCheck?.summary);
     const latestRunNote = clean(extractLatestAssistantSummary(params.latestRun));
+    const latestFailureReason = clean(params.latestRun?.failureReason);
     const latestEventNote = clean(eventStatusNote(params.latestEvent));
     const failureSummary = clean(params.failureSummary);
     const waitingReason = clean(params.waitingReason);
@@ -50,7 +51,7 @@ export function deriveIssueStatusNote(params) {
                 break;
             case "failed":
             case "escalated":
-                note = latestEventNote ?? completionCheckNote ?? failureSummary ?? latestRunNote ?? sessionSummary;
+                note = latestEventNote ?? completionCheckNote ?? failureSummary ?? latestFailureReason ?? latestRunNote ?? sessionSummary;
                 break;
             case "done":
                 note = completionCheckNote ?? sessionSummary ?? latestRunNote ?? failureSummary;

package/dist/webhooks/comment-policy.js

@@ -2,8 +2,7 @@ export function isInertPatchRelayComment(issue, commentId, body, actorType) {
     if (commentId === issue.statusCommentId) {
         return true;
     }
-    if (body.startsWith("## PatchRelay status")
-        && body.includes("_PatchRelay updates this comment as it works. Review and merge remain downstream._")) {
+    if (body.startsWith("## PatchRelay status")) {
         return true;
     }
     const normalizedActorType = actorType?.trim().toLowerCase();

package/package.json

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