patchrelay 0.8.0 → 0.8.2

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.8.0",
-  "commit": "c4fcada0fce7",
-  "builtAt": "2026-03-18T10:29:36.175Z"
+  "version": "0.8.2",
+  "commit": "bae4a3fbeb97",
+  "builtAt": "2026-03-18T21:53:19.259Z"
 }

package/dist/config.js

@@ -128,10 +128,28 @@ const configSchema = z.object({
 });
 function defaultTriggerEvents(actor) {
     if (actor === "app") {
-        return ["agentSessionCreated", "agentPrompted"];
+        return ["delegateChanged", "statusChanged", "agentSessionCreated", "agentPrompted", "commentCreated", "commentUpdated"];
     }
     return ["statusChanged"];
 }
+function normalizeTriggerEvents(actor, configured) {
+    if (actor !== "app") {
+        return configured ?? defaultTriggerEvents(actor);
+    }
+    const required = defaultTriggerEvents(actor);
+    if (!configured || configured.length === 0) {
+        return required;
+    }
+    const seen = new Set(required);
+    const extras = configured.filter((event) => {
+        if (seen.has(event)) {
+            return false;
+        }
+        seen.add(event);
+        return true;
+    });
+    return [...required, ...extras];
+}
 const builtinWorkflows = [
     {
         id: "development",
@@ -489,9 +507,8 @@ export function loadConfig(configPath = process.env.PATCHRELAY_CONFIG ?? getDefa
                 issueKeyPrefixes: project.issue_key_prefixes,
                 linearTeamIds: project.linear_team_ids,
                 allowLabels: project.allow_labels,
-                triggerEvents: repoSettings?.trigger_events ??
-                    project.trigger_events ??
-                    defaultTriggerEvents(parsed.linear.oauth.actor),
+                triggerEvents: normalizeTriggerEvents(parsed.linear.oauth.actor, repoSettings?.trigger_events ??
+                    project.trigger_events),
                 branchPrefix: repoSettings?.branch_prefix ?? project.branch_prefix ?? defaultBranchPrefix(project.id),
                 ...(repoSettings?.configPath ? { repoSettingsPath: repoSettings.configPath } : {}),
             };

package/dist/preflight.js

@@ -40,8 +40,14 @@ export async function runPreflight(config) {
             checks.push(pass("linear_oauth", "Linear app actor includes assignable and mentionable scopes"));
         }
         for (const project of config.projects) {
+            if (!project.triggerEvents.includes("delegateChanged")) {
+                checks.push(warn(`project:${project.id}:triggers`, "Automatic pipeline pickup works best when trigger_events includes delegateChanged"));
+            }
+            if (!project.triggerEvents.includes("statusChanged")) {
+                checks.push(warn(`project:${project.id}:triggers`, "Automatic stage-to-stage continuation works best when trigger_events includes statusChanged"));
+            }
             if (!project.triggerEvents.includes("agentSessionCreated")) {
-                checks.push(warn(`project:${project.id}:triggers`, "App-mode delegation works best when trigger_events includes agentSessionCreated"));
+                checks.push(warn(`project:${project.id}:triggers`, "Native Linear agent sessions work best when trigger_events includes agentSessionCreated"));
             }
             if (!project.triggerEvents.includes("agentPrompted")) {
                 checks.push(warn(`project:${project.id}:triggers`, "Native follow-up agent prompts will not reach an active run unless trigger_events includes agentPrompted"));

package/dist/service-runtime.js

@@ -1,5 +1,6 @@
 import { SerialWorkQueue } from "./service-queue.js";
 const ISSUE_KEY_DELIMITER = "::";
+const DEFAULT_RECONCILE_INTERVAL_MS = 5_000;
 function toReconciler(value) {
     if (typeof value === "function") {
         return {
@@ -40,13 +41,17 @@ function makeIssueQueueKey(item) {
 export class ServiceRuntime {
     codex;
     logger;
+    options;
     webhookQueue;
     issueQueue;
     ready = false;
     startupError;
-    constructor(codex, logger, stageRunReconciler, readyIssueSource, webhookProcessor, issueProcessor) {
+    reconcileTimer;
+    reconcileInProgress = false;
+    constructor(codex, logger, stageRunReconciler, readyIssueSource, webhookProcessor, issueProcessor, options = {}) {
         this.codex = codex;
         this.logger = logger;
+        this.options = options;
         this.stageRunReconciler = toReconciler(stageRunReconciler);
         this.readyIssueSource = toReadyIssueSource(readyIssueSource);
         this.webhookProcessor = toWebhookProcessor(webhookProcessor);
@@ -69,6 +74,7 @@ export class ServiceRuntime {
             }
             this.ready = true;
             this.startupError = undefined;
+            this.scheduleBackgroundReconcile();
         }
         catch (error) {
             this.ready = false;
@@ -78,6 +84,7 @@ export class ServiceRuntime {
     }
     stop() {
         this.ready = false;
+        this.clearBackgroundReconcile();
         void this.codex.stop();
     }
     enqueueWebhookEvent(eventId, options) {
@@ -93,4 +100,42 @@ export class ServiceRuntime {
             ...(this.startupError ? { startupError: this.startupError } : {}),
         };
     }
+    scheduleBackgroundReconcile() {
+        this.clearBackgroundReconcile();
+        const timer = setTimeout(() => {
+            void this.runBackgroundReconcile();
+        }, this.options.reconcileIntervalMs ?? DEFAULT_RECONCILE_INTERVAL_MS);
+        timer.unref?.();
+        this.reconcileTimer = timer;
+    }
+    clearBackgroundReconcile() {
+        if (this.reconcileTimer !== undefined) {
+            clearTimeout(this.reconcileTimer);
+            this.reconcileTimer = undefined;
+        }
+    }
+    async runBackgroundReconcile() {
+        if (!this.ready || !this.codex.isStarted()) {
+            return;
+        }
+        if (this.reconcileInProgress) {
+            this.scheduleBackgroundReconcile();
+            return;
+        }
+        this.reconcileInProgress = true;
+        try {
+            await this.stageRunReconciler.reconcileActiveStageRuns();
+        }
+        catch (error) {
+            this.logger.warn({
+                error: error instanceof Error ? error.message : String(error),
+            }, "Background active-stage reconciliation failed");
+        }
+        finally {
+            this.reconcileInProgress = false;
+            if (this.ready) {
+                this.scheduleBackgroundReconcile();
+            }
+        }
+    }
 }

package/dist/service-stage-finalizer.js

@@ -3,13 +3,11 @@ import { reconcileIssue } from "./reconciliation-engine.js";
 import { buildReconciliationSnapshot } from "./reconciliation-snapshot-builder.js";
 import { syncFailedStageToLinear } from "./stage-failure.js";
 import { parseStageHandoff } from "./stage-handoff.js";
-import { resolveActiveLinearState, resolveFallbackLinearState } from "./linear-workflow.js";
+import { resolveFallbackLinearState } from "./linear-workflow.js";
 import { resolveDefaultTransitionTarget, transitionTargetAllowed } from "./workflow-policy.js";
 import { buildFailedStageReport, buildPendingMaterializationThread, buildStageReport, countEventMethods, extractStageSummary, extractTurnId, resolveStageRunStatus, summarizeCurrentThread, } 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 { normalizeWebhook } from "./webhooks.js";
 const MAX_AUTOMATIC_TRANSITION_ATTEMPTS = 3;
 export class ServiceStageFinalizer {
     config;
@@ -261,7 +259,7 @@ export class ServiceStageFinalizer {
         if (!linearIssue) {
             return;
         }
-        const continuationPrecondition = await this.checkAutomaticContinuationPreconditions(project, stageRun, refreshedIssue, linear, linearIssue);
+        const continuationPrecondition = await this.checkAutomaticContinuationPreconditions(stageRun, refreshedIssue, linear, linearIssue);
         if (!continuationPrecondition.allowed) {
             this.feed?.publish({
                 level: "info",
@@ -339,14 +337,7 @@ export class ServiceStageFinalizer {
             lifecycleStatus: "queued",
         });
     }
-    async checkAutomaticContinuationPreconditions(project, stageRun, issue, linear, linearIssue) {
-        const activeState = resolveActiveLinearState(project, stageRun.stage, issue.selectedWorkflowId);
-        if (activeState && normalizeLinearState(linearIssue.stateName) !== normalizeLinearState(activeState)) {
-            return {
-                allowed: false,
-                reason: `Linear moved from ${activeState} to ${linearIssue.stateName ?? "an unknown state"} while the stage was running.`,
-            };
-        }
+    async checkAutomaticContinuationPreconditions(stageRun, issue, linear, linearIssue) {
         const actorProfile = await linear.getActorProfile().catch(() => undefined);
         if (actorProfile?.actorId && linearIssue.delegateId && linearIssue.delegateId !== actorProfile.actorId) {
             return {
@@ -354,48 +345,8 @@ export class ServiceStageFinalizer {
                 reason: "The issue is no longer delegated to PatchRelay.",
             };
         }
-        const stageSession = stageRun.threadId ? this.stores.issueSessions.getIssueSessionByThreadId(stageRun.threadId) : undefined;
-        if (stageSession?.linkedAgentSessionId && issue.activeAgentSessionId !== stageSession.linkedAgentSessionId) {
-            return {
-                allowed: false,
-                reason: "The active Linear agent session changed while the stage was running.",
-            };
-        }
-        const recentInterruptions = this.listInterruptingWebhooksSince(stageRun, actorProfile?.actorId);
-        if (recentInterruptions.length > 0) {
-            return {
-                allowed: false,
-                reason: `A newer human webhook (${recentInterruptions[0]}) arrived while the stage was running.`,
-            };
-        }
         return { allowed: true };
     }
-    listInterruptingWebhooksSince(stageRun, patchRelayActorId) {
-        const events = this.stores.webhookEvents.listWebhookEventsForIssueSince(stageRun.linearIssueId, stageRun.startedAt);
-        const interrupts = [];
-        for (const event of events) {
-            const payload = safeJsonParse(event.payloadJson);
-            if (!payload) {
-                continue;
-            }
-            const normalized = normalizeWebhook({
-                webhookId: event.webhookId,
-                payload: payload,
-            });
-            if (patchRelayActorId && normalized.actor?.id === patchRelayActorId) {
-                continue;
-            }
-            if (normalized.triggerEvent === "commentCreated" ||
-                normalized.triggerEvent === "commentUpdated" ||
-                normalized.triggerEvent === "agentPrompted" ||
-                normalized.triggerEvent === "agentSessionCreated" ||
-                normalized.triggerEvent === "delegateChanged" ||
-                normalized.triggerEvent === "statusChanged") {
-                interrupts.push(normalized.triggerEvent);
-            }
-        }
-        return interrupts;
-    }
     resolveTransitionTarget(project, stageRun, workflowDefinitionId, handoff) {
         if (!handoff) {
             return "human_needed";

package/dist/service-webhook-processor.js

@@ -154,8 +154,7 @@ export class ServiceWebhookProcessor {
                 });
             }
             if (issueState.issue?.selectedWorkflowId &&
-                issueState.issue.selectedWorkflowId !== priorIssue?.selectedWorkflowId &&
-                (hydrated.triggerEvent === "agentSessionCreated" || hydrated.triggerEvent === "agentPrompted")) {
+                issueState.issue.selectedWorkflowId !== priorIssue?.selectedWorkflowId) {
                 this.feed?.publish({
                     level: "info",
                     kind: "workflow",

package/dist/webhook-desired-stage-recorder.js

@@ -78,9 +78,6 @@ export class WebhookDesiredStageRecorder {
         if (!normalizedIssue) {
             return undefined;
         }
-        if (normalized.triggerEvent !== "agentSessionCreated" && normalized.triggerEvent !== "agentPrompted") {
-            return undefined;
-        }
         if (!delegatedToPatchRelay || !triggerEventAllowed(project, normalized.triggerEvent)) {
             return undefined;
         }
@@ -102,9 +99,6 @@ export class WebhookDesiredStageRecorder {
         if (activeStageRun) {
             return issue?.selectedWorkflowId;
         }
-        if (normalized.triggerEvent !== "agentSessionCreated" && normalized.triggerEvent !== "agentPrompted") {
-            return issue?.selectedWorkflowId;
-        }
         if (!delegatedToPatchRelay || !triggerEventAllowed(project, normalized.triggerEvent) || !normalized.issue) {
             return issue?.selectedWorkflowId;
         }

package/package.json

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