patchrelay 0.74.1 → 0.74.3

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.74.1",
-  "commit": "7763c9d8b14a",
-  "builtAt": "2026-05-28T19:52:29.055Z"
+  "version": "0.74.3",
+  "commit": "21e6267a7b1c",
+  "builtAt": "2026-05-28T21:47:39.635Z"
 }

package/dist/cli/data.js

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

package/dist/codex-app-server.js

@@ -9,14 +9,6 @@ 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");
 const ISSUE_TRIAGE_DEVELOPER_INSTRUCTIONS = [
     "You are PatchRelay's issue triage classifier.",
     "This is a read-only preflight step used only to choose the execution shape for one Linear issue.",
@@ -202,14 +194,6 @@ 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

@@ -116,6 +116,7 @@ export function deriveSessionWakePlan(issue, events) {
                 else {
                     eventIds.push(event.id);
                 }
+                Object.assign(context, payload ?? {});
                 if (typeof payload?.summary === "string" && payload.summary.trim()) {
                     context.completionCheckSummary = payload.summary.trim();
                 }
@@ -187,6 +188,9 @@ export function extractLatestAssistantSummary(run) {
     if (run.summaryJson) {
         try {
             const parsed = JSON.parse(run.summaryJson);
+            if (typeof parsed.outcomeSummary === "string" && parsed.outcomeSummary.trim()) {
+                return sanitizeOperatorFacingText(parsed.outcomeSummary);
+            }
             if (typeof parsed.publicationRecapSummary === "string" && parsed.publicationRecapSummary.trim()) {
                 return sanitizeOperatorFacingText(parsed.publicationRecapSummary);
             }

package/dist/linear-progress-facts.js

@@ -23,6 +23,9 @@ function deriveProgressFactFromCompletedItem(rawItem, issue) {
         return undefined;
     }
     const ephemeralBody = compactOperatorSentence(fullBody) ?? fullBody;
+    if (looksLikeOperationalChatter(fullBody)) {
+        return undefined;
+    }
     if (looksLikeVerification(fullBody)) {
         return {
             kind: "verification_started",
@@ -131,6 +134,16 @@ function looksLikePublishing(text) {
         || normalized.includes("opening the pr")
         || normalized.includes("opening pull request");
 }
+function looksLikeOperationalChatter(text) {
+    const normalized = text.toLowerCase().replace(/\s+/g, " ").trim();
+    const firstPerson = /\b(i('|’)m|i am|i('|’)ll|i will|i need|i’m|i’ll)\b/.test(normalized);
+    const operational = /\b(waiting|watching|checking|running|rerunning|pushing|publishing|creating|opening|committing|preparing|verification|publish pass|push)\b/.test(normalized);
+    return (firstPerson && operational)
+        || /^(i('|’)m|i am|i('|’)ll|i will|i need|i’m|i’ll)\b/.test(normalized)
+        || /^(continuing|resuming) from\b/.test(normalized)
+        || /\b(i('|’)m|i am|i('|’)ll|i will|i need|i’m|i’ll)\s+(waiting|watching|checking|running|rerunning|pushing|publishing|creating|opening|committing)\b/.test(normalized)
+        || /\b(is|are)\s+(now\s+)?(running|still running|in progress)\b/.test(normalized);
+}
 function compactOperatorSentence(text, maxLength = 160) {
     const sanitized = sanitizeOperatorFacingText(text)?.replace(/\s+/g, " ").trim();
     if (!sanitized) {

package/dist/linear-session-reporting.js

@@ -108,14 +108,13 @@ export function buildRunStartedActivity(runType) {
 }
 export function buildReviewRoundStartedActivity(params) {
     const reviewer = params.reviewerName ? ` from @${params.reviewerName}` : "";
-    const head = params.headSha ? ` on head ${params.headSha.slice(0, 8)}` : "";
     const comments = params.commentCount !== undefined
         ? `; ${params.commentCount} inline comment${params.commentCount === 1 ? "" : "s"} captured`
         : "";
     return {
         type: "action",
         action: "Review round",
-        parameter: `${params.round}${reviewer}${head}${comments}`,
+        parameter: `${params.round}${reviewer}${comments}`,
     };
 }
 function formatFactoryState(state) {
@@ -123,13 +122,13 @@ function formatFactoryState(state) {
 }
 export function buildRunCompletedActivity(params) {
     const prLabel = params.prNumber ? `PR #${params.prNumber}` : "the pull request";
-    const summary = trimSummary(params.completionSummary);
+    const summary = cleanOutcomeSummary(trimSummary(params.completionSummary));
     const detail = summary ? ` ${summary}` : "";
     const steeringSummary = buildSteeringSummary(params.steeringDeliveredCount, params.steeringFailedCount);
     switch (params.runType) {
         case "implementation":
             if (params.postRunState === "pr_open") {
-                const body = `${prLabel} opened:${detail || " Published and ready for review."}`;
+                const body = `${prLabel} opened:${detail || " Ready for review."}`;
                 return {
                     type: "response",
                     body: steeringSummary ? `${body}\n\n${steeringSummary}` : body,
@@ -140,15 +139,10 @@ export function buildRunCompletedActivity(params) {
             {
                 const lines = [];
                 lines.push(params.reviewRound ? `Review round ${params.reviewRound} completed.` : "Review fix completed.");
-                if (params.resultHeadSha)
-                    lines.push(`Resulting head: ${params.resultHeadSha.slice(0, 8)}.`);
                 if (steeringSummary)
                     lines.push(steeringSummary);
-                const resolution = buildReviewResolutionSections(summary);
-                lines.push("", "Addressed:", resolution.addressed, "", "Deferred:", resolution.deferred, "", "Not applicable:", resolution.notApplicable);
-                if (!summary && !params.resultHeadSha) {
-                    lines[0] = `Updated ${prLabel} to address review feedback.`;
-                }
+                const addressed = summary ? `- ${summary}` : "- Review feedback addressed.";
+                lines.push("", "Addressed:", addressed);
                 return {
                     type: "response",
                     body: lines.join("\n").trim(),
@@ -196,6 +190,15 @@ export function buildRunCompletedActivity(params) {
         }
     }
 }
+function cleanOutcomeSummary(summary) {
+    if (!summary)
+        return undefined;
+    return summary
+        .replace(/\s*(?:,?\s*(?:and|then)\s+)?(?:force-)?pushed(?:\s+(?:a\s+)?(?:new\s+)?head|\s+the\s+branch|\s+changes|\s+an?\s+update|\s+the\s+repaired\s+branch)?\.?$/i, ".")
+        .replace(/\s*(?:,?\s*(?:and|then)\s+)?published(?:\s+(?:a\s+)?(?:new\s+)?head|\s+the\s+branch|\s+changes|\s+an?\s+update)?\.?$/i, ".")
+        .replace(/\.\.+$/, ".")
+        .trim();
+}
 function buildSteeringSummary(delivered = 0, failed = 0) {
     if (delivered === 0 && failed === 0)
         return undefined;
@@ -208,20 +211,6 @@ function buildSteeringSummary(delivered = 0, failed = 0) {
     }
     return `Steering: ${parts.join("; ")}.`;
 }
-function buildReviewResolutionSections(summary) {
-    if (!summary) {
-        return {
-            addressed: "- Review feedback addressed and published.",
-            deferred: "- None reported.",
-            notApplicable: "- None reported.",
-        };
-    }
-    return {
-        addressed: `- ${summary}`,
-        deferred: "- None reported.",
-        notApplicable: "- None reported.",
-    };
-}
 export function buildRunFailureActivity(runType, reason) {
     const label = formatRunTypeLabel(runType);
     return {

package/dist/prompting/patchrelay.js

@@ -421,6 +421,22 @@ function buildFollowUpContextLines(issue, runType, context) {
     if (wakeReason === "completion_check_continue" && typeof context?.completionCheckSummary === "string" && context.completionCheckSummary.trim()) {
         lines.push(`Completion check summary: ${context.completionCheckSummary.trim()}`);
     }
+    if (context?.preserveDirtyWorktree === true) {
+        lines.push("", "Unpublished local work:", "PatchRelay detected that the previous repair turn ended with uncommitted changes in this worktree.", "Do not reset, clean, stash-drop, or otherwise discard the current worktree. Inspect the existing local diff, keep the intended in-scope repair, then commit and push a fresh PR head.");
+        if (typeof context.dirtyWorktreeSummary === "string" && context.dirtyWorktreeSummary.trim()) {
+            lines.push(`Dirty worktree summary: ${context.dirtyWorktreeSummary.trim()}`);
+        }
+        const changedPaths = Array.isArray(context.dirtyWorktreeChangedPaths)
+            ? context.dirtyWorktreeChangedPaths.filter((entry) => typeof entry === "string" && entry.trim().length > 0)
+            : [];
+        if (changedPaths.length > 0) {
+            lines.push("Changed paths:");
+            changedPaths.slice(0, 12).forEach((entry) => lines.push(`- ${entry}`));
+            if (changedPaths.length > 12) {
+                lines.push(`- ...and ${changedPaths.length - 12} more`);
+            }
+        }
+    }
     if (followUpLines.length > 0) {
         lines.push("", "Recent updates:");
         followUpLines.forEach((line) => lines.push(`- ${line}`));
@@ -567,6 +583,8 @@ function buildPublicationContract(runType, issueClass, context) {
         "Do not run blocking wait commands such as `gh pr checks --watch`, `gh pr view` polling loops, `review-quill pr status --wait`, `merge-steward pr status --wait`, or `gh pr merge` from the agent turn.",
         "PatchRelay receives GitHub webhooks for check, review, and base-branch changes; those events will re-enter automation if more work is needed.",
         "If the issue text asks you to watch CI, wait for approval, or merge after checks pass, treat that as PatchRelay service responsibility rather than agent-turn work.",
+        "Keep reactive repairs narrow: do not run TypeScript, lint, full test suites, Playwright, browser UI suites, or screenshot capture unless the human explicitly asks for that evidence, the reviewer specifically asks for a screenshot or visual proof, or the reactive failure is itself from that exact check.",
+        "Use code inspection and the smallest directly relevant command only when it materially reduces risk. If the repair is a tiny reviewer-requested edit, commit and push the fresh head without broad local verification.",
         "",
         ...(requiresFreshQueueHead
             ? [

package/dist/run-finalizer.js

@@ -4,6 +4,7 @@ import { handleNoPrCompletionCheck } from "./no-pr-completion-check.js";
 import { resolveCompletedRunState } from "./run-completion-policy.js";
 import { computeChangeIdentityFromWorktree } from "./change-identity.js";
 import { inspectGitWorktreeStatus, isRepairRunType } from "./git-worktree-status.js";
+import { buildRunOutcomeSummary } from "./run-outcome-summary.js";
 function parseEventJson(eventJson) {
     if (!eventJson)
         return undefined;
@@ -15,10 +16,12 @@ function parseEventJson(eventJson) {
         return undefined;
     }
 }
-function buildRunSummaryJson(report, publicationRecapSummary) {
+function buildRunSummaryJson(report, outcomeSummary) {
     return JSON.stringify({
         latestAssistantMessage: report.assistantMessages.at(-1) ?? null,
-        publicationRecapSummary: publicationRecapSummary ?? null,
+        outcomeSummary: outcomeSummary ?? null,
+        // Backward compatibility for older CLI/status readers.
+        publicationRecapSummary: outcomeSummary ?? null,
     });
 }
 function summarizePromptDeliveryEvents(events, run) {
@@ -39,13 +42,6 @@ function summarizePromptDeliveryEvents(events, run) {
     }
     return { delivered, failed };
 }
-function shouldGeneratePublicationRecap(runType) {
-    return runType === "implementation"
-        || runType === "review_fix"
-        || runType === "branch_upkeep"
-        || runType === "ci_repair"
-        || runType === "queue_repair";
-}
 export class RunFinalizer {
     db;
     logger;
@@ -57,9 +53,8 @@ export class RunFinalizer {
     failRunAndClear;
     completionPolicy;
     completionCheck;
-    publicationRecap;
     feed;
-    constructor(db, logger, linearSync, wakeDispatcher, withHeldLease, releaseLease, appendWakeEventWithLease, failRunAndClear, completionPolicy, completionCheck, publicationRecap, feed) {
+    constructor(db, logger, linearSync, wakeDispatcher, withHeldLease, releaseLease, appendWakeEventWithLease, failRunAndClear, completionPolicy, completionCheck, feed) {
         this.db = db;
         this.logger = logger;
         this.linearSync = linearSync;
@@ -70,7 +65,6 @@ export class RunFinalizer {
         this.failRunAndClear = failRunAndClear;
         this.completionPolicy = completionPolicy;
         this.completionCheck = completionCheck;
-        this.publicationRecap = publicationRecap;
         this.feed = feed;
     }
     buildCompletedRunUpdate(params) {
@@ -78,7 +72,7 @@ export class RunFinalizer {
             status: "completed",
             threadId: params.threadId,
             ...(params.completedTurnId ? { turnId: params.completedTurnId } : {}),
-            summaryJson: buildRunSummaryJson(params.report, params.publicationRecapSummary),
+            summaryJson: buildRunSummaryJson(params.report, params.outcomeSummary),
             reportJson: JSON.stringify(params.report),
         };
     }
@@ -88,7 +82,7 @@ export class RunFinalizer {
             .filter((event) => event.consumedByRunId === run.id)
             .at(-1);
     }
-    resolvePublicationRecapFacts(params) {
+    resolveRunOutcomeFacts(params) {
         const session = this.db.issueSessions.getIssueSession(params.run.projectId, params.run.linearIssueId);
         const facts = {
             ...(session?.lastWakeReason ? { wakeReason: session.lastWakeReason } : {}),
@@ -125,31 +119,16 @@ export class RunFinalizer {
                 return facts;
         }
     }
-    async generatePublicationRecap(params) {
-        if (!this.publicationRecap || !shouldGeneratePublicationRecap(params.run.runType)) {
-            return undefined;
-        }
-        try {
-            const result = await this.publicationRecap.run({
-                issue: params.issue,
+    buildOutcomeSummary(params) {
+        return buildRunOutcomeSummary({
+            runType: params.run.runType,
+            facts: this.resolveRunOutcomeFacts({
                 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;
-        }
+                issue: params.issue,
+                postRunState: params.postRunState,
+                latestAssistantSummary: params.latestAssistantSummary,
+            }),
+        });
     }
     // Plan §4.2(c): record the identity of the head we just published
     // so subsequent runs can recognize a patch-id-equivalent re-push.
@@ -274,15 +253,77 @@ export class RunFinalizer {
         // exists. Keeping the parameter would be redundant.
         this.clearProgressAndRelease(params.run);
     }
-    verifyRepairWorktreeClean(run, issue) {
+    inspectDirtyRepairWorktree(run, issue) {
         if (!isRepairRunType(run.runType) || !issue.worktreePath)
             return undefined;
         const status = inspectGitWorktreeStatus(issue.worktreePath);
         if (!status.dirty)
             return undefined;
-        return status.summary
-            ? `Repair run finished with a dirty worktree; ${status.summary}`
+        return status;
+    }
+    continueDirtyRepairWorktree(params) {
+        const message = params.status.summary
+            ? `Repair run finished with a dirty worktree; ${params.status.summary}`
             : "Repair run finished with a dirty worktree";
+        const outcomeSummary = "Repair left unpublished local changes; continuing automatically to publish them.";
+        const continued = this.withHeldLease(params.run.projectId, params.run.linearIssueId, (lease) => {
+            this.db.runs.finishRun(params.run.id, this.buildCompletedRunUpdate({
+                threadId: params.threadId,
+                ...(params.completedTurnId ? { completedTurnId: params.completedTurnId } : {}),
+                report: params.report,
+                outcomeSummary,
+            }));
+            this.db.issueSessions.upsertIssueWithLease(lease, {
+                projectId: params.run.projectId,
+                linearIssueId: params.run.linearIssueId,
+                activeRunId: null,
+                factoryState: "delegated",
+                pendingRunType: null,
+                pendingRunContextJson: null,
+                ...(params.run.runType === "ci_repair" && params.issue.ciRepairAttempts > 0
+                    ? { ciRepairAttempts: params.issue.ciRepairAttempts - 1 }
+                    : {}),
+                ...(params.run.runType === "queue_repair" && params.issue.queueRepairAttempts > 0
+                    ? { queueRepairAttempts: params.issue.queueRepairAttempts - 1 }
+                    : {}),
+                ...((params.run.runType === "review_fix" || params.run.runType === "branch_upkeep") && params.issue.reviewFixAttempts > 0
+                    ? { reviewFixAttempts: params.issue.reviewFixAttempts - 1 }
+                    : {}),
+            });
+            return Boolean(this.db.issueSessions.appendIssueSessionEventWithLease(lease, {
+                projectId: params.run.projectId,
+                linearIssueId: params.run.linearIssueId,
+                eventType: "completion_check_continue",
+                eventJson: JSON.stringify({
+                    runType: params.run.runType,
+                    summary: message,
+                    preserveDirtyWorktree: true,
+                    dirtyWorktreeSummary: params.status.summary,
+                    dirtyWorktreeChangedPaths: params.status.changedPaths,
+                    dirtyWorktreeMergeInProgress: params.status.mergeInProgress,
+                }),
+                dedupeKey: `dirty_repair_continue:${params.run.id}`,
+            }));
+        });
+        if (!continued) {
+            this.logger.warn({ runId: params.run.id, issueId: params.run.linearIssueId }, "Skipping dirty-repair continuation after losing issue-session lease");
+            this.clearProgressAndRelease(params.run);
+            return;
+        }
+        this.publishTurnEvent({
+            level: "warn",
+            run: params.run,
+            issueKey: params.issue.issueKey,
+            status: "dirty_repair_continue",
+            summary: "Repair left unpublished local changes; continuing automatically",
+            detail: message,
+        });
+        void this.linearSync.emitActivity(params.issue, {
+            type: "thought",
+            body: "PatchRelay found unpublished repair changes and is continuing automatically to commit and push them.",
+        }, { ephemeral: true });
+        void this.linearSync.syncSession(params.issue, { activeRunType: params.run.runType });
+        this.clearProgressAndRelease(params.run);
     }
     async finalizeCompletedRun(params) {
         const { run, issue, thread, threadId } = params;
@@ -302,16 +343,15 @@ export class RunFinalizer {
         const trackedIssue = this.db.issueToTrackedIssue(issue);
         const report = buildStageReport({ ...run, status: "completed" }, trackedIssue, thread, countEventMethods(this.db.runs.listThreadEvents(run.id)));
         const freshIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
-        const dirtyRepairWorktreeError = this.verifyRepairWorktreeClean(run, freshIssue);
-        if (dirtyRepairWorktreeError) {
-            this.failRunAndClear(run, dirtyRepairWorktreeError, "escalated");
-            this.syncFailureOutcome({
+        const dirtyRepairWorktree = this.inspectDirtyRepairWorktree(run, freshIssue);
+        if (dirtyRepairWorktree) {
+            this.continueDirtyRepairWorktree({
                 run,
-                fallbackIssue: freshIssue,
-                message: dirtyRepairWorktreeError,
-                level: "error",
-                status: "dirty_repair_worktree",
-                summary: dirtyRepairWorktreeError,
+                issue: freshIssue,
+                status: dirtyRepairWorktree,
+                threadId,
+                ...(params.completedTurnId ? { completedTurnId: params.completedTurnId } : {}),
+                report,
             });
             return;
         }
@@ -388,7 +428,7 @@ export class RunFinalizer {
         this.maybeUpdateLastPublishedIdentity(run, refreshedIssue);
         const postRunFollowUp = await this.completionPolicy.resolvePostRunFollowUp(run, refreshedIssue);
         const postRunState = postRunFollowUp?.factoryState ?? resolveCompletedRunState(refreshedIssue, run);
-        const publicationRecapSummary = await this.generatePublicationRecap({
+        const outcomeSummary = this.buildOutcomeSummary({
             run,
             issue: refreshedIssue,
             postRunState,
@@ -399,7 +439,7 @@ export class RunFinalizer {
                 threadId,
                 ...(params.completedTurnId ? { completedTurnId: params.completedTurnId } : {}),
                 report,
-                publicationRecapSummary,
+                outcomeSummary,
             }));
             this.db.issues.upsertIssue({
                 projectId: run.projectId,
@@ -453,12 +493,10 @@ export class RunFinalizer {
             summary: params.source === "notification"
                 ? `Turn completed for ${run.runType}`
                 : `Reconciliation: ${run.runType} completed${postRunState ? ` -> ${postRunState}` : ""}`,
-            detail: publicationRecapSummary ?? report.assistantMessages.at(-1),
+            detail: outcomeSummary,
         });
         const updatedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? refreshedIssue;
-        const completionSummary = publicationRecapSummary
-            ?? report.assistantMessages.at(-1)?.slice(0, 300)
-            ?? `${run.runType} completed.`;
+        const completionSummary = outcomeSummary;
         const steeringSummary = summarizePromptDeliveryEvents(this.db.issueSessions.listIssueSessionEvents(run.projectId, run.linearIssueId), run);
         const linearActivity = buildRunCompletedActivity({
             runType: run.runType,
@@ -466,7 +504,6 @@ export class RunFinalizer {
             postRunState: updatedIssue.factoryState,
             ...(updatedIssue.prNumber !== undefined ? { prNumber: updatedIssue.prNumber } : {}),
             ...(run.runType === "review_fix" ? { reviewRound: Math.max(1, updatedIssue.reviewFixAttempts) } : {}),
-            ...(run.runType === "review_fix" && updatedIssue.prHeadSha ? { resultHeadSha: updatedIssue.prHeadSha } : {}),
             ...(steeringSummary.delivered > 0 ? { steeringDeliveredCount: steeringSummary.delivered } : {}),
             ...(steeringSummary.failed > 0 ? { steeringFailedCount: steeringSummary.failed } : {}),
         });

package/dist/run-launcher.js

@@ -41,6 +41,9 @@ export function shouldReuseIssueThread(params) {
     return Boolean(params.existingThreadId) && !params.compactThread && params.resumeThread;
 }
 export function shouldFreshenWorktreeBeforeLaunch(params) {
+    if (shouldPreserveDirtyWorktreeBeforeLaunch(params)) {
+        return false;
+    }
     if (params.runType === "queue_repair") {
         return false;
     }
@@ -50,6 +53,13 @@ export function shouldFreshenWorktreeBeforeLaunch(params) {
     }
     return true;
 }
+export function shouldPreserveDirtyWorktreeBeforeLaunch(params) {
+    return params.effectiveContext?.preserveDirtyWorktree === true
+        && (params.runType === "review_fix"
+            || params.runType === "branch_upkeep"
+            || params.runType === "ci_repair"
+            || params.runType === "queue_repair");
+}
 export class RunLauncher {
     config;
     db;
@@ -154,7 +164,16 @@ export class RunLauncher {
             // process env (GH_CONFIG_DIR + gh credential helper + GIT_AUTHOR/COMMITTER). Nothing
             // is written into the worktree git config, so credentials never leak into interactive
             // shell sessions on the shared clone.
-            await this.worktreeManager.resetWorktreeToTrackedBranch(params.worktreePath, params.branchName, params.issue, this.logger);
+            const preserveDirtyWorktree = shouldPreserveDirtyWorktreeBeforeLaunch({
+                runType: params.runType,
+                ...(params.effectiveContext ? { effectiveContext: params.effectiveContext } : {}),
+            });
+            if (preserveDirtyWorktree) {
+                this.logger.warn({ issueKey: params.issue.issueKey, runType: params.runType, worktreePath: params.worktreePath }, "Preserving dirty repair worktree for automatic publication continuation");
+            }
+            else {
+                await this.worktreeManager.resetWorktreeToTrackedBranch(params.worktreePath, params.branchName, params.issue, this.logger);
+            }
             if (shouldFreshenWorktreeBeforeLaunch({
                 runType: params.runType,
                 ...(params.effectiveContext ? { effectiveContext: params.effectiveContext } : {}),

package/dist/run-orchestrator.js

@@ -1,7 +1,6 @@
 import { summarizeCurrentThread } from "./run-reporting.js";
 import { buildReviewRoundStartedActivity, 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 { QueueHealthMonitor } from "./queue-health-monitor.js";
@@ -62,7 +61,6 @@ export class RunOrchestrator {
     interruptedRunRecovery;
     runCompletionPolicy;
     completionCheck;
-    publicationRecap;
     issueTriage;
     runNotificationHandler;
     runReconciler;
@@ -125,9 +123,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.publicationRecap = new PublicationRecapService(codex, logger);
         this.issueTriage = new IssueTriageService(codex, logger);
-        this.runFinalizer = new RunFinalizer(db, logger, this.linearSync, this.wakeDispatcher, 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.runFinalizer = new RunFinalizer(db, logger, this.linearSync, this.wakeDispatcher, 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.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, { interruptTurn: (options) => codex.interruptTurn(options) });
         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/run-outcome-summary.js

@@ -0,0 +1,89 @@
+import { sanitizeOperatorFacingText } from "./presentation-text.js";
+export function buildRunOutcomeSummary(params) {
+    switch (params.runType) {
+        case "implementation":
+            return summarizeImplementation(params.facts.postRunState);
+        case "review_fix":
+            return summarizeReviewFix(params.facts);
+        case "ci_repair":
+            return summarizeCiRepair(params.facts);
+        case "queue_repair":
+            return summarizeQueueRepair(params.facts);
+        case "branch_upkeep":
+            return "Branch updated.";
+    }
+}
+function summarizeImplementation(postRunState) {
+    switch (postRunState) {
+        case "awaiting_queue":
+            return "Ready for merge.";
+        case "done":
+            return "Completed.";
+        case "pr_open":
+        default:
+            return "Ready for review.";
+    }
+}
+function summarizeReviewFix(facts) {
+    const concern = summarizeKnownConcern(facts.reviewSummary);
+    return concern ? rewriteConcernAsOutcome(concern) : "Review feedback addressed.";
+}
+function summarizeCiRepair(facts) {
+    const check = sanitizeOperatorFacingText(facts.failingCheckName)?.replace(/\s+/g, " ").trim();
+    if (check) {
+        return `${check} fixed.`;
+    }
+    const concern = summarizeKnownConcern(facts.failureSummary);
+    if (concern) {
+        return rewriteConcernAsOutcome(concern);
+    }
+    return "CI fixed.";
+}
+function summarizeQueueRepair(facts) {
+    const concern = summarizeKnownConcern(facts.queueIncidentSummary);
+    if (concern) {
+        return rewriteConcernAsOutcome(concern);
+    }
+    return "Merge queue issue resolved.";
+}
+function summarizeKnownConcern(value) {
+    const sanitized = sanitizeOperatorFacingText(value)?.replace(/\s+/g, " ").trim();
+    if (!sanitized) {
+        return undefined;
+    }
+    const stripped = sanitized
+        .replace(/^please\s+/i, "")
+        .replace(/[.]+$/, "")
+        .trim();
+    if (!stripped) {
+        return undefined;
+    }
+    return stripped.length <= 80 ? stripped : `${stripped.slice(0, 80).trimEnd()}...`;
+}
+function rewriteConcernAsOutcome(concern) {
+    const normalized = concern.trim().replace(/[.]+$/, "");
+    const tightened = normalized.match(/^tighten\s+(.+)$/i);
+    if (tightened?.[1]) {
+        return `${capitalizeFirst(stripLeadingArticle(tightened[1]))} tightened.`;
+    }
+    const fixed = normalized.match(/^(fix|repair)\s+(.+)$/i);
+    if (fixed?.[2]) {
+        return `${capitalizeFirst(stripLeadingArticle(fixed[2]))} fixed.`;
+    }
+    const resolved = normalized.match(/^resolve\s+(.+)$/i);
+    if (resolved?.[1]) {
+        return `${capitalizeFirst(stripLeadingArticle(resolved[1]))} resolved.`;
+    }
+    const updated = normalized.match(/^update\s+(.+)$/i);
+    if (updated?.[1]) {
+        return `${capitalizeFirst(stripLeadingArticle(updated[1]))} updated.`;
+    }
+    return `${capitalizeFirst(normalized)}.`;
+}
+function capitalizeFirst(value) {
+    const trimmed = value.trim();
+    return trimmed ? `${trimmed.slice(0, 1).toUpperCase()}${trimmed.slice(1)}` : trimmed;
+}
+function stripLeadingArticle(value) {
+    return value.trim().replace(/^the\s+/i, "");
+}

package/package.json

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

package/dist/publication-recap.js

@@ -1,113 +0,0 @@
-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 };
-}