patchrelay 0.50.4 → 0.50.6

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.50.4",
-  "commit": "0063b47a1df7",
-  "builtAt": "2026-04-21T12:01:24.460Z"
+  "version": "0.50.6",
+  "commit": "93d2215a55bf",
+  "builtAt": "2026-04-21T15:53:17.328Z"
 }

package/dist/cli/watch/issue-token.js

@@ -1,4 +1,5 @@
 import { isUndelegatedPausedIssue } from "../../paused-issue-state.js";
+import { derivePrDisplayContext } from "../../pr-display-context.js";
 import { hasFailedPrChecks, hasPendingPrChecks, isApprovedReviewState, isAwaitingReviewState, isChangesRequestedReviewState, prChecksFact, } from "./pr-status.js";
 const GLYPH = {
     running: "\u25cf",
@@ -89,9 +90,14 @@ export function prTokenFor(issue) {
     };
 }
 function prKind(issue) {
-    if (issue.prState === "merged")
+    const prContext = derivePrDisplayContext(issue);
+    if (prContext.kind === "merged_pr")
         return "approved";
-    if (issue.prState === "closed")
+    if (prContext.kind === "closed_replacement_pending")
+        return "queued";
+    if (prContext.kind === "closed_pr_paused")
+        return "attention";
+    if (prContext.kind === "closed_historical_pr")
         return "declined";
     if (issue.prReviewState === "approved")
         return "approved";
@@ -104,9 +110,14 @@ function prKind(issue) {
     return "running";
 }
 function prPhraseFor(issue) {
-    if (issue.prState === "merged")
+    const prContext = derivePrDisplayContext(issue);
+    if (prContext.kind === "merged_pr")
         return "merged";
-    if (issue.prState === "closed")
+    if (prContext.kind === "closed_replacement_pending")
+        return "replace pr";
+    if (prContext.kind === "closed_pr_paused")
+        return "redelegate";
+    if (prContext.kind === "closed_historical_pr")
         return "closed";
     if (isChangesRequestedReviewState(issue.prReviewState))
         return "changes req";

package/dist/cli/watch/state-visualization.js

@@ -1,4 +1,5 @@
 import { hasOpenPr } from "../../pr-state.js";
+import { derivePrDisplayContext } from "../../pr-display-context.js";
 const STATE_LABELS = {
     delegated: "delegated",
     implementing: "implementing",
@@ -164,9 +165,28 @@ export function buildPatchRelayQueueObservations(issue, feedEvents) {
         });
     }
     if (issue.prNumber !== undefined) {
-        const prLabel = hasOpenPr(issue.prNumber, issue.prState)
-            ? `Tracked PR: #${issue.prNumber}`
-            : `Tracked PR: #${issue.prNumber}${issue.prState ? ` (${issue.prState})` : ""}`;
+        const prContext = derivePrDisplayContext(issue);
+        let prLabel;
+        switch (prContext.kind) {
+            case "active_pr":
+            case "merged_pr":
+                prLabel = hasOpenPr(issue.prNumber, issue.prState)
+                    ? `Tracked PR: #${issue.prNumber}`
+                    : `Tracked PR: #${issue.prNumber}${issue.prState ? ` (${issue.prState})` : ""}`;
+                break;
+            case "closed_historical_pr":
+                prLabel = `Previous PR: #${prContext.prNumber} (closed)`;
+                break;
+            case "closed_replacement_pending":
+                prLabel = `Previous PR: #${prContext.prNumber} (closed; replacement pending)`;
+                break;
+            case "closed_pr_paused":
+                prLabel = `Previous PR: #${prContext.prNumber} (closed; redelegate to replace)`;
+                break;
+            case "no_pr":
+                prLabel = "PR context unavailable";
+                break;
+        }
         observations.push({
             tone: "info",
             text: `${prLabel}${issue.prReviewState ? ` (${issue.prReviewState})` : ""}`,

package/dist/config.js

@@ -21,6 +21,8 @@ const DEFAULT_PATCHRELAY_DEVELOPER_INSTRUCTIONS = [
     "- If you change files for an implementation run, commit, push the issue branch, and open or update the PR.",
     "- For repair runs, work on the existing PR branch and do not open a new PR.",
     "- A requested-changes repair is only complete after a newer PR head is pushed, unless a genuine external blocker prevents correct publication.",
+    "- If you change schema, enums, shared vocabulary, normalization helpers, or compatibility mappings, inspect the main read/write paths that can bypass the new abstraction and fix or cover any mismatch before publishing.",
+    "- For CI repair, do not change code or config until you either reproduce the failure on the exact failing head or can point to a concrete log signature that justifies the fix. If you cannot reproduce it, prefer a rerun-only repair over speculative changes.",
     "- If a broader inconsistency is not required to make this task correct, mention it briefly instead of expanding scope.",
     "- Before publishing, do one brief reviewer-minded pass on the current head and fix likely in-scope blockers.",
 ].join("\n");

package/dist/delegation-linked-pr.js

@@ -45,8 +45,8 @@ export function deriveLinkedPrAdoptionOutcome(project, prNumber, remote) {
     }
     if (prState === "closed") {
         return {
-            factoryState: "awaiting_input",
-            pendingRunType: null,
+            factoryState: "delegated",
+            pendingRunType: "implementation",
             issueUpdates: {
                 ...issueUpdates,
                 prIsDraft: false,

package/dist/linear-session-reporting.js

@@ -1,6 +1,7 @@
 import { formatRunTypeLabel } from "./agent-session-plan.js";
 import { sanitizeOperatorFacingText } from "./presentation-text.js";
 import { isClosedPrState } from "./pr-state.js";
+import { derivePrDisplayContext } from "./pr-display-context.js";
 function lowerRunTypeLabel(runType) {
     return formatRunTypeLabel(runType).toLowerCase();
 }
@@ -187,6 +188,7 @@ export function buildMergePrepEscalationActivity(attempts) {
     };
 }
 export function summarizeIssueStateForLinear(issue) {
+    const prContext = derivePrDisplayContext(issue);
     switch (issue.sessionState) {
         case "waiting_input":
             return issue.waitingReason ?? (issue.prNumber && !isClosedPrState(issue.prState) ? `PR #${issue.prNumber} is waiting for input.` : "Waiting for input.");
@@ -208,11 +210,23 @@ export function summarizeIssueStateForLinear(issue) {
     }
     switch (issue.factoryState) {
         case "delegated":
+            if (prContext.kind === "closed_replacement_pending") {
+                return `Queued to replace closed PR #${prContext.prNumber}.`;
+            }
+            if (prContext.kind === "closed_pr_paused") {
+                return `Closed PR #${prContext.prNumber} needs redelegation before replacement.`;
+            }
             if (!issue.delegatedToPatchRelay) {
                 return "PatchRelay is queued to start work, but automation is paused.";
             }
             return "Queued to start work.";
         case "implementing":
+            if (prContext.kind === "closed_replacement_pending") {
+                return `Replacing closed PR #${prContext.prNumber} with a fresh PR.`;
+            }
+            if (prContext.kind === "closed_pr_paused") {
+                return `Closed PR #${prContext.prNumber} needs redelegation before replacement.`;
+            }
             if (!issue.delegatedToPatchRelay) {
                 return "Implementation is paused because the issue is undelegated.";
             }

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

@@ -1,5 +1,6 @@
 import { extractCompletionCheck } from "./completion-check.js";
 import { isClosedPrState } from "./pr-state.js";
+import { derivePrDisplayContext } from "./pr-display-context.js";
 import { deriveIssueStatusNote } from "./status-note.js";
 import { derivePatchRelayWaitingReason } from "./waiting-reason.js";
 export async function syncVisibleStatusComment(params) {
@@ -84,8 +85,17 @@ function renderStatusComment(db, issue, trackedIssue, options) {
         lines.push("", `Reply in a Linear comment to continue, or run \`patchrelay issue prompt ${issueRef} "..."\`.`);
     }
     if (issue.prNumber !== undefined || issue.prUrl) {
+        const prContext = derivePrDisplayContext(issue);
         const prLabel = issue.prNumber !== undefined ? `#${issue.prNumber}` : "open";
-        lines.push("", `PR: ${issue.prUrl ? `[${prLabel}](${issue.prUrl})` : prLabel}`);
+        const linkedLabel = issue.prUrl ? `[${prLabel}](${issue.prUrl})` : prLabel;
+        const prLine = prContext.kind === "closed_historical_pr"
+            ? `Previous PR: ${linkedLabel} (closed)`
+            : prContext.kind === "closed_replacement_pending"
+                ? `Previous PR: ${linkedLabel} (closed; replacement PR needed)`
+                : prContext.kind === "closed_pr_paused"
+                    ? `Previous PR: ${linkedLabel} (closed; redelegate to replace it)`
+                    : `PR: ${linkedLabel}`;
+        lines.push("", prLine);
     }
     if (latestRun) {
         lines.push("", `Latest run: ${formatLatestRun(latestRun)}`);
@@ -103,6 +113,7 @@ function renderStatusComment(db, issue, trackedIssue, options) {
     return lines.join("\n");
 }
 function statusHeadline(issue, activeRunType) {
+    const prContext = derivePrDisplayContext(issue);
     if (activeRunType) {
         return `Running ${humanize(activeRunType)}`;
     }
@@ -123,6 +134,9 @@ function statusHeadline(issue, activeRunType) {
             break;
     }
     if (!issue.delegatedToPatchRelay && issue.prNumber !== undefined) {
+        if (prContext.kind === "closed_pr_paused") {
+            return `Closed PR #${prContext.prNumber} is waiting for redelegation before replacement`;
+        }
         if (issue.factoryState === "awaiting_queue" || issue.prReviewState === "approved") {
             return `PR #${issue.prNumber} is awaiting downstream merge while PatchRelay is paused`;
         }
@@ -144,8 +158,14 @@ function statusHeadline(issue, activeRunType) {
     }
     switch (issue.factoryState) {
         case "delegated":
+            if (prContext.kind === "closed_replacement_pending") {
+                return `Queued to replace closed PR #${prContext.prNumber}`;
+            }
             return "Queued to start work";
         case "implementing":
+            if (prContext.kind === "closed_replacement_pending") {
+                return `Replacing closed PR #${prContext.prNumber} with a fresh PR`;
+            }
             return "Implementing requested change";
         case "pr_open":
             return issue.prNumber !== undefined ? `PR #${issue.prNumber} opened` : "PR opened";

package/dist/pr-display-context.js

@@ -0,0 +1,21 @@
+function isTerminalFactoryState(factoryState) {
+    return factoryState === "done" || factoryState === "failed" || factoryState === "escalated";
+}
+export function derivePrDisplayContext(issue) {
+    if (issue.prNumber === undefined) {
+        return { kind: "no_pr" };
+    }
+    if (issue.prState === "merged") {
+        return { kind: "merged_pr", prNumber: issue.prNumber };
+    }
+    if (issue.prState === "closed") {
+        if (isTerminalFactoryState(issue.factoryState)) {
+            return { kind: "closed_historical_pr", prNumber: issue.prNumber };
+        }
+        if (issue.delegatedToPatchRelay === false) {
+            return { kind: "closed_pr_paused", prNumber: issue.prNumber };
+        }
+        return { kind: "closed_replacement_pending", prNumber: issue.prNumber };
+    }
+    return { kind: "active_pr", prNumber: issue.prNumber };
+}

package/dist/prompting/patchrelay.js

@@ -1,5 +1,6 @@
 import { existsSync } from "node:fs";
 import path from "node:path";
+import { derivePrDisplayContext } from "../pr-display-context.js";
 const WORKFLOW_FILES = {
     implementation: "IMPLEMENTATION_WORKFLOW.md",
     review_fix: "REVIEW_WORKFLOW.md",
@@ -28,11 +29,23 @@ function hasWorkflowFile(repoPath, runType) {
     return existsSync(filePath);
 }
 function buildPromptHeader(issue) {
+    const prContext = derivePrDisplayContext(issue);
+    const prLine = prContext.kind === "active_pr"
+        ? `PR: #${prContext.prNumber}`
+        : prContext.kind === "merged_pr"
+            ? `Merged PR: #${prContext.prNumber}`
+            : prContext.kind === "closed_historical_pr"
+                ? `Previous PR: #${prContext.prNumber} (closed)`
+                : prContext.kind === "closed_replacement_pending"
+                    ? `Previous PR: #${prContext.prNumber} (closed; replacement PR needed)`
+                    : prContext.kind === "closed_pr_paused"
+                        ? `Previous PR: #${prContext.prNumber} (closed; redelegate to replace it)`
+                        : undefined;
     return [
         `Issue: ${issue.issueKey ?? issue.linearIssueId}`,
         issue.title ? `Title: ${issue.title}` : undefined,
         issue.branchName ? `Branch: ${issue.branchName}` : undefined,
-        issue.prNumber ? `PR: #${issue.prNumber}` : undefined,
+        prLine,
     ].filter(Boolean).join("\n");
 }
 function extractIssueSection(description, heading) {
@@ -290,6 +303,8 @@ function buildCiRepairContext(context) {
     return [
         "Settled CI failure on the existing PR branch.",
         "Goal: restore CI readiness and push a branch that is likely to pass the next full CI run.",
+        "Before changing code or config, reproduce the failure on the exact failing head or identify the concrete log signature that justifies the fix.",
+        "If the exact failing head does not reproduce locally and the logs do not support a scoped fix, prefer a rerun-only repair over speculative branch changes.",
         snapshot?.gateCheckName ? `Gate check: ${String(snapshot.gateCheckName)}` : "",
         snapshot?.gateCheckStatus ? `Gate status: ${String(snapshot.gateCheckStatus)}` : "",
         snapshot?.settledAt ? `Settled at: ${String(snapshot.settledAt)}` : "",
@@ -352,6 +367,7 @@ function buildQueueRepairContext(context) {
     return lines.filter(Boolean).join("\n");
 }
 function buildFollowUpContextLines(issue, runType, context) {
+    const prContext = derivePrDisplayContext(issue);
     const wakeReason = typeof context?.wakeReason === "string" ? context.wakeReason : undefined;
     const followUps = Array.isArray(context?.followUps) ? context.followUps : [];
     const followUpLines = followUps
@@ -387,9 +403,25 @@ function buildFollowUpContextLines(issue, runType, context) {
         followUpLines.forEach((line) => lines.push(`- ${line}`));
     }
     if (issue.prNumber || issue.prHeadSha || issue.prReviewState || context?.mergeStateStatus) {
-        lines.push("", "Current PR facts:", `Fact freshness: ${context?.githubFactsFresh === true
+        const prHeading = prContext.kind === "closed_historical_pr"
+            || prContext.kind === "closed_replacement_pending"
+            || prContext.kind === "closed_pr_paused"
+            ? "Previous PR facts:"
+            : "Current PR facts:";
+        const prLine = prContext.kind === "active_pr"
+            ? `Current PR: #${prContext.prNumber}`
+            : prContext.kind === "merged_pr"
+                ? `Merged PR: #${prContext.prNumber}`
+                : prContext.kind === "closed_historical_pr"
+                    ? `Previous PR: #${prContext.prNumber} (closed)`
+                    : prContext.kind === "closed_replacement_pending"
+                        ? `Previous PR: #${prContext.prNumber} (closed; replacement PR needed)`
+                        : prContext.kind === "closed_pr_paused"
+                            ? `Previous PR: #${prContext.prNumber} (closed; redelegate to replace it)`
+                            : "";
+        lines.push("", prHeading, `Fact freshness: ${context?.githubFactsFresh === true
             ? "refreshed immediately before this turn was created."
-            : "may now be stale; refresh before making irreversible decisions."}`, issue.prNumber ? `Current PR: #${issue.prNumber}` : "", issue.prHeadSha ? `Current relevant head SHA: ${issue.prHeadSha}` : "", issue.prReviewState ? `Current review state: ${issue.prReviewState}` : "", typeof context?.mergeStateStatus === "string" ? `Merge state against ${String(context?.baseBranch ?? "main")}: ${String(context.mergeStateStatus)}` : "");
+            : "may now be stale; refresh before making irreversible decisions."}`, prLine, issue.prHeadSha ? `Current relevant head SHA: ${issue.prHeadSha}` : "", issue.prReviewState ? `Current review state: ${issue.prReviewState}` : "", typeof context?.mergeStateStatus === "string" ? `Merge state against ${String(context?.baseBranch ?? "main")}: ${String(context.mergeStateStatus)}` : "");
     }
     return lines.filter(Boolean);
 }
@@ -443,17 +475,21 @@ function buildOrchestrationWorkflowGuidance() {
         "Keep outputs concise and observable in Linear.",
     ].join("\n");
 }
-function buildPrePushSelfReviewSection(target) {
+function buildPrePushSelfReviewSection(target, runType) {
     const publishTarget = target === "new_pr"
         ? "open or update the PR"
         : "push the existing PR branch";
-    return [
+    const lines = [
         "## Final Self-Review Before Push",
         "",
         `Before you ${publishTarget}, do one brief reviewer-minded pass on the current head.`,
         "Fix any likely in-scope blocker you can see now: missing edge-case handling, broken adjacent invariant in the touched flow, mismatch between the PR explanation and the code, or an obviously unreviewable half-finished branch.",
-        "Do not widen scope for optional cleanup. If the issue explicitly allows a non-PR outcome, complete that outcome clearly; otherwise publish before stopping.",
     ];
+    if (runType === "implementation") {
+        lines.push("Name 2-4 concrete invariants most likely to regress in the touched flow, confirm which file or path enforces each one, and verify at least one adjacent path you did not edit directly.", "If you changed schema, enums, shared vocabulary, normalization helpers, or compatibility mappings, inspect the main read/write paths that can bypass the new abstraction and verify one legacy-flow and one new-flow case before publishing.");
+    }
+    lines.push("Do not widen scope for optional cleanup. If the issue explicitly allows a non-PR outcome, complete that outcome clearly; otherwise publish before stopping.");
+    return lines;
 }
 function buildPublicationContract(runType, issueClass) {
     if (issueClass === "orchestration") {
@@ -471,7 +507,7 @@ function buildPublicationContract(runType, issueClass) {
             "If this is code-delivery work, publish before stopping: commit, push the issue branch, and open or update the PR.",
             "If the issue explicitly allows a non-PR outcome, complete that outcome clearly instead of inventing a PR.",
             "",
-            ...buildPrePushSelfReviewSection("new_pr"),
+            ...buildPrePushSelfReviewSection("new_pr", runType),
         ].join("\n");
     }
     return [
@@ -481,7 +517,7 @@ function buildPublicationContract(runType, issueClass) {
         "Do not open a new PR.",
         "A PR-less stop is not a successful outcome for a repair run unless a genuine external blocker prevents any correct push.",
         "",
-        ...buildPrePushSelfReviewSection("existing_pr"),
+        ...buildPrePushSelfReviewSection("existing_pr", runType),
     ].join("\n");
 }
 function buildSections(issue, runType, repoPath, context, followUp = false) {

package/package.json

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