patchrelay 0.8.5 → 0.8.7

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.8.5",
-  "commit": "1a8f1cf74d1f",
-  "builtAt": "2026-03-19T10:46:11.106Z"
+  "version": "0.8.7",
+  "commit": "d054181e45d3",
+  "builtAt": "2026-03-19T11:51:02.960Z"
 }

package/dist/reconciliation-action-applier.js

@@ -45,6 +45,19 @@ export class ReconciliationActionApplier {
         if (decision.outcome === "fail" || decision.outcome === "release") {
             const failedAction = decision.actions.find((action) => action.type === "mark_run_failed");
             if (decision.outcome === "release" && failedAction?.type !== "mark_run_failed") {
+                const releasedAction = decision.actions.find((action) => action.type === "release_issue_ownership");
+                if (releasedAction?.type !== "release_issue_ownership") {
+                    return;
+                }
+                await this.callbacks.releaseRunDuringReconciliation(snapshot.runLease.projectId, snapshot.runLease.linearIssueId, {
+                    runId: snapshot.runLease.id,
+                    ...(threadId ? { threadId } : {}),
+                    ...(turnId ? { turnId } : {}),
+                    ...(nextLifecycleStatus ? { nextLifecycleStatus } : {}),
+                    ...(snapshot.input.live?.linear?.status === "known" && snapshot.input.live.linear.issue?.stateName
+                        ? { currentLinearState: snapshot.input.live.linear.issue.stateName }
+                        : {}),
+                });
                 return;
             }
             await this.callbacks.failRunDuringReconciliation(snapshot.runLease.projectId, snapshot.runLease.linearIssueId, failedAction?.type === "mark_run_failed" && failedAction.threadId

package/dist/reconciliation-engine.js

@@ -68,6 +68,23 @@ export function reconcileIssue(input) {
 function reconcileActiveRun(params) {
     const { issue, liveLinear, liveCodex, obligations, policy } = params;
     const run = issue.activeRun;
+    const authoritativeStopState = resolveAuthoritativeStopState(liveLinear);
+    if (authoritativeStopState) {
+        return {
+            outcome: "release",
+            reasons: [`live Linear state is already ${authoritativeStopState.stateName}`],
+            actions: [
+                {
+                    type: "release_issue_ownership",
+                    projectId: issue.projectId,
+                    linearIssueId: issue.linearIssueId,
+                    runId: run.id,
+                    nextLifecycleStatus: authoritativeStopState.lifecycleStatus,
+                    reason: `live Linear state is already ${authoritativeStopState.stateName}`,
+                },
+            ],
+        };
+    }
     if (run.status === "queued") {
         return {
             outcome: "launch",
@@ -295,6 +312,27 @@ function matchesActiveLinearOwnership(liveLinear, policy) {
     }
     return liveLinear.issue?.stateName === policy.activeLinearStateName;
 }
+function resolveAuthoritativeStopState(liveLinear) {
+    if (liveLinear.status !== "known" || !liveLinear.issue?.stateName) {
+        return undefined;
+    }
+    const stateName = liveLinear.issue.stateName.trim();
+    const normalizedName = stateName.toLowerCase();
+    const normalizedType = liveLinear.issue.stateType?.trim().toLowerCase();
+    if (normalizedType === "completed" || normalizedName === "done" || normalizedName === "completed" || normalizedName === "complete") {
+        return {
+            stateName,
+            lifecycleStatus: "completed",
+        };
+    }
+    if (normalizedName === "human needed") {
+        return {
+            stateName,
+            lifecycleStatus: "paused",
+        };
+    }
+    return undefined;
+}
 function relevantObligations(issue, obligations) {
     const activeRunId = issue.activeRun?.id;
     return obligations.filter((obligation) => {

package/dist/reconciliation-snapshot-builder.js

@@ -22,6 +22,10 @@ export async function buildReconciliationSnapshot(params) {
                     issue: {
                         id: issue.id,
                         stateName: issue.stateName,
+                        ...(() => {
+                            const currentState = issue.workflowStates?.find((state) => state.name === issue.stateName);
+                            return currentState?.type ? { stateType: currentState.type } : {};
+                        })(),
                     },
                 }
                 : ({ status: "unknown" }))

package/dist/service-stage-finalizer.js

@@ -36,6 +36,7 @@ export class ServiceStageFinalizer {
             deliverPendingObligations: (projectId, linearIssueId, threadId, turnId) => this.deliverPendingObligations(projectId, linearIssueId, threadId, turnId),
             completeRun: (projectId, linearIssueId, thread, params) => this.completeReconciledRun(projectId, linearIssueId, thread, params),
             failRunDuringReconciliation: (projectId, linearIssueId, threadId, message, options) => this.failRunLeaseDuringReconciliation(projectId, linearIssueId, threadId, message, options),
+            releaseRunDuringReconciliation: (projectId, linearIssueId, params) => this.releaseRunDuringReconciliation(projectId, linearIssueId, params),
         });
     }
     async getActiveStageStatus(issueKey) {
@@ -468,13 +469,21 @@ export class ServiceStageFinalizer {
         if (targetRunLease.workspaceOwnershipId !== undefined) {
             const workspace = this.stores.workspaceOwnership.getWorkspaceOwnership(targetRunLease.workspaceOwnershipId);
             if (workspace) {
+                const workspaceOwnedByTargetRun = workspace.currentRunLeaseId === targetRunLeaseId ||
+                    (issueControl?.activeWorkspaceOwnershipId === workspace.id && issueControl.activeRunLeaseId === targetRunLeaseId);
                 this.stores.workspaceOwnership.upsertWorkspaceOwnership({
                     projectId,
                     linearIssueId,
                     branchName: workspace.branchName,
                     worktreePath: workspace.worktreePath,
-                    status: workspace.currentRunLeaseId === targetRunLeaseId ? (status === "completed" ? "active" : "paused") : workspace.status,
-                    ...(workspace.currentRunLeaseId === targetRunLeaseId
+                    status: workspaceOwnedByTargetRun
+                        ? status === "released"
+                            ? "released"
+                            : status === "completed"
+                                ? "active"
+                                : "paused"
+                        : workspace.status,
+                    ...(workspaceOwnedByTargetRun
                         ? { currentRunLeaseId: null }
                         : workspace.currentRunLeaseId !== undefined
                             ? { currentRunLeaseId: workspace.currentRunLeaseId }
@@ -489,9 +498,11 @@ export class ServiceStageFinalizer {
             projectId,
             linearIssueId,
             activeRunLeaseId: null,
-            ...(issueControl.activeWorkspaceOwnershipId !== undefined
-                ? { activeWorkspaceOwnershipId: issueControl.activeWorkspaceOwnershipId }
-                : {}),
+            ...(status === "released"
+                ? { activeWorkspaceOwnershipId: null }
+                : issueControl.activeWorkspaceOwnershipId !== undefined
+                    ? { activeWorkspaceOwnershipId: issueControl.activeWorkspaceOwnershipId }
+                    : {}),
             ...(issueControl.serviceOwnedCommentId ? { serviceOwnedCommentId: issueControl.serviceOwnedCommentId } : {}),
             ...(issueControl.activeAgentSessionId ? { activeAgentSessionId: issueControl.activeAgentSessionId } : {}),
             lifecycleStatus: params.nextLifecycleStatus,
@@ -541,10 +552,27 @@ export class ServiceStageFinalizer {
     }
     async restartInterruptedRun(snapshot) {
         const liveCodex = snapshot.input.live?.codex;
+        const liveLinear = snapshot.input.live?.linear;
         const latestTurn = liveCodex?.status === "found" ? liveCodex.thread?.turns.at(-1) : undefined;
         if (latestTurn?.status !== "interrupted") {
             return false;
         }
+        if (liveLinear?.status === "known") {
+            const authoritativeStopState = resolveAuthoritativeLinearStopState({
+                ...(liveLinear.issue?.stateName ? { stateName: liveLinear.issue.stateName } : {}),
+                workflowStates: liveLinear.issue?.stateName
+                    ? [
+                        {
+                            name: liveLinear.issue.stateName,
+                            ...(liveLinear.issue.stateType ? { type: liveLinear.issue.stateType } : {}),
+                        },
+                    ]
+                    : [],
+            });
+            if (authoritativeStopState) {
+                return false;
+            }
+        }
         if (snapshot.runLease.turnId && latestTurn.id !== snapshot.runLease.turnId) {
             return true;
         }
@@ -623,6 +651,44 @@ export class ServiceStageFinalizer {
         }
         await this.failStageRunDuringReconciliation(stageRun, threadId, message, options);
     }
+    async releaseRunDuringReconciliation(projectId, linearIssueId, params) {
+        const runId = typeof params.runId === "number" ? params.runId : Number(params.runId);
+        if (!Number.isFinite(runId)) {
+            return;
+        }
+        this.runAtomically(() => {
+            this.finishLedgerRun(projectId, linearIssueId, "released", {
+                stageRunId: runId,
+                ...(params.threadId ? { threadId: params.threadId } : {}),
+                ...(params.turnId ? { turnId: params.turnId } : {}),
+                nextLifecycleStatus: params.nextLifecycleStatus ?? "completed",
+            });
+            const existingIssue = this.stores.issueWorkflows.getTrackedIssue(projectId, linearIssueId);
+            this.stores.workflowCoordinator.upsertTrackedIssue({
+                projectId,
+                linearIssueId,
+                ...(params.currentLinearState
+                    ? { currentLinearState: params.currentLinearState }
+                    : existingIssue?.currentLinearState
+                        ? { currentLinearState: existingIssue.currentLinearState }
+                        : {}),
+                lifecycleStatus: params.nextLifecycleStatus ?? "completed",
+            });
+        });
+        const issue = this.stores.issueWorkflows.getTrackedIssue(projectId, linearIssueId);
+        this.feed?.publish({
+            level: "info",
+            kind: "workflow",
+            issueKey: issue?.issueKey,
+            projectId,
+            ...(issue?.selectedWorkflowId ? { workflowId: issue.selectedWorkflowId } : {}),
+            status: params.nextLifecycleStatus === "paused" ? "transition_suppressed" : "completed",
+            summary: params.nextLifecycleStatus === "paused"
+                ? "Released stale run after terminal Linear pause"
+                : "Released stale run after terminal Linear completion",
+            detail: params.currentLinearState ? `Live Linear state is already ${params.currentLinearState}.` : undefined,
+        });
+    }
     findStageRunForIssue(projectId, linearIssueId, threadId) {
         return (threadId ? this.stores.issueWorkflows.getStageRunByThreadId(threadId) : undefined) ??
             this.stores.issueWorkflows.getLatestStageRunForIssue(projectId, linearIssueId);

package/package.json

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