patchrelay 0.4.1 → 0.6.0

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

@@ -9,10 +9,12 @@ export class AgentSessionWebhookHandler {
     stores;
     turnInputDispatcher;
     agentActivity;
-    constructor(stores, turnInputDispatcher, agentActivity) {
+    feed;
+    constructor(stores, turnInputDispatcher, agentActivity, feed) {
         this.stores = stores;
         this.turnInputDispatcher = turnInputDispatcher;
         this.agentActivity = agentActivity;
+        this.feed = feed;
     }
     async handle(params) {
         const { normalized, project, issue, desiredStage, delegatedToPatchRelay } = params;
@@ -95,6 +97,13 @@ export class AgentSessionWebhookHandler {
                 ...(issue?.issueKey ? { issueKey: issue.issueKey } : {}),
                 failureMessage: "Failed to deliver queued Linear agent prompt to active Codex turn",
             });
+            this.publishPromptDeliveryEvent({
+                projectId: project.id,
+                issueKey: issue?.issueKey ?? normalized.issue?.identifier,
+                stage: activeRunLease.stage,
+                obligationId,
+                flushResult,
+            });
             await this.agentActivity.publishForSession(project.id, normalized.agentSession.id, {
                 type: "thought",
                 body: obligationId !== undefined && flushResult.deliveredObligationIds.includes(obligationId)
@@ -148,6 +157,47 @@ export class AgentSessionWebhookHandler {
         });
         return obligation.id;
     }
+    publishPromptDeliveryEvent(params) {
+        if (params.obligationId === undefined) {
+            return;
+        }
+        if (params.flushResult.deliveredObligationIds.includes(params.obligationId)) {
+            this.feed?.publish({
+                level: "info",
+                kind: "agent",
+                projectId: params.projectId,
+                issueKey: params.issueKey,
+                stage: params.stage,
+                status: "delivered",
+                summary: `Delivered follow-up prompt to active ${params.stage} workflow`,
+                detail: "The active Linear agent session was routed into the running Codex turn.",
+            });
+            return;
+        }
+        if (params.flushResult.failedObligationIds.includes(params.obligationId)) {
+            this.feed?.publish({
+                level: "warn",
+                kind: "agent",
+                projectId: params.projectId,
+                issueKey: params.issueKey,
+                stage: params.stage,
+                status: "delivery_failed",
+                summary: `Could not deliver follow-up prompt to active ${params.stage} workflow`,
+                detail: "PatchRelay kept the prompt queued and will retry delivery on the next active turn.",
+            });
+            return;
+        }
+        this.feed?.publish({
+            level: "info",
+            kind: "agent",
+            projectId: params.projectId,
+            issueKey: params.issueKey,
+            stage: params.stage,
+            status: "queued",
+            summary: `Queued follow-up prompt for active ${params.stage} workflow`,
+            detail: "PatchRelay saved the prompt for the next delivery opportunity.",
+        });
+    }
 }
 function buildPromptDedupeKey(agentSessionId, promptBody) {
     return `linear-agent-prompt:${agentSessionId}:${hashBody(promptBody)}`;

package/dist/webhook-comment-handler.js

@@ -4,9 +4,11 @@ import { triggerEventAllowed } from "./project-resolution.js";
 export class CommentWebhookHandler {
     stores;
     turnInputDispatcher;
-    constructor(stores, turnInputDispatcher) {
+    feed;
+    constructor(stores, turnInputDispatcher, feed) {
         this.stores = stores;
         this.turnInputDispatcher = turnInputDispatcher;
+        this.feed = feed;
     }
     async handle(normalized, project) {
         if ((normalized.triggerEvent !== "commentCreated" && normalized.triggerEvent !== "commentUpdated") || !normalized.comment?.body) {
@@ -48,8 +50,8 @@ export class CommentWebhookHandler {
             })) {
             return;
         }
-        this.enqueueObligation(project.id, normalizedIssue.id, runLease.threadId, runLease.turnId, normalized.comment.id, body, dedupeKey);
-        await this.turnInputDispatcher.flush({
+        const obligationId = this.enqueueObligation(project.id, normalizedIssue.id, runLease.threadId, runLease.turnId, normalized.comment.id, body, dedupeKey);
+        const flushResult = await this.turnInputDispatcher.flush({
             id: issueControl.activeRunLeaseId,
             projectId: project.id,
             linearIssueId: normalizedIssue.id,
@@ -59,6 +61,14 @@ export class CommentWebhookHandler {
             ...(issue?.issueKey ? { issueKey: issue.issueKey } : {}),
             failureMessage: "Failed to deliver queued Linear comment to active Codex turn",
         });
+        this.publishCommentDeliveryEvent({
+            projectId: project.id,
+            issueKey: issue?.issueKey ?? normalizedIssue.identifier,
+            stage: runLease.stage,
+            obligationId,
+            authorName: normalized.comment.userName,
+            flushResult,
+        });
     }
     enqueueObligation(projectId, linearIssueId, threadId, turnId, commentId, body, dedupeKey) {
         const activeRunLeaseId = this.stores.issueControl.getIssueControl(projectId, linearIssueId)?.activeRunLeaseId;
@@ -80,6 +90,48 @@ export class CommentWebhookHandler {
         });
         return obligation.id;
     }
+    publishCommentDeliveryEvent(params) {
+        if (params.obligationId === undefined) {
+            return;
+        }
+        const authorDetail = params.authorName ? `Author: ${params.authorName}.` : undefined;
+        if (params.flushResult.deliveredObligationIds.includes(params.obligationId)) {
+            this.feed?.publish({
+                level: "info",
+                kind: "comment",
+                projectId: params.projectId,
+                issueKey: params.issueKey,
+                stage: params.stage,
+                status: "delivered",
+                summary: `Delivered follow-up comment to active ${params.stage} workflow`,
+                detail: authorDetail ?? "The comment was routed into the running Codex turn.",
+            });
+            return;
+        }
+        if (params.flushResult.failedObligationIds.includes(params.obligationId)) {
+            this.feed?.publish({
+                level: "warn",
+                kind: "comment",
+                projectId: params.projectId,
+                issueKey: params.issueKey,
+                stage: params.stage,
+                status: "delivery_failed",
+                summary: `Could not deliver follow-up comment to active ${params.stage} workflow`,
+                detail: authorDetail ?? "PatchRelay kept the comment queued and will retry delivery.",
+            });
+            return;
+        }
+        this.feed?.publish({
+            level: "info",
+            kind: "comment",
+            projectId: params.projectId,
+            issueKey: params.issueKey,
+            stage: params.stage,
+            status: "queued",
+            summary: `Queued follow-up comment for active ${params.stage} workflow`,
+            detail: authorDetail ?? "PatchRelay saved the comment for the next delivery opportunity.",
+        });
+    }
 }
 function buildCommentDedupeKey(commentId, body) {
     return `linear-comment:${commentId}:${hashBody(body)}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchrelay",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "license": "MIT",
   "type": "module",
   "repository": {
@@ -34,7 +34,8 @@
     "doctor": "node dist/index.js doctor",
     "restart": "node dist/index.js restart-service",
     "lint": "eslint .",
-    "check": "tsc -p tsconfig.json --noEmit",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "check": "npm run typecheck",
     "test": "node --experimental-transform-types --test test/**/*.test.ts",
     "ci": "npm run lint && npm run check && npm test && npm run build"
   },