patchrelay 0.74.0 → 0.74.2

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.74.0",
-  "commit": "d04d91223dec",
-  "builtAt": "2026-05-28T18:16:54.428Z"
+  "version": "0.74.2",
+  "commit": "5e2c2733aa21",
+  "builtAt": "2026-05-28T21:38:50.236Z"
 }

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();
     }
@@ -98,6 +101,9 @@ export class CliDataAccess extends CliOperatorApiClient {
         super(config);
         this.config = config;
         this.db = options?.db ?? new PatchRelayDatabase(config.database.path, config.database.wal);
+        if (!options?.db) {
+            this.db.assertSchemaReady();
+        }
         this.codex = options?.codex;
     }
     close() {

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/db/schema-guard.js

@@ -0,0 +1,17 @@
+const REQUIRED_PATCHRELAY_TABLES = [
+    "issues",
+    "runs",
+    "issue_sessions",
+    "issue_session_events",
+];
+export function assertPatchRelaySchemaReady(connection, databasePath) {
+    const rows = connection
+        .prepare("SELECT name FROM sqlite_master WHERE type = 'table'")
+        .all();
+    const tables = new Set(rows.map((row) => String(row.name)));
+    const missing = REQUIRED_PATCHRELAY_TABLES.filter((table) => !tables.has(table));
+    if (missing.length === 0) {
+        return;
+    }
+    throw new Error(`PatchRelay database is uninitialized or points at the wrong path: ${databasePath}. Missing required table(s): ${missing.join(", ")}`);
+}

package/dist/db.js

@@ -7,6 +7,7 @@ import { RepositoryLinkStore } from "./db/repository-link-store.js";
 import { RunStore } from "./db/run-store.js";
 import { WebhookEventStore } from "./db/webhook-event-store.js";
 import { runPatchRelayMigrations } from "./db/migrations.js";
+import { assertPatchRelaySchemaReady } from "./db/schema-guard.js";
 import { SqliteConnection } from "./db/shared.js";
 import { syncIssueSessionFromIssue } from "./issue-session-projector.js";
 import { TrackedIssueQuery } from "./tracked-issue-query.js";
@@ -23,6 +24,7 @@ export class PatchRelayDatabase {
     runs;
     trackedIssues;
     constructor(databasePath, wal) {
+        this.databasePath = databasePath;
         this.connection = new SqliteConnection(databasePath);
         this.connection.pragma("foreign_keys = ON");
         if (wal) {
@@ -45,8 +47,13 @@ export class PatchRelayDatabase {
         this.workflowWakes = new WorkflowWakeResolver(this.issues, this.issueSessions);
         this.trackedIssues = new TrackedIssueQuery(this.issues, this.issueSessions, this.workflowWakes, this.runs);
     }
+    databasePath;
     runMigrations() {
         runPatchRelayMigrations(this.connection);
+        this.assertSchemaReady();
+    }
+    assertSchemaReady() {
+        assertPatchRelaySchemaReady(this.connection, this.databasePath);
     }
     transaction(fn) {
         return this.connection.transaction(fn)();

package/dist/github-cli-auth.js

@@ -1,5 +1,6 @@
 import { existsSync } from "node:fs";
 import { mkdir, writeFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
 import path from "node:path";
 /**
  * Unified GitHub App credential delivery for `git` and the `gh` CLI.
@@ -88,3 +89,45 @@ export function buildAgentChildEnv(parentEnv = process.env) {
     delete env.GITHUB_TOKEN;
     return env;
 }
+export async function verifyGitHubCliAuthEnv(env = process.env, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 10_000;
+    await new Promise((resolve, reject) => {
+        const child = spawn("git", ["credential", "fill"], {
+            env,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        let stderr = "";
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            child.kill("SIGTERM");
+            reject(new Error(`GitHub git credential check timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        timer.unref?.();
+        child.stderr.on("data", (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on("error", (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.on("close", (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            const detail = stderr.trim();
+            reject(new Error(`GitHub git credential check failed${detail ? `: ${detail}` : ""}`));
+        });
+        child.stdin.end(`protocol=https\nhost=${GITHUB_HOST}\n\n`);
+    });
+}

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/preflight.js

@@ -1,6 +1,7 @@
 import { accessSync, constants, existsSync, mkdirSync, statSync } from "node:fs";
 import path from "node:path";
 import { runPatchRelayMigrations } from "./db/migrations.js";
+import { assertPatchRelaySchemaReady } from "./db/schema-guard.js";
 import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
 import { SqliteConnection } from "./db/shared.js";
 import { execCommand } from "./utils.js";
@@ -132,6 +133,7 @@ function checkDatabaseHealth(config) {
             connection.pragma("journal_mode = WAL");
         }
         runPatchRelayMigrations(connection);
+        assertPatchRelaySchemaReady(connection, config.database.path);
         const quickCheck = connection.prepare("PRAGMA quick_check").get();
         const quickCheckResult = quickCheck ? Object.values(quickCheck)[0] : undefined;
         if (quickCheckResult !== "ok") {

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}`));

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-notification-handler.js

@@ -4,6 +4,7 @@ import { resolveRecoverablePostRunState } from "./interrupted-run-recovery.js";
 function isRequestedChangesRunType(runType) {
     return runType === "review_fix" || runType === "branch_upkeep";
 }
+const DEFAULT_PUBLISH_COMMAND_TIMEOUT_MS = 10 * 60 * 1000;
 export class RunNotificationHandler {
     config;
     db;
@@ -15,8 +16,10 @@ export class RunNotificationHandler {
     heartbeatIssueSessionLease;
     releaseIssueSessionLease;
     feed;
+    options;
     activeThreadId;
-    constructor(config, db, logger, linearSync, runFinalizer, readThreadWithRetry, withHeldIssueSessionLease, heartbeatIssueSessionLease, releaseIssueSessionLease, feed) {
+    publishCommandWatchdogs = new Map();
+    constructor(config, db, logger, linearSync, runFinalizer, readThreadWithRetry, withHeldIssueSessionLease, heartbeatIssueSessionLease, releaseIssueSessionLease, feed, options = {}) {
         this.config = config;
         this.db = db;
         this.logger = logger;
@@ -27,6 +30,7 @@ export class RunNotificationHandler {
         this.heartbeatIssueSessionLease = heartbeatIssueSessionLease;
         this.releaseIssueSessionLease = releaseIssueSessionLease;
         this.feed = feed;
+        this.options = options;
     }
     async handle(notification) {
         let threadId = typeof notification.params.threadId === "string" ? notification.params.threadId : undefined;
@@ -50,6 +54,7 @@ export class RunNotificationHandler {
             return;
         }
         const turnId = typeof notification.params.turnId === "string" ? notification.params.turnId : undefined;
+        this.observePublishCommand(notification, run, threadId, turnId ?? run.turnId);
         if (this.config.runner.codex.persistExtendedHistory) {
             this.db.runs.saveThreadEvent({
                 runId: run.id,
@@ -59,15 +64,13 @@ export class RunNotificationHandler {
                 eventJson: JSON.stringify(notification.params),
             });
         }
-        this.linearSync.maybeEmitProgress(notification, run);
+        this.maybeEmitProgress(notification, run);
         if (notification.method === "turn/plan/updated") {
-            const issue = this.db.issues.getIssue(run.projectId, run.linearIssueId);
-            if (issue) {
-                void this.linearSync.syncCodexPlan(issue, notification.params);
-            }
+            this.syncCodexPlan(notification, run);
         }
         if (notification.method !== "turn/completed")
             return;
+        this.clearPublishWatchdogsForThread(threadId);
         const thread = await this.readThreadWithRetry(threadId);
         const issue = this.db.issues.getIssue(run.projectId, run.linearIssueId);
         if (!issue)
@@ -137,4 +140,120 @@ export class RunNotificationHandler {
         });
         this.activeThreadId = undefined;
     }
+    observePublishCommand(notification, run, threadId, turnId) {
+        const item = notification.params.item;
+        if (!item || typeof item !== "object") {
+            return;
+        }
+        const itemRecord = item;
+        const itemId = typeof itemRecord.id === "string" ? itemRecord.id : undefined;
+        if (!itemId) {
+            return;
+        }
+        if (notification.method === "item/completed" || isTerminalItemUpdate(notification.method, itemRecord)) {
+            this.clearPublishWatchdog(threadId, itemId);
+            return;
+        }
+        if (notification.method !== "item/started" || itemRecord.type !== "commandExecution" || !turnId || !this.options.interruptTurn) {
+            return;
+        }
+        const command = extractCommandText(itemRecord.command);
+        if (!command || !isGitPushCommand(command)) {
+            return;
+        }
+        const key = publishWatchdogKey(threadId, itemId);
+        if (this.publishCommandWatchdogs.has(key)) {
+            return;
+        }
+        const timeoutMs = this.options.publishCommandTimeoutMs ?? DEFAULT_PUBLISH_COMMAND_TIMEOUT_MS;
+        const timer = setTimeout(() => {
+            this.publishCommandWatchdogs.delete(key);
+            this.logger.warn({ runId: run.id, projectId: run.projectId, issueId: run.linearIssueId, threadId, turnId, timeoutMs }, "Interrupting stuck git push command");
+            this.feed?.publish({
+                level: "error",
+                kind: "turn",
+                projectId: run.projectId,
+                stage: run.runType,
+                status: "interrupted",
+                summary: `Interrupted stuck publish command after ${Math.round(timeoutMs / 1000)}s`,
+            });
+            void this.options.interruptTurn?.({ threadId, turnId }).catch((error) => {
+                this.logger.warn({ runId: run.id, projectId: run.projectId, issueId: run.linearIssueId, threadId, turnId, error: formatError(error) }, "Failed to interrupt stuck git push command");
+            });
+        }, timeoutMs);
+        timer.unref?.();
+        this.publishCommandWatchdogs.set(key, timer);
+    }
+    clearPublishWatchdog(threadId, itemId) {
+        const key = publishWatchdogKey(threadId, itemId);
+        const timer = this.publishCommandWatchdogs.get(key);
+        if (!timer) {
+            return;
+        }
+        clearTimeout(timer);
+        this.publishCommandWatchdogs.delete(key);
+    }
+    clearPublishWatchdogsForThread(threadId) {
+        for (const [key, timer] of this.publishCommandWatchdogs) {
+            if (!key.startsWith(`${threadId}:`)) {
+                continue;
+            }
+            clearTimeout(timer);
+            this.publishCommandWatchdogs.delete(key);
+        }
+    }
+    maybeEmitProgress(notification, run) {
+        try {
+            this.linearSync.maybeEmitProgress(notification, run);
+        }
+        catch (error) {
+            this.logger.warn({ runId: run.id, projectId: run.projectId, issueId: run.linearIssueId, method: notification.method, error: formatError(error) }, "Linear progress reporting failed");
+        }
+    }
+    syncCodexPlan(notification, run) {
+        let issue;
+        try {
+            issue = this.db.issues.getIssue(run.projectId, run.linearIssueId);
+        }
+        catch (error) {
+            this.logger.warn({ runId: run.id, projectId: run.projectId, issueId: run.linearIssueId, method: notification.method, error: formatError(error) }, "Linear plan sync lookup failed");
+            return;
+        }
+        if (!issue)
+            return;
+        try {
+            void this.linearSync.syncCodexPlan(issue, notification.params).catch((error) => {
+                this.logger.warn({ runId: run.id, issueKey: issue.issueKey, projectId: run.projectId, issueId: run.linearIssueId, method: notification.method, error: formatError(error) }, "Linear plan sync failed");
+            });
+        }
+        catch (error) {
+            this.logger.warn({ runId: run.id, issueKey: issue.issueKey, projectId: run.projectId, issueId: run.linearIssueId, method: notification.method, error: formatError(error) }, "Linear plan sync failed");
+        }
+    }
+}
+function formatError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function publishWatchdogKey(threadId, itemId) {
+    return `${threadId}:${itemId}`;
+}
+function extractCommandText(command) {
+    if (typeof command === "string") {
+        return command;
+    }
+    if (Array.isArray(command)) {
+        return command.map((entry) => String(entry)).join(" ");
+    }
+    return undefined;
+}
+function isGitPushCommand(command) {
+    const normalized = command.replace(/\s+/g, " ").trim();
+    return /(?:^|[;&|({\s])git(?:\s+-C\s+\S+)?\s+push(?:\s|$)/.test(normalized);
+}
+function isTerminalItemUpdate(method, item) {
+    if (method !== "item/updated") {
+        return false;
+    }
+    const status = typeof item.status === "string" ? item.status.toLowerCase() : "";
+    return status === "completed" || status === "failed" || status === "cancelled" || status === "canceled";
 }

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,11 +123,10 @@ 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);
+        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);
         this.interruptedRunRecovery = new InterruptedRunRecovery(db, logger, this.linearSync, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, this.recoveryPorts.failRunAndClear, this.recoveryPorts.restoreIdleWorktree, this.runCompletionPolicy, (projectId, issueId) => this.enqueueIssue(projectId, issueId), feed);
         this.runReconciler = new RunReconciler(db, logger, linearProvider, this.linearSync, this.interruptedRunRecovery, this.runFinalizer, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, this.threadPorts.readThreadWithRetry, this.recoveryPorts.recoverOrEscalate, (projectId) => this.config.projects.find((project) => project.id === projectId)?.github?.repoFullName, 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/dist/service-runtime.js

@@ -65,7 +65,7 @@ export class ServiceRuntime {
     }
     getReadiness() {
         return {
-            ready: this.ready && this.codex.isStarted() && this.linearConnected,
+            ready: this.ready && this.codex.isStarted() && this.linearConnected && this.githubAppAuthHealthy,
             codexStarted: this.codex.isStarted(),
             linearConnected: this.linearConnected,
             githubAppAuthHealthy: this.githubAppAuthHealthy,

package/dist/service.js

@@ -1,5 +1,5 @@
 import { resolveGitHubAppCredentials, createGitHubAppTokenManager, getGitHubAppPaths, } from "./github-app-token.js";
-import { applyGitHubCliAuthEnv, resolveGhBin } from "./github-cli-auth.js";
+import { applyGitHubCliAuthEnv, resolveGhBin, verifyGitHubCliAuthEnv } from "./github-cli-auth.js";
 import { remediateLeakedBotAuth } from "./github-auth-remediation.js";
 import { GitHubWebhookHandler } from "./github-webhook-handler.js";
 import { IssueQueryService } from "./issue-query-service.js";
@@ -149,8 +149,18 @@ export class PatchRelayService {
             this.runtime.setGithubAppAuthHealthy(ghAuthStatus.healthy, ghAuthStatus.lastRefreshError ?? undefined);
             if (!ghAuthStatus.healthy) {
                 this.logger.error({ ghAuthStatus }, "GitHub App auth is NOT healthy at startup — git/gh operations will fail until a token is minted");
+                throw new Error(`GitHub App auth is not healthy at startup: ${ghAuthStatus.lastRefreshError ?? "no fresh installation token"}`);
             }
             else {
+                try {
+                    await verifyGitHubCliAuthEnv(process.env);
+                }
+                catch (error) {
+                    const msg = error instanceof Error ? error.message : String(error);
+                    this.runtime.setGithubAppAuthHealthy(false, msg);
+                    this.logger.error({ error: msg, ghConfigDir }, "GitHub App auth smoke test failed — service will not accept work");
+                    throw error;
+                }
                 this.logger.info({ installationId: ghAuthStatus.installationId, expiresAt: ghAuthStatus.expiresAt }, "GitHub App auth ready — gh + git authenticate as the bot");
             }
             // Clean up credentials older versions persisted into managed repo configs.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchrelay",
-  "version": "0.74.0",
+  "version": "0.74.2",
   "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 };
-}