patchrelay 0.7.9 → 0.7.10

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.7.9",
-  "commit": "9f2abbe93f17",
-  "builtAt": "2026-03-17T10:42:10.173Z"
+  "version": "0.7.10",
+  "commit": "0eab9a037342",
+  "builtAt": "2026-03-17T11:47:34.397Z"
 }

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

@@ -45,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,
             });
@@ -69,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,
@@ -82,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",
@@ -111,14 +130,14 @@ 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 receipt = this.ensureEventReceipt(event, project.id, routedIssue.id);
             const hydrated = await this.hydrateIssueContext(project.id, normalized);
-            const hydratedIssue = hydrated.issue ?? normalized.issue;
+            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) {
@@ -229,6 +248,43 @@ export class ServiceWebhookProcessor {
             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) {

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.9",
+  "version": "0.7.10",
   "license": "MIT",
   "type": "module",
   "repository": {