patchrelay 0.36.12 → 0.36.14

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.36.12",
-  "commit": "c36b9a22a748",
-  "builtAt": "2026-04-09T21:06:16.158Z"
+  "version": "0.36.14",
+  "commit": "cf7280bff401",
+  "builtAt": "2026-04-10T04:01:33.969Z"
 }

package/dist/linear-session-reporting.js

@@ -62,20 +62,51 @@ export function buildRunStartedActivity(runType) {
     }
 }
 export function buildRunCompletedActivity(params) {
-    const label = formatRunTypeLabel(params.runType);
-    const nextState = describeNextState(params.postRunState, params.prNumber);
+    const prLabel = params.prNumber ? `PR #${params.prNumber}` : "the pull request";
     const summary = trimSummary(params.completionSummary);
-    const lines = [`${label} completed.`];
-    if (nextState) {
-        lines.push("", nextState);
-    }
-    if (summary) {
-        lines.push("", summary);
+    const detail = summary ? ` ${summary}` : "";
+    switch (params.runType) {
+        case "implementation":
+            if (params.postRunState === "pr_open") {
+                return {
+                    type: "response",
+                    body: `${prLabel} opened:${detail || " Published and ready for review."}`,
+                };
+            }
+            return undefined;
+        case "review_fix":
+            return {
+                type: "response",
+                body: `Updated ${prLabel} to address review feedback.${detail}`,
+            };
+        case "ci_repair":
+            return {
+                type: "response",
+                body: `Updated ${prLabel} after CI repair.${detail}`,
+            };
+        case "queue_repair":
+            return {
+                type: "response",
+                body: `Updated ${prLabel} after merge-queue repair.${detail}`,
+            };
+        case "branch_upkeep":
+            return undefined;
+        default: {
+            const label = formatRunTypeLabel(params.runType);
+            const nextState = describeNextState(params.postRunState, params.prNumber);
+            const lines = [`${label} completed.`];
+            if (nextState) {
+                lines.push("", nextState);
+            }
+            if (summary) {
+                lines.push("", summary);
+            }
+            return {
+                type: "response",
+                body: lines.join("\n"),
+            };
+        }
     }
-    return {
-        type: "response",
-        body: lines.join("\n"),
-    };
 }
 export function buildRunFailureActivity(runType, reason) {
     const label = formatRunTypeLabel(runType);
@@ -92,33 +123,16 @@ export function buildStopConfirmationActivity() {
 }
 export function buildGitHubStateActivity(newState, event) {
     switch (newState) {
-        case "pr_open": {
-            const parts = [`PR #${event.prNumber ?? "?"} is open and ready for review.`];
-            if (event.prUrl) {
-                parts.push("", event.prUrl);
-            }
-            return { type: "response", body: parts.join("\n") };
-        }
+        case "pr_open":
+            return undefined;
         case "awaiting_queue":
-            return { type: "response", body: "Review approved. PatchRelay is moving the PR toward merge." };
+            return undefined;
         case "changes_requested":
-            return {
-                type: "action",
-                action: "Addressing",
-                parameter: event.reviewerName ? `review feedback from ${event.reviewerName}` : "review feedback",
-            };
+            return undefined;
         case "repairing_ci":
-            return {
-                type: "action",
-                action: "Repairing",
-                parameter: event.checkName ? `CI failure: ${event.checkName}` : "failing CI checks",
-            };
+            return undefined;
         case "repairing_queue":
-            return {
-                type: "action",
-                action: "Repairing",
-                parameter: "merge queue validation",
-            };
+            return undefined;
         case "done":
             return { type: "response", body: `PR merged.${event.prNumber ? ` PR #${event.prNumber}` : ""}` };
         case "failed":

package/dist/linear-session-sync.js

@@ -2,8 +2,10 @@ import { buildAgentSessionPlanForIssue } from "./agent-session-plan.js";
 import { buildAgentSessionExternalUrls } from "./agent-session-presentation.js";
 import { deriveIssueStatusNote } from "./status-note.js";
 import { derivePatchRelayWaitingReason } from "./waiting-reason.js";
-import { resolvePreferredReviewLinearState, resolvePreferredStartedLinearState } from "./linear-workflow.js";
+import { resolvePreferredDeployingLinearState, resolvePreferredHumanNeededLinearState, resolvePreferredImplementingLinearState, resolvePreferredReviewLinearState, resolvePreferredReviewingLinearState, } from "./linear-workflow.js";
+import { sanitizeOperatorFacingCommand, sanitizeOperatorFacingText } from "./presentation-text.js";
 const PROGRESS_THROTTLE_MS = 5_000;
+const MAX_PROGRESS_TEXT_LENGTH = 220;
 export class LinearSessionSync {
     config;
     db;
@@ -11,6 +13,9 @@ export class LinearSessionSync {
     logger;
     feed;
     progressThrottle = new Map();
+    workingOnPublishedRuns = new Set();
+    agentMessageBuffers = new Map();
+    agentMessageProgressPublished = new Set();
     constructor(config, db, linearProvider, logger, feed) {
         this.config = config;
         this.db = db;
@@ -166,21 +171,103 @@ export class LinearSessionSync {
         }
     }
     maybeEmitProgress(notification, run) {
-        const activity = resolveProgressActivity(notification);
-        if (!activity)
+        const issue = this.db.issues.getIssue(run.projectId, run.linearIssueId);
+        if (!issue)
             return;
-        const now = Date.now();
-        const lastEmit = this.progressThrottle.get(run.id) ?? 0;
-        if (now - lastEmit < PROGRESS_THROTTLE_MS)
+        const agentSentence = this.consumeAgentMessageSentence(notification, run);
+        const workingOn = this.resolveWorkingOnActivity(notification, agentSentence?.sentence);
+        if (workingOn && !this.workingOnPublishedRuns.has(run.id)) {
+            this.workingOnPublishedRuns.add(run.id);
+            void this.emitActivity(issue, workingOn);
+        }
+        const progress = this.resolveEphemeralProgressActivity(notification, agentSentence?.sentence);
+        if (!progress)
             return;
-        this.progressThrottle.set(run.id, now);
-        const issue = this.db.issues.getIssue(run.projectId, run.linearIssueId);
-        if (issue) {
-            void this.emitActivity(issue, activity, { ephemeral: true });
+        if (!progress.bypassThrottle) {
+            const now = Date.now();
+            const lastEmit = this.progressThrottle.get(run.id) ?? 0;
+            if (now - lastEmit < PROGRESS_THROTTLE_MS)
+                return;
+            this.progressThrottle.set(run.id, now);
         }
+        void this.emitActivity(issue, progress.activity, { ephemeral: true });
     }
     clearProgress(runId) {
         this.progressThrottle.delete(runId);
+        this.workingOnPublishedRuns.delete(runId);
+        for (const key of this.agentMessageBuffers.keys()) {
+            if (key.startsWith(`${runId}:`)) {
+                this.agentMessageBuffers.delete(key);
+            }
+        }
+        for (const key of this.agentMessageProgressPublished) {
+            if (key.startsWith(`${runId}:`)) {
+                this.agentMessageProgressPublished.delete(key);
+            }
+        }
+    }
+    resolveWorkingOnActivity(notification, agentSentence) {
+        const summary = resolveWorkingOnSummary(notification) ?? agentSentence;
+        if (!summary)
+            return undefined;
+        return { type: "response", body: `Working on: ${summary}` };
+    }
+    resolveEphemeralProgressActivity(notification, agentSentence) {
+        if (notification.method === "item/started") {
+            const item = notification.params.item;
+            if (!item)
+                return undefined;
+            const type = typeof item.type === "string" ? item.type : undefined;
+            if (type === "commandExecution") {
+                const cmd = item.command;
+                const cmdStr = Array.isArray(cmd)
+                    ? sanitizeOperatorFacingCommand(cmd.map((part) => String(part)).join(" "))
+                    : sanitizeOperatorFacingCommand(typeof cmd === "string" ? cmd : undefined);
+                return { activity: { type: "action", action: "Running", parameter: truncateProgressText(cmdStr ?? "command", 120) } };
+            }
+            if (type === "mcpToolCall") {
+                const server = typeof item.server === "string" ? item.server : "";
+                const tool = typeof item.tool === "string" ? item.tool : "";
+                return { activity: { type: "action", action: "Using", parameter: `${server}/${tool}` } };
+            }
+            if (type === "dynamicToolCall") {
+                const tool = typeof item.tool === "string" ? item.tool : "tool";
+                return { activity: { type: "action", action: "Using", parameter: tool } };
+            }
+        }
+        if (agentSentence) {
+            return {
+                activity: { type: "thought", body: agentSentence },
+                bypassThrottle: true,
+            };
+        }
+        return undefined;
+    }
+    consumeAgentMessageSentence(notification, run) {
+        const messageKey = resolveAgentMessageKey(notification, run);
+        if (!messageKey)
+            return undefined;
+        if (this.agentMessageProgressPublished.has(messageKey))
+            return undefined;
+        const delta = resolveAgentMessageDelta(notification);
+        if (delta) {
+            const previous = this.agentMessageBuffers.get(messageKey) ?? "";
+            const next = `${previous}${delta}`;
+            this.agentMessageBuffers.set(messageKey, next);
+            const sentence = extractFirstSentence(next);
+            if (!sentence)
+                return undefined;
+            this.agentMessageProgressPublished.add(messageKey);
+            return { sentence };
+        }
+        const completedText = resolveCompletedAgentMessageText(notification);
+        if (!completedText)
+            return undefined;
+        const sentence = extractFirstSentence(completedText);
+        if (!sentence)
+            return undefined;
+        this.agentMessageProgressPublished.add(messageKey);
+        return { sentence };
     }
     async syncStatusComment(issue, linear, options) {
         try {
@@ -205,29 +292,6 @@ export class LinearSessionSync {
         }
     }
 }
-function resolveProgressActivity(notification) {
-    if (notification.method === "item/started") {
-        const item = notification.params.item;
-        if (!item)
-            return undefined;
-        const type = typeof item.type === "string" ? item.type : undefined;
-        if (type === "commandExecution") {
-            const cmd = item.command;
-            const cmdStr = Array.isArray(cmd) ? cmd.join(" ") : typeof cmd === "string" ? cmd : undefined;
-            return { type: "action", action: "Running", parameter: cmdStr?.slice(0, 120) ?? "command" };
-        }
-        if (type === "mcpToolCall") {
-            const server = typeof item.server === "string" ? item.server : "";
-            const tool = typeof item.tool === "string" ? item.tool : "";
-            return { type: "action", action: "Using", parameter: `${server}/${tool}` };
-        }
-        if (type === "dynamicToolCall") {
-            const tool = typeof item.tool === "string" ? item.tool : "tool";
-            return { type: "action", action: "Using", parameter: tool };
-        }
-    }
-    return undefined;
-}
 function renderStatusComment(db, issue, trackedIssue, options) {
     const activeRun = issue.activeRunId ? db.runs.getRunById(issue.activeRunId) : undefined;
     const latestRun = db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
@@ -343,32 +407,127 @@ function humanize(value) {
 }
 function shouldAutoAdvanceLinearState(issue) {
     const normalizedType = issue.currentLinearStateType?.trim().toLowerCase();
-    if (normalizedType === "backlog" || normalizedType === "unstarted") {
-        return true;
+    if (normalizedType === "completed" || normalizedType === "canceled" || normalizedType === "cancelled") {
+        return false;
     }
     const normalizedName = issue.currentLinearState?.trim().toLowerCase();
-    return normalizedName === "backlog" || normalizedName === "todo" || normalizedName === "to do" || normalizedName === "triage";
+    return normalizedName !== "done" && normalizedName !== "completed" && normalizedName !== "complete";
 }
 function resolveDesiredActiveWorkflowState(issue, trackedIssue, options, liveIssue) {
+    if (issue.factoryState === "awaiting_input" || issue.factoryState === "failed" || issue.factoryState === "escalated"
+        || trackedIssue?.sessionState === "waiting_input" || trackedIssue?.sessionState === "failed") {
+        return resolvePreferredHumanNeededLinearState(liveIssue);
+    }
+    const activelyWorking = issue.activeRunId !== undefined
+        || options?.activeRunType !== undefined
+        || trackedIssue?.sessionState === "running"
+        || issue.factoryState === "delegated"
+        || issue.factoryState === "implementing"
+        || issue.factoryState === "changes_requested"
+        || issue.factoryState === "repairing_ci"
+        || issue.factoryState === "repairing_queue";
+    if (activelyWorking) {
+        return resolvePreferredImplementingLinearState(liveIssue);
+    }
+    if (issue.factoryState === "awaiting_queue"
+        || issue.prReviewState === "approved"
+        || isApprovedAndGreen(issue.prReviewState, issue.prCheckStatus)) {
+        return resolvePreferredDeployingLinearState(liveIssue);
+    }
+    const reviewQuillActive = hasPendingReviewQuillVerdict(issue.lastGitHubCiSnapshotJson);
+    if (reviewQuillActive) {
+        return resolvePreferredReviewingLinearState(liveIssue);
+    }
     const reviewBound = issue.prNumber !== undefined
         || Boolean(issue.prUrl)
         || issue.factoryState === "pr_open"
-        || issue.factoryState === "awaiting_queue"
-        || issue.factoryState === "changes_requested"
-        || issue.factoryState === "repairing_ci"
-        || issue.factoryState === "repairing_queue"
         || issue.prReviewState !== undefined
         || issue.prCheckStatus !== undefined;
     if (reviewBound) {
         return resolvePreferredReviewLinearState(liveIssue);
     }
-    const activelyWorking = issue.activeRunId !== undefined
-        || options?.activeRunType !== undefined
-        || trackedIssue?.sessionState === "running"
-        || issue.factoryState === "delegated"
-        || issue.factoryState === "implementing";
-    if (activelyWorking) {
-        return resolvePreferredStartedLinearState(liveIssue);
+    return undefined;
+}
+function isApprovedAndGreen(prReviewState, prCheckStatus) {
+    const normalizedReview = prReviewState?.trim().toLowerCase();
+    const normalizedChecks = prCheckStatus?.trim().toLowerCase();
+    return normalizedReview === "approved" && (normalizedChecks === "success" || normalizedChecks === "passed");
+}
+function hasPendingReviewQuillVerdict(snapshotJson) {
+    if (!snapshotJson)
+        return false;
+    try {
+        const parsed = JSON.parse(snapshotJson);
+        return Array.isArray(parsed.checks) && parsed.checks.some((check) => typeof check.name === "string"
+            && check.name === "review-quill/verdict"
+            && typeof check.status === "string"
+            && check.status.toLowerCase() === "pending");
+    }
+    catch {
+        return false;
+    }
+}
+function resolveWorkingOnSummary(notification) {
+    if (notification.method !== "turn/plan/updated") {
+        return undefined;
+    }
+    const plan = notification.params.plan;
+    if (!Array.isArray(plan))
+        return undefined;
+    const ranked = plan
+        .map((entry) => entry)
+        .filter((entry) => typeof entry.step === "string" && entry.step.trim().length > 0)
+        .sort((a, b) => rankPlanStatus(a.status) - rankPlanStatus(b.status));
+    const first = ranked[0];
+    return summarizeProgressSentence(typeof first?.step === "string" ? first.step : undefined);
+}
+function rankPlanStatus(status) {
+    return status === "inProgress" ? 0
+        : status === "pending" ? 1
+            : status === "completed" ? 2
+                : 3;
+}
+function resolveAgentMessageKey(notification, run) {
+    if (notification.method === "item/agentMessage/delta") {
+        const itemId = typeof notification.params.itemId === "string" ? notification.params.itemId : undefined;
+        return itemId ? `${run.id}:${itemId}` : undefined;
+    }
+    if (notification.method === "item/completed") {
+        const item = notification.params.item;
+        const itemId = typeof item?.id === "string" ? item.id : undefined;
+        const itemType = typeof item?.type === "string" ? item.type : undefined;
+        return itemId && itemType === "agentMessage" ? `${run.id}:${itemId}` : undefined;
     }
     return undefined;
 }
+function resolveAgentMessageDelta(notification) {
+    if (notification.method !== "item/agentMessage/delta") {
+        return undefined;
+    }
+    return typeof notification.params.delta === "string" ? notification.params.delta : undefined;
+}
+function resolveCompletedAgentMessageText(notification) {
+    if (notification.method !== "item/completed") {
+        return undefined;
+    }
+    const item = notification.params.item;
+    if (!item || item.type !== "agentMessage")
+        return undefined;
+    return typeof item.text === "string" ? item.text : undefined;
+}
+function extractFirstSentence(text) {
+    const sanitized = sanitizeOperatorFacingText(text)?.replace(/\s+/g, " ").trim();
+    if (!sanitized)
+        return undefined;
+    const match = sanitized.match(/^(.+?[.!?])(?:\s|$)/);
+    return truncateProgressText((match?.[1] ?? sanitized).trim(), MAX_PROGRESS_TEXT_LENGTH);
+}
+function summarizeProgressSentence(text) {
+    const summary = extractFirstSentence(text);
+    if (!summary)
+        return undefined;
+    return summary.endsWith(".") || summary.endsWith("!") || summary.endsWith("?") ? summary : `${summary}.`;
+}
+function truncateProgressText(text, maxLength) {
+    return text.length <= maxLength ? text : `${text.slice(0, maxLength - 3).trimEnd()}...`;
+}

package/dist/linear-workflow.js

@@ -2,6 +2,20 @@ function normalizeLinearState(value) {
     const trimmed = value?.trim();
     return trimmed ? trimmed.toLowerCase() : undefined;
 }
+function includesAny(normalized, candidates) {
+    return Boolean(normalized && candidates.includes(normalized));
+}
+function resolvePreferredLinearState(issue, params) {
+    const match = issue.workflowStates.find((state) => {
+        const normalizedType = normalizeLinearState(state.type);
+        const normalizedName = normalizeLinearState(state.name);
+        if (params.types && !params.types.includes(normalizedType ?? "")) {
+            return false;
+        }
+        return includesAny(normalizedName, params.names);
+    });
+    return match?.name ?? params.fallback;
+}
 export function resolvePreferredStartedLinearState(issue) {
     const startedStates = issue.workflowStates.filter((state) => normalizeLinearState(state.type) === "started");
     const preferred = startedStates.find((state) => {
@@ -10,14 +24,50 @@ export function resolvePreferredStartedLinearState(issue) {
     });
     return preferred?.name ?? startedStates[0]?.name;
 }
+export function resolvePreferredImplementingLinearState(issue) {
+    return resolvePreferredLinearState(issue, {
+        names: ["implementing", "in progress", "in-progress", "started", "doing"],
+        types: ["started"],
+        fallback: resolvePreferredStartedLinearState(issue),
+    });
+}
 export function resolvePreferredReviewLinearState(issue) {
-    const reviewState = issue.workflowStates.find((state) => {
-        if (normalizeLinearState(state.type) !== "started")
-            return false;
-        const normalized = normalizeLinearState(state.name);
-        return normalized === "in review" || normalized === "review";
+    return resolvePreferredLinearState(issue, {
+        names: ["review", "awaiting review"],
+        types: ["unstarted"],
+        fallback: resolvePreferredLinearState(issue, {
+            names: ["reviewing", "in review", "review"],
+            types: ["started"],
+            fallback: resolvePreferredStartedLinearState(issue),
+        }),
+    });
+}
+export function resolvePreferredReviewingLinearState(issue) {
+    return resolvePreferredLinearState(issue, {
+        names: ["reviewing", "in review", "review"],
+        types: ["started"],
+        fallback: resolvePreferredReviewLinearState(issue),
+    });
+}
+export function resolvePreferredDeployLinearState(issue) {
+    return resolvePreferredLinearState(issue, {
+        names: ["deploy", "ready to deploy", "ready for deploy", "merge"],
+        types: ["unstarted"],
+        fallback: resolvePreferredReviewLinearState(issue),
+    });
+}
+export function resolvePreferredDeployingLinearState(issue) {
+    return resolvePreferredLinearState(issue, {
+        names: ["deploying", "merging", "shipping"],
+        types: ["started"],
+        fallback: resolvePreferredDeployLinearState(issue),
+    });
+}
+export function resolvePreferredHumanNeededLinearState(issue) {
+    return resolvePreferredLinearState(issue, {
+        names: ["human needed", "needs human", "help needed", "operator needed", "blocked"],
+        fallback: undefined,
     });
-    return reviewState?.name ?? resolvePreferredStartedLinearState(issue);
 }
 export function resolvePreferredCompletedLinearState(issue) {
     const completed = issue.workflowStates.find((state) => normalizeLinearState(state.type) === "completed");

package/dist/presentation-text.js

@@ -1,7 +1,16 @@
 function unwrapShellWrappedCommand(text) {
     return text
         .replace(/`(?:\/bin\/bash|bash|\/bin\/sh|sh)\s+-lc\s+'([^`\n]+)'`/g, "`$1`")
-        .replace(/`(?:\/bin\/bash|bash|\/bin\/sh|sh)\s+-lc\s+"([^`\n]+)"`/g, "`$1`");
+        .replace(/`(?:\/bin\/bash|bash|\/bin\/sh|sh)\s+-lc\s+"([^`\n]+)"`/g, "`$1`")
+        .replace(/^(?:\/bin\/bash|bash|\/bin\/sh|sh)\s+-lc\s+'([^`\n]+)'$/g, "$1")
+        .replace(/^(?:\/bin\/bash|bash|\/bin\/sh|sh)\s+-lc\s+"([^`\n]+)"$/g, "$1");
+}
+export function sanitizeOperatorFacingCommand(command) {
+    const trimmed = command?.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    return unwrapShellWrappedCommand(trimmed);
 }
 export function sanitizeOperatorFacingText(text) {
     const trimmed = text?.trim();

package/dist/run-finalizer.js

@@ -159,12 +159,15 @@ export class RunFinalizer {
         });
         const updatedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? refreshedIssue;
         const completionSummary = report.assistantMessages.at(-1)?.slice(0, 300) ?? `${run.runType} completed.`;
-        void this.linearSync.emitActivity(updatedIssue, buildRunCompletedActivity({
+        const linearActivity = buildRunCompletedActivity({
             runType: run.runType,
             completionSummary,
             postRunState: updatedIssue.factoryState,
             ...(updatedIssue.prNumber !== undefined ? { prNumber: updatedIssue.prNumber } : {}),
-        }));
+        });
+        if (linearActivity) {
+            void this.linearSync.emitActivity(updatedIssue, linearActivity);
+        }
         void this.linearSync.syncSession(updatedIssue);
         this.linearSync.clearProgress(run.id);
         this.releaseLease(run.projectId, run.linearIssueId);

package/dist/webhooks/agent-session-handler.js

@@ -46,13 +46,12 @@ export class AgentSessionHandler {
                 await this.publishAgentActivity(linear, normalized.agentSession.id, buildAlreadyRunningThought(activeRun.runType));
                 return;
             }
-            const blockerSummary = trackedIssue?.blockedByCount
-                ? `PatchRelay is delegated and waiting on blockers to reach Done: ${trackedIssue.blockedByKeys.join(", ")}.`
-                : "PatchRelay is delegated, but no work is queued. Delegate the issue or move it to Start to trigger implementation.";
-            await this.publishAgentActivity(linear, normalized.agentSession.id, {
-                type: "elicitation",
-                body: blockerSummary,
-            });
+            if (!trackedIssue?.blockedByCount) {
+                await this.publishAgentActivity(linear, normalized.agentSession.id, {
+                    type: "elicitation",
+                    body: "PatchRelay is delegated, but no work is queued. Delegate the issue or move it to Start to trigger implementation.",
+                });
+            }
             return;
         }
         if (normalized.triggerEvent === "agentSignal" && normalized.agentSession.signal === "stop") {

package/package.json

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