patchrelay 0.7.8 → 0.7.9

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.7.8",
-  "commit": "ef8346869c35",
-  "builtAt": "2026-03-17T10:30:51.043Z"
+  "version": "0.7.9",
+  "commit": "9f2abbe93f17",
+  "builtAt": "2026-03-17T10:42:10.173Z"
 }

package/dist/linear-client.js

@@ -15,6 +15,10 @@ export class LinearGraphqlClient {
           identifier
           title
           url
+          delegate {
+            id
+            name
+          }
           state {
             id
             name
@@ -65,6 +69,10 @@ export class LinearGraphqlClient {
             identifier
             title
             url
+            delegate {
+              id
+              name
+            }
             state {
               id
               name
@@ -290,6 +298,8 @@ export class LinearGraphqlClient {
             ...(issue.state?.name ? { stateName: issue.state.name } : {}),
             ...(issue.team?.id ? { teamId: issue.team.id } : {}),
             ...(issue.team?.key ? { teamKey: issue.team.key } : {}),
+            ...(issue.delegate?.id ? { delegateId: issue.delegate.id } : {}),
+            ...(issue.delegate?.name ? { delegateName: issue.delegate.name } : {}),
             workflowStates: (issue.team?.states?.nodes ?? []).map((state) => ({
                 id: state.id,
                 name: state.name,

package/dist/service-webhook-processor.js

@@ -10,6 +10,7 @@ import { normalizeWebhook } from "./webhooks.js";
 export class ServiceWebhookProcessor {
     config;
     stores;
+    linearProvider;
     enqueueIssue;
     logger;
     feed;
@@ -20,6 +21,7 @@ export class ServiceWebhookProcessor {
     constructor(config, stores, linearProvider, codex, enqueueIssue, logger, feed) {
         this.config = config;
         this.stores = stores;
+        this.linearProvider = linearProvider;
         this.enqueueIssue = enqueueIssue;
         this.logger = logger;
         this.feed = feed;
@@ -115,13 +117,15 @@ export class ServiceWebhookProcessor {
             }
             this.stores.webhookEvents.assignWebhookProject(webhookEventId, project.id);
             const receipt = this.ensureEventReceipt(event, project.id, normalized.issue.id);
-            const issueState = this.desiredStageRecorder.record(project, normalized, receipt ? { eventReceiptId: receipt.id } : undefined);
-            const observation = describeWebhookObservation(normalized, issueState.delegatedToPatchRelay);
+            const hydrated = await this.hydrateIssueContext(project.id, normalized);
+            const hydratedIssue = hydrated.issue ?? normalized.issue;
+            const issueState = this.desiredStageRecorder.record(project, hydrated, receipt ? { eventReceiptId: receipt.id } : undefined);
+            const observation = describeWebhookObservation(hydrated, issueState.delegatedToPatchRelay);
             if (observation) {
                 this.feed?.publish({
                     level: "info",
                     kind: observation.kind,
-                    issueKey: normalized.issue.identifier,
+                    issueKey: hydratedIssue.identifier,
                     projectId: project.id,
                     ...(observation.status ? { status: observation.status } : {}),
                     summary: observation.summary,
@@ -129,45 +133,45 @@ export class ServiceWebhookProcessor {
                 });
             }
             await this.agentSessionHandler.handle({
-                normalized,
+                normalized: hydrated,
                 project,
                 issue: issueState.issue,
                 desiredStage: issueState.desiredStage,
                 delegatedToPatchRelay: issueState.delegatedToPatchRelay,
             });
-            await this.commentHandler.handle(normalized, project);
+            await this.commentHandler.handle(hydrated, project);
             this.stores.webhookEvents.markWebhookProcessed(webhookEventId, "processed");
             this.markEventReceiptProcessed(event.webhookId, "processed");
             if (issueState.desiredStage) {
                 this.feed?.publish({
                     level: "info",
                     kind: "stage",
-                    issueKey: normalized.issue.identifier,
+                    issueKey: hydratedIssue.identifier,
                     projectId: project.id,
                     stage: issueState.desiredStage,
                     status: "queued",
                     summary: `Queued ${issueState.desiredStage} workflow`,
-                    detail: `Triggered by ${normalized.triggerEvent}${normalized.issue.stateName ? ` from ${normalized.issue.stateName}` : ""}.`,
+                    detail: `Triggered by ${hydrated.triggerEvent}${hydratedIssue.stateName ? ` from ${hydratedIssue.stateName}` : ""}.`,
                 });
                 this.logger.info({
                     webhookEventId,
                     webhookId: event.webhookId,
                     projectId: project.id,
-                    issueKey: normalized.issue.identifier,
-                    issueId: normalized.issue.id,
+                    issueKey: hydratedIssue.identifier,
+                    issueId: hydratedIssue.id,
                     desiredStage: issueState.desiredStage,
                     delegatedToPatchRelay: issueState.delegatedToPatchRelay,
                 }, "Recorded desired stage from webhook and enqueued issue execution");
-                this.enqueueIssue(project.id, normalized.issue.id);
+                this.enqueueIssue(project.id, hydratedIssue.id);
                 return;
             }
             this.logger.info({
                 webhookEventId,
                 webhookId: event.webhookId,
                 projectId: project.id,
-                issueKey: normalized.issue.identifier,
-                issueId: normalized.issue.id,
-                triggerEvent: normalized.triggerEvent,
+                issueKey: hydratedIssue.identifier,
+                issueId: hydratedIssue.id,
+                triggerEvent: hydrated.triggerEvent,
                 delegatedToPatchRelay: issueState.delegatedToPatchRelay,
             }, "Processed webhook without enqueuing a new stage run");
         }
@@ -194,6 +198,37 @@ export class ServiceWebhookProcessor {
             throw err;
         }
     }
+    async hydrateIssueContext(projectId, normalized) {
+        if (!normalized.issue) {
+            return normalized;
+        }
+        if (normalized.triggerEvent !== "agentSessionCreated" && normalized.triggerEvent !== "agentPrompted") {
+            return normalized;
+        }
+        if (hasCompleteIssueContext(normalized.issue)) {
+            return normalized;
+        }
+        const linear = await this.linearProvider.forProject(projectId);
+        if (!linear) {
+            return normalized;
+        }
+        try {
+            const liveIssue = await linear.getIssue(normalized.issue.id);
+            return {
+                ...normalized,
+                issue: mergeIssueMetadata(normalized.issue, liveIssue),
+            };
+        }
+        catch (error) {
+            this.logger.warn({
+                projectId,
+                issueId: normalized.issue.id,
+                triggerEvent: normalized.triggerEvent,
+                error: sanitizeDiagnosticText(error instanceof Error ? error.message : String(error)),
+            }, "Failed to hydrate sparse Linear issue context for agent session webhook");
+            return normalized;
+        }
+    }
     assignEventReceiptContext(webhookId, projectId, linearIssueId) {
         const receipt = this.lookupEventReceipt(webhookId);
         if (!receipt) {
@@ -234,6 +269,24 @@ export class ServiceWebhookProcessor {
         return this.stores.eventReceipts.getEventReceipt(inserted.id);
     }
 }
+function hasCompleteIssueContext(issue) {
+    return Boolean(issue.stateName && issue.delegateId && issue.teamId && issue.teamKey);
+}
+function mergeIssueMetadata(issue, liveIssue) {
+    return {
+        ...issue,
+        ...(issue.identifier ? {} : liveIssue.identifier ? { identifier: liveIssue.identifier } : {}),
+        ...(issue.title ? {} : liveIssue.title ? { title: liveIssue.title } : {}),
+        ...(issue.url ? {} : liveIssue.url ? { url: liveIssue.url } : {}),
+        ...(issue.teamId ? {} : liveIssue.teamId ? { teamId: liveIssue.teamId } : {}),
+        ...(issue.teamKey ? {} : liveIssue.teamKey ? { teamKey: liveIssue.teamKey } : {}),
+        ...(issue.stateId ? {} : liveIssue.stateId ? { stateId: liveIssue.stateId } : {}),
+        ...(issue.stateName ? {} : liveIssue.stateName ? { stateName: liveIssue.stateName } : {}),
+        ...(issue.delegateId ? {} : liveIssue.delegateId ? { delegateId: liveIssue.delegateId } : {}),
+        ...(issue.delegateName ? {} : liveIssue.delegateName ? { delegateName: liveIssue.delegateName } : {}),
+        labelNames: issue.labelNames.length > 0 ? issue.labelNames : (liveIssue.labels ?? []).map((label) => label.name),
+    };
+}
 function describeWebhookObservation(normalized, delegatedToPatchRelay) {
     switch (normalized.triggerEvent) {
         case "delegateChanged":

package/package.json

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