patchrelay 0.8.2 → 0.8.4

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.8.2",
-  "commit": "bae4a3fbeb97",
-  "builtAt": "2026-03-18T21:53:19.259Z"
+  "version": "0.8.4",
+  "commit": "57164b7aed73",
+  "builtAt": "2026-03-19T08:00:15.798Z"
 }

package/dist/db/issue-workflow-coordinator.js

@@ -200,7 +200,7 @@ export class IssueWorkflowCoordinator {
             });
         }
         const workspace = this.authoritativeLedger.getWorkspaceOwnership(stageRun.workspaceId);
-        if (workspace) {
+        if (workspace && workspace.currentRunLeaseId === params.stageRunId) {
             this.authoritativeLedger.upsertWorkspaceOwnership({
                 projectId: stageRun.projectId,
                 linearIssueId: stageRun.linearIssueId,

package/dist/linear-workflow.js

@@ -1,11 +1,53 @@
 import { resolveWorkflowStageConfig } from "./workflow-policy.js";
 const STATUS_MARKER = "<!-- patchrelay:status-comment -->";
+function normalizeLinearState(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed.toLowerCase() : undefined;
+}
 export function resolveActiveLinearState(project, stage, workflowDefinitionId) {
     return resolveWorkflowStageConfig(project, stage, workflowDefinitionId)?.activeState;
 }
 export function resolveFallbackLinearState(project, stage, workflowDefinitionId) {
     return resolveWorkflowStageConfig(project, stage, workflowDefinitionId)?.fallbackState;
 }
+export function resolveDoneLinearState(issue) {
+    const typedMatch = issue.workflowStates.find((state) => normalizeLinearState(state.type) === "completed");
+    if (typedMatch?.name) {
+        return typedMatch.name;
+    }
+    const nameMatch = issue.workflowStates.find((state) => {
+        const normalized = normalizeLinearState(state.name);
+        return normalized === "done" || normalized === "completed" || normalized === "complete";
+    });
+    return nameMatch?.name;
+}
+export function resolveAuthoritativeLinearStopState(issue) {
+    const currentStateName = issue.stateName?.trim();
+    const normalizedCurrentState = normalizeLinearState(currentStateName);
+    if (!currentStateName || !normalizedCurrentState) {
+        return undefined;
+    }
+    const currentWorkflowState = issue.workflowStates.find((state) => normalizeLinearState(state.name) === normalizedCurrentState);
+    if (normalizeLinearState(currentWorkflowState?.type) === "completed") {
+        return {
+            stateName: currentWorkflowState?.name ?? currentStateName,
+            lifecycleStatus: "completed",
+        };
+    }
+    if (normalizedCurrentState === "human needed") {
+        return {
+            stateName: currentStateName,
+            lifecycleStatus: "paused",
+        };
+    }
+    if (normalizedCurrentState === "done" || normalizedCurrentState === "completed" || normalizedCurrentState === "complete") {
+        return {
+            stateName: currentStateName,
+            lifecycleStatus: "completed",
+        };
+    }
+    return undefined;
+}
 export function buildRunningStatusComment(params) {
     return [
         STATUS_MARKER,

package/dist/service-stage-finalizer.js

@@ -3,12 +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 { resolveFallbackLinearState } from "./linear-workflow.js";
+import { resolveAuthoritativeLinearStopState, resolveDoneLinearState, 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";
-const MAX_AUTOMATIC_TRANSITION_ATTEMPTS = 3;
 export class ServiceStageFinalizer {
     config;
     stores;
@@ -153,6 +152,7 @@ export class ServiceStageFinalizer {
         const report = buildStageReport(finalizedStageRun, issue, thread, countEventMethods(this.stores.stageEvents.listThreadEvents(stageRun.id)));
         this.runAtomically(() => {
             this.finishLedgerRun(stageRun.projectId, stageRun.linearIssueId, "completed", {
+                stageRunId: stageRun.id,
                 threadId: params.threadId,
                 ...(params.turnId ? { turnId: params.turnId } : {}),
                 nextLifecycleStatus: params.nextLifecycleStatus ?? (issue.desiredStage ? "queued" : "completed"),
@@ -171,6 +171,7 @@ export class ServiceStageFinalizer {
     failStageRun(stageRun, threadId, message, options) {
         this.runAtomically(() => {
             this.finishLedgerRun(stageRun.projectId, stageRun.linearIssueId, "failed", {
+                stageRunId: stageRun.id,
                 threadId,
                 ...(options?.turnId ? { turnId: options.turnId } : {}),
                 failureReason: message,
@@ -240,7 +241,7 @@ export class ServiceStageFinalizer {
     }
     async maybeQueueAutomaticTransition(stageRun, report) {
         const refreshedIssue = this.stores.issueWorkflows.getTrackedIssue(stageRun.projectId, stageRun.linearIssueId);
-        if (!refreshedIssue || refreshedIssue.desiredStage) {
+        if (!refreshedIssue) {
             return;
         }
         const project = this.config.projects.find((candidate) => candidate.id === stageRun.projectId);
@@ -259,6 +260,14 @@ export class ServiceStageFinalizer {
         if (!linearIssue) {
             return;
         }
+        const authoritativeStopState = resolveAuthoritativeLinearStopState(linearIssue);
+        if (authoritativeStopState) {
+            this.syncIssueToAuthoritativeLinearStopState(stageRun, refreshedIssue, authoritativeStopState);
+            return;
+        }
+        if (refreshedIssue.desiredStage) {
+            return;
+        }
         const continuationPrecondition = await this.checkAutomaticContinuationPreconditions(stageRun, refreshedIssue, linear, linearIssue);
         if (!continuationPrecondition.allowed) {
             this.feed?.publish({
@@ -315,9 +324,19 @@ export class ServiceStageFinalizer {
             await this.routeStageToHumanNeeded(project, stageRun, linearIssue, `PatchRelay received ${nextTarget} as the next stage again and needs a human to confirm the intended loop.`);
             return;
         }
-        const priorAttempts = this.countPriorTransitionAttempts(stageRun.projectId, stageRun.linearIssueId, stageRun.stage, nextTarget);
-        if (priorAttempts >= MAX_AUTOMATIC_TRANSITION_ATTEMPTS) {
-            await this.routeStageToHumanNeeded(project, stageRun, linearIssue, `PatchRelay hit the automatic continuation limit for ${stageRun.stage} -> ${nextTarget}.`);
+        if (this.isTransitionAlreadyInFlight(stageRun, nextTarget)) {
+            this.feed?.publish({
+                level: "info",
+                kind: "workflow",
+                issueKey: refreshedIssue.issueKey,
+                projectId: stageRun.projectId,
+                stage: stageRun.stage,
+                ...(refreshedIssue.selectedWorkflowId ? { workflowId: refreshedIssue.selectedWorkflowId } : {}),
+                nextStage: nextTarget,
+                status: "transition_in_progress",
+                summary: `${nextTarget} is already queued or running`,
+                detail: `PatchRelay kept ${stageRun.stage} completion from re-queueing ${nextTarget}.`,
+            });
             return;
         }
         this.feed?.publish({
@@ -337,6 +356,32 @@ export class ServiceStageFinalizer {
             lifecycleStatus: "queued",
         });
     }
+    syncIssueToAuthoritativeLinearStopState(stageRun, issue, stopState) {
+        this.stores.workflowCoordinator.setIssueDesiredStage(stageRun.projectId, stageRun.linearIssueId, undefined, {
+            lifecycleStatus: stopState.lifecycleStatus,
+        });
+        this.stores.workflowCoordinator.upsertTrackedIssue({
+            projectId: stageRun.projectId,
+            linearIssueId: stageRun.linearIssueId,
+            currentLinearState: stopState.stateName,
+            lifecycleStatus: stopState.lifecycleStatus,
+        });
+        this.feed?.publish({
+            level: "info",
+            kind: "workflow",
+            issueKey: issue.issueKey,
+            projectId: stageRun.projectId,
+            stage: stageRun.stage,
+            ...(issue.selectedWorkflowId ? { workflowId: issue.selectedWorkflowId } : {}),
+            status: stopState.lifecycleStatus === "completed" ? "completed" : "transition_suppressed",
+            summary: stopState.lifecycleStatus === "completed"
+                ? `Kept workflow completed after ${stageRun.stage}`
+                : `Ignored stale ${stageRun.stage} completion`,
+            detail: stopState.lifecycleStatus === "completed"
+                ? `Live Linear state is already ${stopState.stateName}, so PatchRelay kept the issue finished.`
+                : `Live Linear state is already ${stopState.stateName}, so PatchRelay kept the issue paused.`,
+        });
+    }
     async checkAutomaticContinuationPreconditions(stageRun, issue, linear, linearIssue) {
         const actorProfile = await linear.getActorProfile().catch(() => undefined);
         if (actorProfile?.actorId && linearIssue.delegateId && linearIssue.delegateId !== actorProfile.actorId) {
@@ -360,19 +405,16 @@ export class ServiceStageFinalizer {
         }
         return resolveDefaultTransitionTarget(project, stageRun.stage, workflowDefinitionId) ?? "human_needed";
     }
-    countPriorTransitionAttempts(projectId, linearIssueId, currentStage, nextTarget) {
-        const stageHistory = this.stores.issueWorkflows
-            .listStageRunsForIssue(projectId, linearIssueId)
-            .filter((stageRun) => stageRun.status === "completed");
-        let count = 0;
-        for (let index = 0; index < stageHistory.length - 1; index += 1) {
-            const current = stageHistory[index];
-            const next = stageHistory[index + 1];
-            if (current?.stage === currentStage && next?.stage === nextTarget) {
-                count += 1;
-            }
+    isTransitionAlreadyInFlight(stageRun, nextTarget) {
+        const refreshedIssue = this.stores.issueWorkflows.getTrackedIssue(stageRun.projectId, stageRun.linearIssueId);
+        if (!refreshedIssue) {
+            return false;
         }
-        return count;
+        if (refreshedIssue.desiredStage === nextTarget) {
+            return true;
+        }
+        const activeStageRun = this.resolveActiveStageRun(refreshedIssue);
+        return activeStageRun !== undefined && activeStageRun.id !== stageRun.id && activeStageRun.stage === nextTarget;
     }
     async routeStageToHumanNeeded(project, stageRun, linearIssue, reason) {
         const linear = await this.linearProvider.forProject(stageRun.projectId);
@@ -408,29 +450,41 @@ export class ServiceStageFinalizer {
     }
     finishLedgerRun(projectId, linearIssueId, status, params) {
         const issueControl = this.stores.issueControl.getIssueControl(projectId, linearIssueId);
-        if (!issueControl?.activeRunLeaseId) {
+        const targetRunLeaseId = params.stageRunId ?? issueControl?.activeRunLeaseId;
+        if (!targetRunLeaseId) {
+            return;
+        }
+        const targetRunLease = this.stores.runLeases.getRunLease(targetRunLeaseId);
+        if (!targetRunLease) {
             return;
         }
         this.stores.runLeases.finishRunLease({
-            runLeaseId: issueControl.activeRunLeaseId,
+            runLeaseId: targetRunLeaseId,
             status,
             ...(params.threadId ? { threadId: params.threadId } : {}),
             ...(params.turnId ? { turnId: params.turnId } : {}),
             ...(params.failureReason ? { failureReason: params.failureReason } : {}),
         });
-        if (issueControl.activeWorkspaceOwnershipId !== undefined) {
-            const workspace = this.stores.workspaceOwnership.getWorkspaceOwnership(issueControl.activeWorkspaceOwnershipId);
+        if (targetRunLease.workspaceOwnershipId !== undefined) {
+            const workspace = this.stores.workspaceOwnership.getWorkspaceOwnership(targetRunLease.workspaceOwnershipId);
             if (workspace) {
                 this.stores.workspaceOwnership.upsertWorkspaceOwnership({
                     projectId,
                     linearIssueId,
                     branchName: workspace.branchName,
                     worktreePath: workspace.worktreePath,
-                    status: status === "completed" ? "active" : "paused",
-                    currentRunLeaseId: null,
+                    status: workspace.currentRunLeaseId === targetRunLeaseId ? (status === "completed" ? "active" : "paused") : workspace.status,
+                    ...(workspace.currentRunLeaseId === targetRunLeaseId
+                        ? { currentRunLeaseId: null }
+                        : workspace.currentRunLeaseId !== undefined
+                            ? { currentRunLeaseId: workspace.currentRunLeaseId }
+                            : {}),
                 });
             }
         }
+        if (!issueControl?.activeRunLeaseId || issueControl.activeRunLeaseId !== targetRunLeaseId) {
+            return;
+        }
         this.stores.issueControl.upsertIssueControl({
             projectId,
             linearIssueId,
@@ -631,14 +685,3 @@ function normalizeLinearState(value) {
     const trimmed = value?.trim();
     return trimmed ? trimmed.toLowerCase() : undefined;
 }
-function resolveDoneLinearState(issue) {
-    const typedMatch = issue.workflowStates.find((state) => normalizeLinearState(state.type) === "completed");
-    if (typedMatch?.name) {
-        return typedMatch.name;
-    }
-    const nameMatch = issue.workflowStates.find((state) => {
-        const normalized = normalizeLinearState(state.name);
-        return normalized === "done" || normalized === "completed" || normalized === "complete";
-    });
-    return nameMatch?.name;
-}

package/dist/service-stage-runner.js

@@ -1,3 +1,4 @@
+import { resolveAuthoritativeLinearStopState } from "./linear-workflow.js";
 import { buildStageLaunchPlan, isCodexThreadId } from "./stage-launch.js";
 import { syncFailedStageToLinear } from "./stage-failure.js";
 import { buildFailedStageReport } from "./stage-reporting.js";
@@ -47,6 +48,22 @@ export class ServiceStageRunner {
         if (!issue) {
             return;
         }
+        if (issue.lifecycleStatus === "completed" || issue.lifecycleStatus === "paused") {
+            this.feed?.publish({
+                level: "info",
+                kind: "workflow",
+                issueKey: issue.issueKey,
+                projectId: item.projectId,
+                stage: desiredStage,
+                ...(issue.selectedWorkflowId ? { workflowId: issue.selectedWorkflowId } : {}),
+                status: issue.lifecycleStatus === "completed" ? "completed" : "transition_suppressed",
+                summary: issue.lifecycleStatus === "completed"
+                    ? `Skipped ${desiredStage} because the issue is already complete`
+                    : `Skipped ${desiredStage} because the issue is already paused`,
+                detail: issue.currentLinearState ? `Live Linear state is ${issue.currentLinearState}.` : undefined,
+            });
+            return;
+        }
         const existingWorkspace = this.stores.workspaceOwnership.getWorkspaceOwnershipForIssue(item.projectId, item.issueId);
         const stageHistory = this.stores.issueWorkflows.listStageRunsForIssue(item.projectId, item.issueId);
         const previousStageRun = stageHistory.at(-1);
@@ -201,13 +218,28 @@ export class ServiceStageRunner {
     }
     async ensureLaunchIssueMirror(project, linearIssueId, _desiredStage, _desiredWebhookId) {
         const existing = this.stores.issueWorkflows.getTrackedIssue(project.id, linearIssueId);
-        if (existing?.issueKey && existing.title && existing.issueUrl && existing.currentLinearState) {
-            return existing;
-        }
         const liveIssue = await this.linearProvider
             .forProject(project.id)
             .then((linear) => linear?.getIssue(linearIssueId))
             .catch(() => undefined);
+        const authoritativeStopState = liveIssue ? resolveAuthoritativeLinearStopState(liveIssue) : undefined;
+        if (authoritativeStopState) {
+            this.stores.workflowCoordinator.setIssueDesiredStage(project.id, linearIssueId, undefined, {
+                lifecycleStatus: authoritativeStopState.lifecycleStatus,
+            });
+            return this.stores.workflowCoordinator.upsertTrackedIssue({
+                projectId: project.id,
+                linearIssueId,
+                ...(liveIssue?.identifier ? { issueKey: liveIssue.identifier } : existing?.issueKey ? { issueKey: existing.issueKey } : {}),
+                ...(liveIssue?.title ? { title: liveIssue.title } : existing?.title ? { title: existing.title } : {}),
+                ...(liveIssue?.url ? { issueUrl: liveIssue.url } : existing?.issueUrl ? { issueUrl: existing.issueUrl } : {}),
+                currentLinearState: authoritativeStopState.stateName,
+                lifecycleStatus: authoritativeStopState.lifecycleStatus,
+            });
+        }
+        if (!liveIssue && existing?.issueKey && existing.title && existing.issueUrl && existing.currentLinearState) {
+            return existing;
+        }
         return this.stores.workflowCoordinator.recordDesiredStage({
             projectId: project.id,
             linearIssueId,

package/package.json

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