patchrelay 0.51.5 → 0.52.1

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.51.5",
-  "commit": "fa598553f4b9",
-  "builtAt": "2026-04-22T13:58:38.906Z"
+  "version": "0.52.1",
+  "commit": "ce226d1e6424",
+  "builtAt": "2026-04-22T15:51:04.485Z"
 }

package/dist/linear-progress-facts.js

@@ -18,29 +18,33 @@ function deriveProgressFactFromCompletedItem(rawItem, issue) {
     if (item.type !== "agentMessage" || typeof item.text !== "string") {
         return undefined;
     }
-    const body = compactOperatorSentence(item.text);
-    if (!body) {
+    const fullBody = sanitizeOperatorFacingText(item.text)?.replace(/\s+/g, " ").trim();
+    if (!fullBody) {
         return undefined;
     }
-    if (looksLikeVerification(body)) {
+    const ephemeralBody = compactOperatorSentence(fullBody) ?? fullBody;
+    if (looksLikeVerification(fullBody)) {
         return {
             kind: "verification_started",
-            meaningKey: `verification:${normalizeMeaningKey(body)}`,
-            content: { type: "thought", body },
+            meaningKey: `verification:${normalizeMeaningKey(fullBody)}`,
+            ephemeralContent: { type: "thought", body: ephemeralBody },
+            historyContent: { type: "thought", body: fullBody },
         };
     }
-    if (looksLikePublishing(body)) {
+    if (looksLikePublishing(fullBody)) {
         return {
             kind: "publishing_started",
-            meaningKey: `publishing:${normalizeMeaningKey(body)}`,
-            content: { type: "thought", body },
+            meaningKey: `publishing:${normalizeMeaningKey(fullBody)}`,
+            ephemeralContent: { type: "thought", body: ephemeralBody },
+            historyContent: { type: "thought", body: fullBody },
         };
     }
-    if (looksLikeRootCause(body)) {
+    if (looksLikeRootCause(fullBody)) {
         return {
             kind: "root_cause_found",
-            meaningKey: `finding:${normalizeMeaningKey(body)}`,
-            content: { type: "thought", body },
+            meaningKey: `finding:${normalizeMeaningKey(fullBody)}`,
+            ephemeralContent: { type: "thought", body: ephemeralBody },
+            historyContent: { type: "thought", body: fullBody },
         };
     }
     return undefined;
@@ -59,7 +63,12 @@ function deriveProgressFactFromPlan(rawPlan, issue) {
         return {
             kind: "verification_started",
             meaningKey: `verification:${normalizeMeaningKey(activeStep.step)}`,
-            content: {
+            ephemeralContent: {
+                type: "action",
+                action: "Verifying",
+                parameter: summarizePlanStep(activeStep.step, "latest changes before publishing"),
+            },
+            historyContent: {
                 type: "action",
                 action: "Verifying",
                 parameter: summarizePlanStep(activeStep.step, "latest changes before publishing"),
@@ -71,7 +80,12 @@ function deriveProgressFactFromPlan(rawPlan, issue) {
         return {
             kind: "publishing_started",
             meaningKey: `publishing:${normalizeMeaningKey(activeStep.step)}`,
-            content: {
+            ephemeralContent: {
+                type: "action",
+                action: "Publishing",
+                parameter,
+            },
+            historyContent: {
                 type: "action",
                 action: "Publishing",
                 parameter,

package/dist/linear-progress-reporter.js

@@ -17,22 +17,79 @@ export class LinearProgressReporter {
             return;
         }
         const previous = this.publicationsByRun.get(run.id);
-        if (previous?.meaningKey === fact.meaningKey) {
+        const shouldEmitEphemeral = previous?.ephemeralMeaningKey !== fact.meaningKey;
+        const shouldEmitHistory = previous?.historyMeaningKey !== fact.meaningKey;
+        if (!shouldEmitEphemeral && !shouldEmitHistory) {
             return;
         }
+        const now = Date.now();
         const publication = {
-            meaningKey: fact.meaningKey,
-            publishedAtMs: Date.now(),
+            ...previous,
+            ...(shouldEmitEphemeral
+                ? {
+                    ephemeralMeaningKey: fact.meaningKey,
+                    ephemeralPublishedAtMs: now,
+                }
+                : {}),
+            ...(shouldEmitHistory
+                ? {
+                    historyMeaningKey: fact.meaningKey,
+                    historyPublishedAtMs: now,
+                }
+                : {}),
         };
         this.publicationsByRun.set(run.id, publication);
-        void this.emitActivity(issue, fact.content, { ephemeral: true }).catch(() => {
-            const current = this.publicationsByRun.get(run.id);
-            if (current?.publishedAtMs === publication.publishedAtMs && current.meaningKey === publication.meaningKey) {
-                this.publicationsByRun.delete(run.id);
-            }
-        });
+        if (shouldEmitEphemeral) {
+            void this.emitActivity(issue, fact.ephemeralContent, { ephemeral: true }).catch(() => {
+                this.clearFailedPublication(run.id, "ephemeral", fact.meaningKey, now);
+            });
+        }
+        if (shouldEmitHistory) {
+            void this.emitActivity(issue, fact.historyContent).catch(() => {
+                this.clearFailedPublication(run.id, "history", fact.meaningKey, now);
+            });
+        }
     }
     clearProgress(runId) {
         this.publicationsByRun.delete(runId);
     }
+    clearFailedPublication(runId, channel, meaningKey, publishedAtMs) {
+        const current = this.publicationsByRun.get(runId);
+        if (!current) {
+            return;
+        }
+        if (channel === "ephemeral") {
+            if (current.ephemeralMeaningKey !== meaningKey || current.ephemeralPublishedAtMs !== publishedAtMs) {
+                return;
+            }
+            const next = {};
+            if (current.historyMeaningKey !== undefined) {
+                next.historyMeaningKey = current.historyMeaningKey;
+            }
+            if (current.historyPublishedAtMs !== undefined) {
+                next.historyPublishedAtMs = current.historyPublishedAtMs;
+            }
+            if (!next.historyMeaningKey) {
+                this.publicationsByRun.delete(runId);
+                return;
+            }
+            this.publicationsByRun.set(runId, next);
+            return;
+        }
+        if (current.historyMeaningKey !== meaningKey || current.historyPublishedAtMs !== publishedAtMs) {
+            return;
+        }
+        const next = {};
+        if (current.ephemeralMeaningKey !== undefined) {
+            next.ephemeralMeaningKey = current.ephemeralMeaningKey;
+        }
+        if (current.ephemeralPublishedAtMs !== undefined) {
+            next.ephemeralPublishedAtMs = current.ephemeralPublishedAtMs;
+        }
+        if (!next.ephemeralMeaningKey) {
+            this.publicationsByRun.delete(runId);
+            return;
+        }
+        this.publicationsByRun.set(runId, next);
+    }
 }

package/dist/linear-session-reporting.js

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

package/package.json

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