patchrelay 0.56.1 → 0.58.0

package/dist/agent-session-plan.js

@@ -15,7 +15,7 @@ function implementationPlan() {
     return [
         { content: "Prepare workspace", status: "pending" },
         { content: "Implementing", status: "pending" },
-        { content: "Awaiting verification", status: "pending" },
+        { content: "Fresh head pushed", status: "pending" },
         { content: "Merge", status: "pending" },
     ];
 }
@@ -30,8 +30,8 @@ function orchestrationPlan() {
 function reviewFixPlan() {
     return [
         { content: "Prepare workspace", status: "completed" },
-        { content: "Addressing review feedback", status: "pending" },
-        { content: "Awaiting re-verification", status: "pending" },
+        { content: "Addressing requested changes", status: "pending" },
+        { content: "Fresh head pushed", status: "pending" },
         { content: "Merge", status: "pending" },
     ];
 }
@@ -39,7 +39,7 @@ function branchUpkeepPlan() {
     return [
         { content: "Prepare workspace", status: "completed" },
         { content: "Repairing branch upkeep", status: "pending" },
-        { content: "Awaiting re-verification", status: "pending" },
+        { content: "Fresh head pushed", status: "pending" },
         { content: "Merge", status: "pending" },
     ];
 }
@@ -55,7 +55,7 @@ function mainRepairPlan(attempt) {
     return [
         { content: "Inspect main failure", status: "pending" },
         { content: `Repairing main (${attemptLabel(attempt)})`, status: "pending" },
-        { content: "Awaiting re-verification", status: "pending" },
+        { content: "Fresh head pushed", status: "pending" },
         { content: "Priority merge", status: "pending" },
     ];
 }
@@ -152,7 +152,12 @@ export function buildAgentSessionPlan(params) {
                 ? mainRepairPlan(params.ciRepairAttempts ?? 1)
                 : planForRunType("implementation", params), ["completed", "inProgress", "pending", "pending"]);
         case "pr_open":
-            return setStatuses(implementationPlan(), ["completed", "completed", "inProgress", "pending"]);
+            return setStatuses([
+                { content: "Prepare workspace", status: "completed" },
+                { content: "Implementing", status: "completed" },
+                { content: prOpenGateLabel(params), status: "inProgress" },
+                { content: "Merge", status: "pending" },
+            ], ["completed", "completed", "inProgress", "pending"]);
         case "changes_requested":
             return setStatuses(reviewFixPlan(), ["completed", "inProgress", "pending", "pending"]);
         case "repairing_ci":
@@ -160,9 +165,9 @@ export function buildAgentSessionPlan(params) {
         case "awaiting_queue":
             return setStatuses([
                 { content: "Prepare workspace", status: "completed" },
-                { content: "Implementing", status: "completed" },
+                { content: "Fresh head pushed", status: "completed" },
                 { content: "Verification passed", status: "completed" },
-                { content: "Awaiting merge", status: "inProgress" },
+                { content: "Awaiting queue", status: "inProgress" },
             ], ["completed", "completed", "completed", "inProgress"]);
         case "repairing_queue":
             return setStatuses(queueRepairPlan(params.queueRepairAttempts ?? 1), ["completed", "completed", "completed", "inProgress"]);
@@ -175,12 +180,41 @@ export function buildAgentSessionPlan(params) {
         case "done":
             return setStatuses([
                 { content: "Prepare workspace", status: "completed" },
-                { content: "Implementing", status: "completed" },
+                { content: "Fresh head pushed", status: "completed" },
                 { content: "Verification passed", status: "completed" },
                 { content: "Merged", status: "completed" },
             ], ["completed", "completed", "completed", "completed"]);
     }
 }
+function prOpenGateLabel(params) {
+    const reviewState = normalizeState(params.prReviewState);
+    const checkStatus = normalizeState(params.prCheckStatus);
+    if (isPendingCheckStatus(checkStatus)) {
+        return "Awaiting checks";
+    }
+    if (isAwaitingReviewState(reviewState)) {
+        return "Awaiting review";
+    }
+    if (isApprovedReviewState(reviewState) && isPassedCheckStatus(checkStatus)) {
+        return "Awaiting queue";
+    }
+    return "Fresh head pushed";
+}
+function isAwaitingReviewState(value) {
+    return value === "review_required" || value === "commented" || value === "changes_requested";
+}
+function isApprovedReviewState(value) {
+    return value === "approved";
+}
+function isPendingCheckStatus(value) {
+    return value === "pending" || value === "queued" || value === "in_progress" || value === "waiting";
+}
+function isPassedCheckStatus(value) {
+    return value === "success" || value === "passed";
+}
+function normalizeState(value) {
+    return (value ?? "").trim().toLowerCase().replace(/[-/\s]+/g, "_");
+}
 function planForRunType(runType, params) {
     switch (runType) {
         case "main_repair":
@@ -206,6 +240,8 @@ export function buildAgentSessionPlanForIssue(issue, options) {
         ...(issue.issueClass ? { issueClass: issue.issueClass } : {}),
         ...(issue.orchestrationSettleUntil ? { orchestrationSettleUntil: issue.orchestrationSettleUntil } : {}),
         ...(issue.pendingRunType ? { pendingRunType: issue.pendingRunType } : {}),
+        ...(issue.prReviewState ? { prReviewState: issue.prReviewState } : {}),
+        ...(issue.prCheckStatus ? { prCheckStatus: issue.prCheckStatus } : {}),
         ...(options?.activeRunType ? { activeRunType: options.activeRunType } : {}),
     });
 }

package/dist/agent-session-presentation.js

@@ -2,19 +2,13 @@ import { buildSessionStatusUrl, createSessionStatusToken, deriveSessionStatusSig
 const SESSION_STATUS_TTL_SECONDS = 60 * 60 * 24 * 7;
 export function buildAgentSessionExternalUrls(config, params) {
     const urls = [];
-    if (params.issueKey && config.server.publicBaseUrl) {
-        const token = createSessionStatusToken({
-            issueKey: params.issueKey,
-            secret: deriveSessionStatusSigningSecret(config.linear.tokenEncryptionKey),
-            ttlSeconds: SESSION_STATUS_TTL_SECONDS,
-        });
+    const statusUrl = params.issueKey && config.server.publicBaseUrl
+        ? buildPublicStatusUrl(config, params.issueKey)
+        : undefined;
+    if (statusUrl) {
         urls.push({
             label: "PatchRelay status",
-            url: buildSessionStatusUrl({
-                publicBaseUrl: config.server.publicBaseUrl,
-                issueKey: params.issueKey,
-                token: token.token,
-            }),
+            url: statusUrl,
         });
     }
     if (params.prUrl) {
@@ -23,5 +17,98 @@ export function buildAgentSessionExternalUrls(config, params) {
             url: params.prUrl,
         });
     }
+    const reviewQuillUrl = buildReviewQuillUrl(params);
+    if (reviewQuillUrl) {
+        urls.push({
+            label: "Review-quill status",
+            url: reviewQuillUrl,
+        });
+    }
+    const mergeStewardUrl = buildMergeStewardUrl(params);
+    if (mergeStewardUrl) {
+        urls.push({
+            label: "Merge-steward queue",
+            url: mergeStewardUrl,
+        });
+    }
+    if (statusUrl && params.activeRunId !== undefined) {
+        urls.push({
+            label: "Active run",
+            url: withFragment(statusUrl, "current-view"),
+        });
+    }
     return urls.length > 0 ? urls : undefined;
 }
+function buildPublicStatusUrl(config, issueKey) {
+    if (!config.server.publicBaseUrl)
+        return undefined;
+    const token = createSessionStatusToken({
+        issueKey,
+        secret: deriveSessionStatusSigningSecret(config.linear.tokenEncryptionKey),
+        ttlSeconds: SESSION_STATUS_TTL_SECONDS,
+    });
+    return buildSessionStatusUrl({
+        publicBaseUrl: config.server.publicBaseUrl,
+        issueKey,
+        token: token.token,
+    });
+}
+function buildReviewQuillUrl(params) {
+    if (isReviewQuillCheck(params.lastGitHubFailureCheckName) && params.lastGitHubFailureCheckUrl) {
+        return params.lastGitHubFailureCheckUrl;
+    }
+    if (!params.prUrl || !hasReviewQuillContext(params)) {
+        return undefined;
+    }
+    return `${trimTrailingSlash(params.prUrl)}/checks`;
+}
+function buildMergeStewardUrl(params) {
+    const incidentUrl = parseQueueIncidentUrl(params.lastQueueIncidentJson);
+    if (incidentUrl)
+        return incidentUrl;
+    if (params.lastGitHubFailureSource === "queue_eviction"
+        || isMergeStewardCheck(params.lastGitHubFailureCheckName)) {
+        return params.lastGitHubFailureCheckUrl;
+    }
+    return undefined;
+}
+function hasReviewQuillContext(params) {
+    if (isReviewQuillCheck(params.lastGitHubFailureCheckName))
+        return true;
+    const reviewState = normalizeState(params.prReviewState);
+    if (reviewState === "review_required" || reviewState === "changes_requested" || reviewState === "commented") {
+        return true;
+    }
+    return normalizeState(params.prCheckStatus).includes("review");
+}
+function isReviewQuillCheck(checkName) {
+    return normalizeState(checkName).includes("review_quill");
+}
+function isMergeStewardCheck(checkName) {
+    return normalizeState(checkName).includes("merge_steward");
+}
+function parseQueueIncidentUrl(value) {
+    if (!value)
+        return undefined;
+    try {
+        const parsed = JSON.parse(value);
+        if (!parsed || typeof parsed !== "object")
+            return undefined;
+        const incidentUrl = parsed.incidentUrl;
+        return typeof incidentUrl === "string" && incidentUrl.trim() ? incidentUrl.trim() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function withFragment(url, fragment) {
+    const parsed = new URL(url);
+    parsed.hash = fragment;
+    return parsed.toString();
+}
+function trimTrailingSlash(value) {
+    return value.replace(/\/+$/, "");
+}
+function normalizeState(value) {
+    return (value ?? "").trim().toLowerCase().replace(/[-/\s]+/g, "_");
+}

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.56.1",
-  "commit": "39a7bc21b981",
-  "builtAt": "2026-05-01T15:22:20.307Z"
+  "version": "0.58.0",
+  "commit": "a14713655229",
+  "builtAt": "2026-05-02T10:15:39.171Z"
 }

package/dist/github-linear-session-sync.js

@@ -43,6 +43,13 @@ export async function syncGitHubLinearSession(params) {
         const externalUrls = buildAgentSessionExternalUrls(config, {
             ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
             ...(issue.prUrl ? { prUrl: issue.prUrl } : {}),
+            ...(issue.activeRunId !== undefined ? { activeRunId: issue.activeRunId } : {}),
+            ...(issue.prReviewState ? { prReviewState: issue.prReviewState } : {}),
+            ...(issue.prCheckStatus ? { prCheckStatus: issue.prCheckStatus } : {}),
+            ...(issue.lastGitHubFailureSource ? { lastGitHubFailureSource: issue.lastGitHubFailureSource } : {}),
+            ...(issue.lastGitHubFailureCheckName ? { lastGitHubFailureCheckName: issue.lastGitHubFailureCheckName } : {}),
+            ...(issue.lastGitHubFailureCheckUrl ? { lastGitHubFailureCheckUrl: issue.lastGitHubFailureCheckUrl } : {}),
+            ...(issue.lastQueueIncidentJson ? { lastQueueIncidentJson: issue.lastQueueIncidentJson } : {}),
         });
         await linear.updateAgentSession({
             agentSessionId: issue.agentSessionId,

package/dist/http.js

@@ -578,7 +578,7 @@ function renderAgentSessionStatusPage(params) {
         <span class="chip"><strong>Latest:</strong> ${latestStage}</span>
         <span class="chip"><strong>Thread:</strong> ${threadInfo}</span>
       </div>
-      <div class="section">
+      <div id="current-view" class="section">
         <h2>Current View</h2>
         <table>
           <tbody>
@@ -600,7 +600,7 @@ function renderAgentSessionStatusPage(params) {
         <span class="chip"><strong>CI repairs:</strong> ${escapeHtml(String(ciAttempts))}</span>
         <span class="chip"><strong>Steward repairs:</strong> ${escapeHtml(String(queueAttempts))}</span>
       </div>
-      <div class="section">
+      <div id="recent-stages" class="section">
         <h2>Recent Stages</h2>
         <table>
           <thead>

package/dist/linear-agent-activity-recovery.js

@@ -0,0 +1,83 @@
+const ACTIVITY_RECOVERY_LIMIT = 20;
+const MAX_CONTEXT_ACTIVITIES = 8;
+const MAX_ACTIVITY_TEXT_LENGTH = 500;
+function trimBounded(value, maxLength = MAX_ACTIVITY_TEXT_LENGTH) {
+    const normalized = value.replace(/\s+/g, " ").trim();
+    if (normalized.length <= maxLength)
+        return normalized;
+    return `${normalized.slice(0, maxLength - 1).trimEnd()}...`;
+}
+function hasRecoveredContext(context) {
+    return typeof context?.linearAgentActivityContext === "string" && context.linearAgentActivityContext.trim().length > 0;
+}
+function hasLocalHumanContext(context) {
+    if (hasRecoveredContext(context))
+        return true;
+    for (const key of ["promptContext", "promptBody", "operatorPrompt", "userComment"]) {
+        const value = context?.[key];
+        if (typeof value === "string" && value.trim().length > 0)
+            return true;
+    }
+    if (!Array.isArray(context?.followUps))
+        return false;
+    return context.followUps.some((entry) => {
+        if (!entry || typeof entry !== "object")
+            return false;
+        const text = entry.text;
+        return typeof text === "string" && text.trim().length > 0;
+    });
+}
+function activitySortKey(activity) {
+    const parsed = activity.updatedAt ? Date.parse(activity.updatedAt) : NaN;
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function describeActivity(activity) {
+    const type = activity.type?.trim() || "activity";
+    const body = typeof activity.body === "string" ? trimBounded(activity.body) : "";
+    if (body) {
+        return `${type}: ${body}`;
+    }
+    if (activity.action || activity.parameter || activity.result) {
+        const action = activity.action ? trimBounded(activity.action, 120) : "action";
+        const parameter = activity.parameter ? ` ${trimBounded(activity.parameter, 180)}` : "";
+        const result = activity.result ? ` -> ${trimBounded(activity.result, 180)}` : "";
+        return `${type}: ${action}${parameter}${result}`;
+    }
+    return undefined;
+}
+export function summarizeLinearAgentActivities(activities) {
+    const lines = [...activities]
+        .sort((left, right) => activitySortKey(left) - activitySortKey(right))
+        .map(describeActivity)
+        .filter((line) => Boolean(line))
+        .slice(-MAX_CONTEXT_ACTIVITIES);
+    if (lines.length === 0)
+        return undefined;
+    return {
+        linearAgentActivityContext: lines.map((line) => `- ${line}`).join("\n"),
+        linearAgentActivityCount: lines.length,
+    };
+}
+export async function recoverLinearAgentActivityContext(params) {
+    if (!params.agentSessionId || hasLocalHumanContext(params.context)) {
+        return undefined;
+    }
+    try {
+        const linear = await params.linearProvider.forProject(params.projectId);
+        if (!linear?.listAgentSessionActivities) {
+            return undefined;
+        }
+        const activities = await linear.listAgentSessionActivities(params.agentSessionId, {
+            first: ACTIVITY_RECOVERY_LIMIT,
+        });
+        return summarizeLinearAgentActivities(activities);
+    }
+    catch (error) {
+        params.logger.warn({
+            issueKey: params.issueKey,
+            agentSessionId: params.agentSessionId,
+            error: error instanceof Error ? error.message : String(error),
+        }, "Failed to recover Linear agent activity context");
+        return undefined;
+    }
+}

package/dist/linear-agent-session-client.js

@@ -75,6 +75,13 @@ export class LinearAgentSessionClient {
         const externalUrls = buildAgentSessionExternalUrls(this.config, {
             ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
             ...(issue.prUrl ? { prUrl: issue.prUrl } : {}),
+            ...(issue.activeRunId !== undefined ? { activeRunId: issue.activeRunId } : {}),
+            ...(issue.prReviewState ? { prReviewState: issue.prReviewState } : {}),
+            ...(issue.prCheckStatus ? { prCheckStatus: issue.prCheckStatus } : {}),
+            ...(issue.lastGitHubFailureSource ? { lastGitHubFailureSource: issue.lastGitHubFailureSource } : {}),
+            ...(issue.lastGitHubFailureCheckName ? { lastGitHubFailureCheckName: issue.lastGitHubFailureCheckName } : {}),
+            ...(issue.lastGitHubFailureCheckUrl ? { lastGitHubFailureCheckUrl: issue.lastGitHubFailureCheckUrl } : {}),
+            ...(issue.lastQueueIncidentJson ? { lastQueueIncidentJson: issue.lastQueueIncidentJson } : {}),
         });
         await linear.updateAgentSession({
             agentSessionId: issue.agentSessionId,

package/dist/linear-client.js

@@ -241,6 +241,55 @@ export class LinearGraphqlClient {
         }
         return response.agentSessionUpdate.agentSession;
     }
+    async listAgentSessionActivities(agentSessionId, options) {
+        const response = await this.request(`
+      query PatchRelayAgentSessionActivities($id: String!, $first: Int!) {
+        agentSession(id: $id) {
+          activities(first: $first) {
+            edges {
+              node {
+                id
+                updatedAt
+                content {
+                  __typename
+                  ... on AgentActivityThoughtContent {
+                    body
+                  }
+                  ... on AgentActivityActionContent {
+                    action
+                    parameter
+                    result
+                  }
+                  ... on AgentActivityElicitationContent {
+                    body
+                  }
+                  ... on AgentActivityResponseContent {
+                    body
+                  }
+                  ... on AgentActivityErrorContent {
+                    body
+                  }
+                  ... on AgentActivityPromptContent {
+                    body
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      `, {
+            id: agentSessionId,
+            first: Math.max(1, Math.min(options?.first ?? 20, 50)),
+        });
+        const activityEdges = response.agentSession?.activities?.edges;
+        const rawActivities = activityEdges
+            ? activityEdges.map((edge) => edge?.node)
+            : response.agentSession?.activities?.nodes ?? [];
+        return rawActivities
+            .filter((activity) => Boolean(activity))
+            .map(mapAgentActivity);
+    }
     async updateIssueLabels(params) {
         const issue = await this.getIssue(params.issueId);
         const addIds = this.resolveLabelIds(issue, params.addNames ?? []);
@@ -439,6 +488,25 @@ function mapIssueRelation(raw) {
         ...(raw.state?.type ? { stateType: raw.state.type } : {}),
     };
 }
+function mapAgentActivity(raw) {
+    const content = raw.content ?? {};
+    return {
+        id: raw.id,
+        ...(content.__typename ? { type: normalizeAgentActivityType(content.__typename) } : {}),
+        ...(content.body ? { body: content.body } : {}),
+        ...(content.action ? { action: content.action } : {}),
+        ...(content.parameter ? { parameter: content.parameter } : {}),
+        ...(content.result ? { result: content.result } : {}),
+        ...(raw.updatedAt ? { updatedAt: raw.updatedAt } : {}),
+    };
+}
+function normalizeAgentActivityType(typename) {
+    return typename
+        .replace(/^AgentActivity/, "")
+        .replace(/Content$/, "")
+        .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+        .toLowerCase();
+}
 export class DatabaseBackedLinearClientProvider {
     config;
     db;

package/dist/prompting/patchrelay.js

@@ -197,6 +197,9 @@ function buildHumanContextLines(context) {
     const latestPrompt = typeof context?.promptBody === "string" ? context.promptBody.trim() : "";
     const operatorPrompt = typeof context?.operatorPrompt === "string" ? context.operatorPrompt.trim() : "";
     const userComment = typeof context?.userComment === "string" ? context.userComment.trim() : "";
+    const linearAgentActivityContext = typeof context?.linearAgentActivityContext === "string"
+        ? context.linearAgentActivityContext.trim()
+        : "";
     const lines = [];
     if (promptContext) {
         lines.push("Linear session context:", promptContext, "");
@@ -210,6 +213,9 @@ function buildHumanContextLines(context) {
     if (userComment) {
         lines.push("Human follow-up comment:", userComment, "");
     }
+    if (linearAgentActivityContext) {
+        lines.push("Recovered Linear agent activity context:", linearAgentActivityContext, "");
+    }
     return lines;
 }
 function resolveRequestedChangesMode(runType, context) {

package/dist/run-orchestrator.js

@@ -8,6 +8,7 @@ import { MainBranchHealthMonitor } from "./main-branch-health-monitor.js";
 import { QueueHealthMonitor } from "./queue-health-monitor.js";
 import { IdleIssueReconciler } from "./idle-reconciliation.js";
 import { LinearSessionSync } from "./linear-session-sync.js";
+import { recoverLinearAgentActivityContext } from "./linear-agent-activity-recovery.js";
 import { IssueSessionLeaseService } from "./issue-session-lease-service.js";
 import { InterruptedRunRecovery } from "./interrupted-run-recovery.js";
 import { RunCompletionPolicy } from "./run-completion-policy.js";
@@ -234,12 +235,23 @@ export class RunOrchestrator {
         const baseContext = isRequestedChangesRunType(runType)
             ? await this.runCompletionPolicy.resolveRequestedChangesWakeContext(issue, runType, context)
             : context;
+        const recoveredLinearActivityContext = await recoverLinearAgentActivityContext({
+            linearProvider: this.linearProvider,
+            projectId: issue.projectId,
+            agentSessionId: issue.agentSessionId,
+            context: baseContext,
+            issueKey: issue.issueKey,
+            logger: this.logger,
+        });
+        const baseContextWithRecoveredActivity = recoveredLinearActivityContext
+            ? { ...baseContext, ...recoveredLinearActivityContext }
+            : baseContext;
         const coordinationContext = runType === "implementation"
             ? this.buildRelatedIssueContext(issue)
             : undefined;
         const effectiveContext = coordinationContext
-            ? { ...coordinationContext, ...(baseContext ?? {}) }
-            : baseContext;
+            ? { ...coordinationContext, ...baseContextWithRecoveredActivity }
+            : baseContextWithRecoveredActivity;
         const sourceHeadSha = typeof effectiveContext?.failureHeadSha === "string"
             ? effectiveContext.failureHeadSha
             : typeof effectiveContext?.headSha === "string"

package/package.json

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