patchrelay 0.7.8 → 0.7.10

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.10",
+  "commit": "0eab9a037342",
+  "builtAt": "2026-03-17T11:47:34.397Z"
 }

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-stage-runner.js

@@ -3,6 +3,7 @@ import { syncFailedStageToLinear } from "./stage-failure.js";
 import { buildFailedStageReport } from "./stage-reporting.js";
 import { StageLifecyclePublisher } from "./stage-lifecycle-publisher.js";
 import { StageTurnInputDispatcher } from "./stage-turn-input-dispatcher.js";
+import { safeJsonParse } from "./utils.js";
 import { WorktreeManager } from "./worktree-manager.js";
 export class ServiceStageRunner {
     config;
@@ -86,11 +87,16 @@ export class ServiceStageRunner {
             });
             await this.lifecyclePublisher.markStageActive(project, claim.issue, claim.stageRun);
             threadLaunch = await this.launchStageThread(item.projectId, item.issueId, claim.stageRun.id, plan.worktreePath, issue.issueKey);
+            const pendingLaunchInput = this.collectPendingLaunchInput(item.projectId, item.issueId);
+            const initialTurnInput = pendingLaunchInput.combinedInput
+                ? [plan.prompt, "", pendingLaunchInput.combinedInput].join("\n")
+                : plan.prompt;
             turn = await this.codex.startTurn({
                 threadId: threadLaunch.threadId,
                 cwd: plan.worktreePath,
-                input: plan.prompt,
+                input: initialTurnInput,
             });
+            this.completeDeliveredLaunchInput(pendingLaunchInput.obligationIds, claim.stageRun.id, threadLaunch.threadId, turn.turnId);
         }
         catch (error) {
             const err = error instanceof Error ? error : new Error(String(error));
@@ -122,19 +128,8 @@ export class ServiceStageRunner {
             turnId: turn.turnId,
         });
         this.inputDispatcher.routePendingInputs(claim.stageRun, threadLaunch.threadId, turn.turnId);
-        await this.inputDispatcher.flush({
-            id: claim.stageRun.id,
-            projectId: claim.stageRun.projectId,
-            linearIssueId: claim.stageRun.linearIssueId,
-            threadId: threadLaunch.threadId,
-            turnId: turn.turnId,
-        }, {
-            logFailures: true,
-            failureMessage: "Failed to deliver queued Linear comment during stage startup",
-            ...(claim.issue.issueKey ? { issueKey: claim.issue.issueKey } : {}),
-        });
         const deliveredToSession = await this.lifecyclePublisher.publishStageStarted(claim.issue, claim.stageRun.stage);
