patchrelay 0.52.0 → 0.52.2

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.52.0",
-  "commit": "818b35cc9b05",
-  "builtAt": "2026-04-22T14:41:18.426Z"
+  "version": "0.52.2",
+  "commit": "44bb9d45502d",
+  "builtAt": "2026-04-22T17:29:32.600Z"
 }

package/dist/cli/data.js

@@ -6,6 +6,7 @@ import { extractCompletionCheck } from "../completion-check.js";
 import { getThreadTurns } from "../codex-thread-utils.js";
 import { PatchRelayDatabase } from "../db.js";
 import { buildManualRetryAttemptReset, resolveRetryTarget } from "../manual-issue-actions.js";
+import { buildOperatorRetryEvent } from "../operator-retry-event.js";
 import { WorktreeManager } from "../worktree-manager.js";
 import { parseDelegationObservedPayload, parseRunReleasedAuthorityPayload } from "../delegation-audit.js";
 import { CliOperatorApiClient } from "./operator-client.js";
@@ -386,61 +387,10 @@ export class CliDataAccess extends CliOperatorApiClient {
         };
     }
     appendRetryWake(issue, runType) {
-        if (runType === "queue_repair") {
-            const queueIncident = parseObjectJson(issue.lastQueueIncidentJson);
-            const failureContext = parseObjectJson(issue.lastGitHubFailureContextJson);
-            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                eventType: "merge_steward_incident",
-                eventJson: JSON.stringify({
-                    ...(queueIncident ?? {}),
-                    ...(failureContext ?? {}),
-                    source: "operator_retry",
-                }),
-                dedupeKey: `operator_retry:queue_repair:${issue.linearIssueId}:${issue.prHeadSha ?? issue.lastGitHubFailureHeadSha ?? "unknown-sha"}`,
-            });
-            return;
-        }
-        if (runType === "ci_repair") {
-            const failureContext = parseObjectJson(issue.lastGitHubFailureContextJson);
-            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                eventType: "settled_red_ci",
-                eventJson: JSON.stringify({
-                    ...(failureContext ?? {}),
-                    source: "operator_retry",
-                }),
-                dedupeKey: `operator_retry:ci_repair:${issue.linearIssueId}:${issue.lastGitHubFailureSignature ?? issue.prHeadSha ?? "unknown-sha"}`,
-            });
-            return;
-        }
-        if (runType === "review_fix" || runType === "branch_upkeep") {
-            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                eventType: "review_changes_requested",
-                eventJson: JSON.stringify({
-                    reviewBody: runType === "branch_upkeep"
-                        ? "Operator requested retry of branch upkeep after requested changes."
-                        : "Operator requested retry of review-fix work.",
-                    ...(runType === "branch_upkeep" ? { branchUpkeepRequired: true, wakeReason: "branch_upkeep" } : {}),
-                    source: "operator_retry",
-                }),
-                dedupeKey: `operator_retry:${runType}:${issue.linearIssueId}:${issue.prHeadSha ?? "unknown-sha"}`,
-            });
-            return;
-        }
         this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