-        if (!deliveredToSession) {
+        if (!deliveredToSession && !claim.issue.activeAgentSessionId) {
             await this.lifecyclePublisher.refreshRunningStatusComment(item.projectId, item.issueId, claim.stageRun.id, issue.issueKey);
         }
         this.logger.info({
@@ -156,6 +151,39 @@ export class ServiceStageRunner {
             detail: `Turn ${turn.turnId} is running in ${plan.branchName}.`,
         });
     }
+    collectPendingLaunchInput(projectId, issueId) {
+        const obligationIds = [];
+        const bodies = [];
+        for (const obligation of this.stores.obligations.listPendingObligations({ kind: "deliver_turn_input" })) {
+            if (obligation.projectId !== projectId ||
+                obligation.linearIssueId !== issueId ||
+                !obligation.source.startsWith("linear-agent-launch:")) {
+                continue;
+            }
+            const payload = safeJsonParse(obligation.payloadJson);
+            const body = payload?.body?.trim();
+            if (!body) {
+                this.stores.obligations.markObligationStatus(obligation.id, "failed", "obligation payload had no deliverable body");
+                continue;
+            }
+            obligationIds.push(obligation.id);
+            bodies.push(body);
+        }
+        return {
+            ...(bodies.length > 0 ? { combinedInput: bodies.join("\n\n") } : {}),
+            obligationIds,
+        };
+    }
+    completeDeliveredLaunchInput(obligationIds, runLeaseId, threadId, turnId) {
+        for (const obligationId of obligationIds) {
+            this.stores.obligations.updateObligationRouting(obligationId, {
+                runLeaseId,
+                threadId,
+                turnId,
+            });
+            this.stores.obligations.markObligationStatus(obligationId, "completed");
+        }
+    }
     async ensureLaunchIssueMirror(project, linearIssueId, _desiredStage, _desiredWebhookId) {
         const existing = this.stores.issueWorkflows.getTrackedIssue(project.id, linearIssueId);
         if (existing?.issueKey && existing.title && existing.issueUrl && existing.currentLinearState) {

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;
@@ -43,7 +45,7 @@ export class ServiceWebhookProcessor {
                 this.markEventReceiptProcessed(event.webhookId, "failed");
                 throw new Error(`Stored webhook payload is invalid JSON: event ${webhookEventId}`);
             }
-            const normalized = normalizeWebhook({
+            let normalized = normalizeWebhook({
                 webhookId: event.webhookId,
                 payload,
             });
@@ -67,12 +69,25 @@ export class ServiceWebhookProcessor {
                 this.markEventReceiptProcessed(event.webhookId, "processed");
                 return;
             }
-            const project = resolveProject(this.config, normalized.issue);
+            let project = resolveProject(this.config, normalized.issue);
             if (!project) {
+                const routed = await this.tryHydrateProjectRoute(normalized);
+                if (routed) {
+                    normalized = routed.normalized;
+                    project = routed.project;
+                }
+            }
+            if (!project) {
+                const unresolvedIssue = normalized.issue;
+                if (!unresolvedIssue) {
+                    this.stores.webhookEvents.markWebhookProcessed(webhookEventId, "failed");
+                    this.markEventReceiptProcessed(event.webhookId, "failed");
+                    throw new Error(`Normalized issue context disappeared before routing webhook ${event.webhookId}`);
+                }
                 this.feed?.publish({
                     level: "warn",
                     kind: "webhook",
-                    issueKey: normalized.issue.identifier,
+                    issueKey: unresolvedIssue.identifier,
                     status: "ignored",
                     summary: "Ignored webhook with no matching project route",
                     detail: normalized.triggerEvent,
@@ -80,21 +95,27 @@ export class ServiceWebhookProcessor {
                 this.logger.info({
                     webhookEventId,
                     webhookId: event.webhookId,
-                    issueKey: normalized.issue.identifier,
-                    issueId: normalized.issue.id,
-                    teamId: normalized.issue.teamId,
-                    teamKey: normalized.issue.teamKey,
+                    issueKey: unresolvedIssue.identifier,
+                    issueId: unresolvedIssue.id,
+                    teamId: unresolvedIssue.teamId,
+                    teamKey: unresolvedIssue.teamKey,
                     triggerEvent: normalized.triggerEvent,
                 }, "Ignoring webhook because no project route matched the Linear issue");
                 this.stores.webhookEvents.markWebhookProcessed(webhookEventId, "processed");
                 this.markEventReceiptProcessed(event.webhookId, "processed");
                 return;
             }
+            const routedIssue = normalized.issue;
+            if (!routedIssue) {
+                this.stores.webhookEvents.markWebhookProcessed(webhookEventId, "failed");
+                this.markEventReceiptProcessed(event.webhookId, "failed");
+                throw new Error(`Normalized issue context disappeared while routing webhook ${event.webhookId}`);
+            }
             if (!trustedActorAllowed(project, normalized.actor)) {
                 this.feed?.publish({
                     level: "warn",
                     kind: "webhook",
-                    issueKey: normalized.issue.identifier,
+                    issueKey: routedIssue.identifier,
                     projectId: project.id,
                     status: "ignored",
                     summary: "Ignored webhook from an untrusted actor",
@@ -109,19 +130,21 @@ export class ServiceWebhookProcessor {
                     actorEmail: normalized.actor?.email,
                 }, "Ignoring webhook from untrusted Linear actor");
                 this.stores.webhookEvents.markWebhookProcessed(webhookEventId, "processed");
-                this.assignEventReceiptContext(event.webhookId, project.id, normalized.issue.id);
+                this.assignEventReceiptContext(event.webhookId, project.id, routedIssue.id);
                 this.markEventReceiptProcessed(event.webhookId, "processed");
                 return;
             }
             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 receipt = this.ensureEventReceipt(event, project.id, routedIssue.id);
+            const hydrated = await this.hydrateIssueContext(project.id, normalized);
+            const hydratedIssue = hydrated.issue ?? routedIssue;
+            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 +152,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 +217,74 @@ 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;
+        }
+    }
+    async tryHydrateProjectRoute(normalized) {
+        if (!normalized.issue) {
+            return undefined;
+        }
+        if (normalized.triggerEvent !== "agentSessionCreated" && normalized.triggerEvent !== "agentPrompted") {
+            return undefined;
+        }
+        for (const candidate of this.config.projects) {
+            const linear = await this.linearProvider.forProject(candidate.id);
+            if (!linear) {
+                continue;
+            }
+            try {
+                const liveIssue = await linear.getIssue(normalized.issue.id);
+                const hydrated = {
+                    ...normalized,
+                    issue: mergeIssueMetadata(normalized.issue, liveIssue),
+                };
+                const resolved = resolveProject(this.config, hydrated.issue);
+                if (resolved) {
+                    return {
+                        project: resolved,
+                        normalized: hydrated,
+                    };
+                }
+            }
+            catch (error) {
+                this.logger.debug({
+                    candidateProjectId: candidate.id,
+                    issueId: normalized.issue.id,
+                    triggerEvent: normalized.triggerEvent,
+                    error: sanitizeDiagnosticText(error instanceof Error ? error.message : String(error)),
+                }, "Failed to hydrate Linear issue context while resolving project route");
+            }
+        }
+        return undefined;
+    }
     assignEventReceiptContext(webhookId, projectId, linearIssueId) {
         const receipt = this.lookupEventReceipt(webhookId);
         if (!receipt) {
@@ -234,6 +325,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/dist/stage-failure.js

@@ -71,7 +71,7 @@ export async function syncFailedStageToLinear(params) {
                 .then(() => true)
                 .catch(() => false)) || deliveredToSession;
     }
-    if (!deliveredToSession) {
+    if (!deliveredToSession && !params.issue.activeAgentSessionId) {
         const result = await linear
             .upsertIssueComment({
             issueId: params.stageRun.linearIssueId,

package/dist/stage-lifecycle-publisher.js

@@ -84,7 +84,7 @@ export class StageLifecyclePublisher {
             await linear.createAgentActivity({
                 agentSessionId: issue.activeAgentSessionId,
                 content: {
-                    type: "thought",
+                    type: "response",
                     body: `PatchRelay started the ${stage} workflow and is working in the background.`,
                 },
             });
@@ -155,7 +155,7 @@ export class StageLifecyclePublisher {
                             type: "elicitation",
                             body: `PatchRelay finished the ${stageRun.stage} workflow. Move the issue to its next workflow state or leave a follow-up prompt to continue.`,
                         })) || deliveredToSession;
-                    if (!deliveredToSession) {
+                    if (!deliveredToSession && !refreshedIssue.activeAgentSessionId) {
                         const result = await linear.upsertIssueComment({
                             issueId: stageRun.linearIssueId,
                             ...(refreshedIssue.statusCommentId ? { commentId: refreshedIssue.statusCommentId } : {}),

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

@@ -66,7 +66,7 @@ export class AgentSessionWebhookHandler {
             if (desiredStage) {
                 await this.agentActivity.updateSession(buildSessionUpdateParams(project.id, normalized.agentSession.id, issue?.issueKey ?? normalized.issue?.identifier, buildPreparingSessionPlan(desiredStage)));
                 await this.agentActivity.publishForSession(project.id, normalized.agentSession.id, {
-                    type: "thought",
+                    type: "response",
                     body: `PatchRelay started working on the ${desiredStage} workflow and is preparing the workspace.`,
                 }, { ephemeral: false });
                 return;
@@ -137,7 +137,7 @@ export class AgentSessionWebhookHandler {
         if (!activeRunLease && desiredStage) {
             await this.agentActivity.updateSession(buildSessionUpdateParams(project.id, normalized.agentSession.id, issue?.issueKey ?? normalized.issue?.identifier, buildPreparingSessionPlan(desiredStage)));
             await this.agentActivity.publishForSession(project.id, normalized.agentSession.id, {
-                type: "thought",
+                type: "response",
                 body: `PatchRelay is preparing the ${desiredStage} workflow from your latest prompt.`,
             }, { ephemeral: false });
             return;

package/package.json

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