-            eventType: "delegated",
-            eventJson: JSON.stringify({
-                promptContext: "Operator requested retry of PatchRelay work.",
-                source: "operator_retry",
-            }),
-            dedupeKey: `operator_retry:implementation:${issue.linearIssueId}`,
+            ...buildOperatorRetryEvent(issue, runType),
         });
     }
     list(options) {

package/dist/linear-progress-facts.js

@@ -18,32 +18,33 @@ function deriveProgressFactFromCompletedItem(rawItem, issue) {
     if (item.type !== "agentMessage" || typeof item.text !== "string") {
         return undefined;
     }
-    const body = compactOperatorSentence(item.text);
-    if (!body) {
+    const fullBody = sanitizeOperatorFacingText(item.text)?.replace(/\s+/g, " ").trim();
+    if (!fullBody) {
         return undefined;
     }
-    if (looksLikeVerification(body)) {
+    const ephemeralBody = compactOperatorSentence(fullBody) ?? fullBody;
+    if (looksLikeVerification(fullBody)) {
         return {
             kind: "verification_started",
-            meaningKey: `verification:${normalizeMeaningKey(body)}`,
-            ephemeralContent: { type: "thought", body },
-            historyContent: { type: "thought", body },
+            meaningKey: `verification:${normalizeMeaningKey(fullBody)}`,
+            ephemeralContent: { type: "thought", body: ephemeralBody },
+            historyContent: { type: "thought", body: fullBody },
         };
     }
-    if (looksLikePublishing(body)) {
+    if (looksLikePublishing(fullBody)) {
         return {
             kind: "publishing_started",
-            meaningKey: `publishing:${normalizeMeaningKey(body)}`,
-            ephemeralContent: { type: "thought", body },
-            historyContent: { type: "thought", body },
+            meaningKey: `publishing:${normalizeMeaningKey(fullBody)}`,
+            ephemeralContent: { type: "thought", body: ephemeralBody },
+            historyContent: { type: "thought", body: fullBody },
         };
     }
-    if (looksLikeRootCause(body)) {
+    if (looksLikeRootCause(fullBody)) {
         return {
             kind: "root_cause_found",
-            meaningKey: `finding:${normalizeMeaningKey(body)}`,
-            ephemeralContent: { type: "thought", body },
-            historyContent: { type: "thought", body },
+            meaningKey: `finding:${normalizeMeaningKey(fullBody)}`,
+            ephemeralContent: { type: "thought", body: ephemeralBody },
+            historyContent: { type: "thought", body: fullBody },
         };
     }
     return undefined;

package/dist/linear-session-reporting.js

@@ -77,20 +77,35 @@ export function buildRunCompletedActivity(params) {
             }
             return undefined;
         case "review_fix":
-            return {
-                type: "response",
-                body: `Updated ${prLabel} to address review feedback.${detail}`,
-            };
+            return summary
+                ? {
+                    type: "response",
+                    body: summary,
+                }
+                : {
+                    type: "response",
+                    body: `Updated ${prLabel} to address review feedback.`,
+                };
         case "ci_repair":
-            return {
-                type: "response",
-                body: `Updated ${prLabel} after CI repair.${detail}`,
-            };
+            return summary
+                ? {
+                    type: "response",
+                    body: summary,
+                }
+                : {
+                    type: "response",
+                    body: `Updated ${prLabel} after CI repair.`,
+                };
         case "queue_repair":
-            return {
-                type: "response",
-                body: `Updated ${prLabel} after merge-queue repair.${detail}`,
-            };
+            return summary
+                ? {
+                    type: "response",
+                    body: summary,
+                }
+                : {
+                    type: "response",
+                    body: `Updated ${prLabel} after merge-queue repair.`,
+                };
         case "branch_upkeep":
             return undefined;
         default: {

package/dist/operator-retry-event.js

@@ -38,9 +38,9 @@ export function buildOperatorRetryEvent(issue, runType, source = "operator_retry
         return {
             eventType: "review_changes_requested",
             eventJson: JSON.stringify({
-                reviewBody: runType === "branch_upkeep"
-                    ? `${humanizeSource(source)} requested retry of branch upkeep after requested changes.`
-                    : `${humanizeSource(source)} requested retry of review-fix work.`,
+                ...(runType === "branch_upkeep"
+                    ? { reviewBody: `${humanizeSource(source)} requested retry of branch upkeep after requested changes.` }
+                    : { promptContext: `${humanizeSource(source)} requested retry of review-fix work.` }),
                 ...(runType === "branch_upkeep" ? { branchUpkeepRequired: true, wakeReason: "branch_upkeep" } : {}),
                 source,
             }),

package/dist/reactive-run-policy.js

@@ -1,4 +1,5 @@
 import { buildReviewFixBranchUpkeepContext, isDirtyMergeStateStatus, isRequestedChangesRunType, readReactivePrSnapshot, } from "./reactive-pr-state.js";
+import { readLatestRequestedChangesReviewContext } from "./remote-pr-review.js";
 export class ReactiveRunPolicy {
     config;
     db;
@@ -136,6 +137,7 @@ export class ReactiveRunPolicy {
             const snapshot = await readReactivePrSnapshot(this.config, issue.projectId, issue.prNumber);
             if (!snapshot)
                 return context;
+            const refreshedContext = await this.hydrateRequestedChangesContext(issue.projectId, issue.prNumber, snapshot.repoFullName, snapshot.headSha, context);
             this.upsertIssueIfLeaseHeld(issue.projectId, issue.linearIssueId, {
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
@@ -144,12 +146,12 @@ export class ReactiveRunPolicy {
                 ...(snapshot.reviewState ? { prReviewState: snapshot.reviewState } : {}),
             }, "review-fix wake refresh");
             if (snapshot.prState !== "open")
-                return context;
+                return refreshedContext;
             if (snapshot.reviewState && snapshot.reviewState !== "changes_requested")
-                return context;
+                return refreshedContext;
             if (!isDirtyMergeStateStatus(snapshot.pr.mergeStateStatus))
-                return context;
-            return buildReviewFixBranchUpkeepContext(issue.prNumber, snapshot.baseBranch, snapshot.pr, context);
+                return refreshedContext;
+            return buildReviewFixBranchUpkeepContext(issue.prNumber, snapshot.baseBranch, snapshot.pr, refreshedContext);
         }
         catch (error) {
             this.logger.debug({
@@ -210,4 +212,44 @@ export class ReactiveRunPolicy {
         }
         return updated;
     }
+    async hydrateRequestedChangesContext(projectId, prNumber, repoFullName, headSha, context) {
+        const merged = {
+            ...(context ?? {}),
+            ...(headSha ? { headSha } : {}),
+        };
+        if (hasStructuredReviewContext(merged)) {
+            return merged;
+        }
+        const liveReview = await readLatestRequestedChangesReviewContext(repoFullName, prNumber);
+        if (!liveReview) {
+            return Object.keys(merged).length > 0 ? merged : context;
+        }
+        return {
+            ...merged,
+            ...(liveReview.reviewId !== undefined ? { reviewId: liveReview.reviewId } : {}),
+            ...(liveReview.reviewCommitId ? { reviewCommitId: liveReview.reviewCommitId } : {}),
+            ...(liveReview.reviewUrl ? { reviewUrl: liveReview.reviewUrl } : {}),
+            ...(liveReview.reviewerName ? { reviewerName: liveReview.reviewerName } : {}),
+            ...(liveReview.reviewBody ? { reviewBody: liveReview.reviewBody } : {}),
+            ...(liveReview.reviewComments ? { reviewComments: liveReview.reviewComments } : {}),
+        };
+    }
+}
+function hasStructuredReviewContext(context) {
+    if (!context)
+        return false;
+    const reviewBody = typeof context.reviewBody === "string" ? context.reviewBody.trim() : "";
+    const isOperatorRetryPlaceholder = typeof context.source === "string"
+        && context.source === "operator_retry"
+        && /^operator requested retry of review-fix work\.?$/i.test(reviewBody);
+    if (isOperatorRetryPlaceholder) {
+        return false;
+    }
+    if (reviewBody)
+        return true;
+    if (typeof context.reviewUrl === "string" && context.reviewUrl.trim())
+        return true;
+    if (typeof context.reviewerName === "string" && context.reviewerName.trim())
+        return true;
+    return Array.isArray(context.reviewComments) && context.reviewComments.length > 0;
 }

package/dist/remote-pr-review.js

@@ -0,0 +1,60 @@
+import { execCommand, safeJsonParse } from "./utils.js";
+export async function readLatestRequestedChangesReviewContext(repoFullName, prNumber) {
+    const [owner, repo] = repoFullName.split("/", 2);
+    if (!owner || !repo) {
+        return undefined;
+    }
+    const reviewsResult = await execCommand("gh", [
+        "api",
+        `repos/${owner}/${repo}/pulls/${prNumber}/reviews?per_page=100`,
+    ], { timeoutMs: 10_000 });
+    if (reviewsResult.exitCode !== 0) {
+        return undefined;
+    }
+    const reviews = safeJsonParse(reviewsResult.stdout);
+    if (!Array.isArray(reviews)) {
+        return undefined;
+    }
+    const review = [...reviews].reverse().find((entry) => entry?.state?.trim().toUpperCase() === "CHANGES_REQUESTED");
+    if (!review?.id) {
+        return undefined;
+    }
+    const comments = await readReviewComments(owner, repo, prNumber, review.id);
+    return {
+        reviewId: review.id,
+        ...(typeof review.commit_id === "string" && review.commit_id.trim() ? { reviewCommitId: review.commit_id.trim() } : {}),
+        ...(typeof review.html_url === "string" && review.html_url.trim() ? { reviewUrl: review.html_url.trim() } : {}),
+        ...(typeof review.body === "string" && review.body.trim() ? { reviewBody: review.body.trim() } : {}),
+        ...(typeof review.user?.login === "string" && review.user.login.trim() ? { reviewerName: review.user.login.trim() } : {}),
+        ...(comments.length > 0 ? { reviewComments: comments } : {}),
+    };
+}
+async function readReviewComments(owner, repo, prNumber, reviewId) {
+    const commentsResult = await execCommand("gh", [
+        "api",
+        `repos/${owner}/${repo}/pulls/${prNumber}/reviews/${reviewId}/comments?per_page=100`,
+    ], { timeoutMs: 10_000 });
+    if (commentsResult.exitCode !== 0) {
+        return [];
+    }
+    const comments = safeJsonParse(commentsResult.stdout);
+    if (!Array.isArray(comments)) {
+        return [];
+    }
+    return comments.flatMap((entry) => {
+        const body = typeof entry.body === "string" ? entry.body.trim() : "";
+        if (!body) {
+            return [];
+        }
+        return [{
+                body,
+                ...(typeof entry.path === "string" ? { path: entry.path } : {}),
+                ...(typeof entry.line === "number" ? { line: entry.line } : {}),
+                ...(typeof entry.side === "string" ? { side: entry.side } : {}),
+                ...(typeof entry.start_line === "number" ? { startLine: entry.start_line } : {}),
+                ...(typeof entry.start_side === "string" ? { startSide: entry.start_side } : {}),
+                ...(typeof entry.html_url === "string" ? { url: entry.html_url } : {}),
+                ...(typeof entry.user?.login === "string" ? { authorLogin: entry.user.login } : {}),
+            }];
+    });
+}

package/dist/run-launcher.js

@@ -18,6 +18,16 @@ function shouldCompactThread(issue, threadGeneration, context) {
 export function shouldReuseIssueThread(params) {
     return Boolean(params.existingThreadId) && !params.compactThread && params.resumeThread;
 }
+export function shouldFreshenWorktreeBeforeLaunch(params) {
+    if (params.runType === "queue_repair") {
+        return false;
+    }
+    if (params.runType === "review_fix") {
+        return params.effectiveContext?.branchUpkeepRequired === true
+            || params.effectiveContext?.reviewFixMode === "branch_upkeep";
+    }
+    return true;
+}
 export class RunLauncher {
     config;
     db;
@@ -125,7 +135,10 @@ export class RunLauncher {
                 });
             }
             await this.worktreeManager.resetWorktreeToTrackedBranch(params.worktreePath, params.branchName, params.issue, this.logger);
-            if (params.runType !== "queue_repair") {
+            if (shouldFreshenWorktreeBeforeLaunch({
+                runType: params.runType,
+                ...(params.effectiveContext ? { effectiveContext: params.effectiveContext } : {}),
+            })) {
                 await this.worktreeManager.freshenWorktree(params.worktreePath, params.project, params.issue, this.logger);
             }
             const hookEnv = buildHookEnv(params.issue.issueKey ?? params.issue.linearIssueId, params.branchName, params.runType, params.worktreePath);

package/package.json

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