patchrelay 0.49.0 → 0.49.1

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.49.0",
-  "commit": "e4ca4c92eb96",
-  "builtAt": "2026-04-19T10:24:09.505Z"
+  "version": "0.49.1",
+  "commit": "b14320b27556",
+  "builtAt": "2026-04-19T11:22:46.139Z"
 }

package/dist/cli/data.js

@@ -9,6 +9,8 @@ import { buildManualRetryAttemptReset, resolveRetryTarget } from "../manual-issu
 import { WorktreeManager } from "../worktree-manager.js";
 import { parseDelegationObservedPayload, parseRunReleasedAuthorityPayload } from "../delegation-audit.js";
 import { CliOperatorApiClient } from "./operator-client.js";
+import { resolveEffectiveActiveRun } from "../effective-active-run.js";
+import { derivePatchRelayWaitingReason } from "../waiting-reason.js";
 function safeJsonParse(value) {
     if (!value)
         return undefined;
@@ -105,8 +107,11 @@ export class CliDataAccess extends CliOperatorApiClient {
         if (!issue)
             return undefined;
         const dbIssue = this.db.issues.getIssueByKey(issueKey);
-        const activeRun = dbIssue.activeRunId ? this.db.runs.getRunById(dbIssue.activeRunId) : undefined;
         const latestRun = this.db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
+        const activeRun = resolveEffectiveActiveRun({
+            activeRun: dbIssue.activeRunId ? this.db.runs.getRunById(dbIssue.activeRunId) : undefined,
+            latestRun,
+        });
         const latestReport = normalizeStageReport(latestRun?.reportJson, latestRun?.status);
         const latestSummary = safeJsonParse(latestRun?.summaryJson);
         const completionCheck = latestRun ? extractCompletionCheck(latestRun) : undefined;
@@ -139,7 +144,10 @@ export class CliDataAccess extends CliOperatorApiClient {
         if (!issue)
             return undefined;
         const dbIssue = this.db.issues.getIssueByKey(issueKey);
-        const run = dbIssue.activeRunId ? this.db.runs.getRunById(dbIssue.activeRunId) : undefined;
+        const run = resolveEffectiveActiveRun({
+            activeRun: dbIssue.activeRunId ? this.db.runs.getRunById(dbIssue.activeRunId) : undefined,
+            latestRun: this.db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId),
+        });
         if (!run)
             return undefined;
         const live = run.threadId &&
@@ -469,19 +477,36 @@ export class CliDataAccess extends CliOperatorApiClient {
         ORDER BY i.updated_at DESC, i.issue_key ASC
         `)
             .all(...values);
-        const items = rows.map((row) => ({
-            ...(row.issue_key !== null ? { issueKey: String(row.issue_key) } : {}),
-            ...(row.title !== null ? { title: String(row.title) } : {}),
-            projectId: String(row.project_id),
-            ...(row.current_linear_state !== null ? { currentLinearState: String(row.current_linear_state) } : {}),
-            ...(row.session_state !== null ? { sessionState: String(row.session_state) } : {}),
-            factoryState: String(row.factory_state ?? "delegated"),
-            ...(row.waiting_reason !== null ? { waitingReason: String(row.waiting_reason) } : {}),
-            ...(row.active_run_type !== null ? { activeRunType: String(row.active_run_type) } : {}),
-            ...(row.latest_run_type !== null ? { latestRunType: String(row.latest_run_type) } : {}),
-            ...(row.latest_run_status !== null ? { latestRunStatus: String(row.latest_run_status) } : {}),
-            updatedAt: String(row.updated_at),
-        }));
+        const items = rows.map((row) => {
+            const detachedActiveRun = row.active_run_type === null
+                && (row.latest_run_status === "queued" || row.latest_run_status === "running");
+            const activeRunType = row.active_run_type !== null
+                ? String(row.active_run_type)
+                : detachedActiveRun && row.latest_run_type !== null
+                    ? String(row.latest_run_type)
+                    : undefined;
+            const waitingReason = detachedActiveRun
+                ? derivePatchRelayWaitingReason({
+                    activeRunId: 1,
+                    factoryState: String(row.factory_state ?? "delegated"),
+                })
+                : row.waiting_reason !== null
+                    ? String(row.waiting_reason)
+                    : undefined;
+            return {
+                ...(row.issue_key !== null ? { issueKey: String(row.issue_key) } : {}),
+                ...(row.title !== null ? { title: String(row.title) } : {}),
+                projectId: String(row.project_id),
+                ...(row.current_linear_state !== null ? { currentLinearState: String(row.current_linear_state) } : {}),
+                ...(row.session_state !== null ? { sessionState: detachedActiveRun ? "running" : String(row.session_state) } : {}),
+                factoryState: String(row.factory_state ?? "delegated"),
+                ...(waitingReason ? { waitingReason } : {}),
+                ...(activeRunType ? { activeRunType } : {}),
+                ...(row.latest_run_type !== null ? { latestRunType: String(row.latest_run_type) } : {}),
+                ...(row.latest_run_status !== null ? { latestRunStatus: String(row.latest_run_status) } : {}),
+                updatedAt: String(row.updated_at),
+            };
+        });
         return items.filter((item) => {
             if (options?.active && !item.activeRunType)
                 return false;

package/dist/effective-active-run.js

@@ -0,0 +1,15 @@
+function isActiveRunStatus(status) {
+    return status === "queued" || status === "running";
+}
+export function hasDetachedActiveLatestRun(params) {
+    return params.activeRunId === undefined
+        && params.latestRun !== undefined
+        && isActiveRunStatus(params.latestRun.status);
+}
+export function resolveEffectiveActiveRun(params) {
+    if (params.activeRun)
+        return params.activeRun;
+    if (params.latestRun && isActiveRunStatus(params.latestRun.status))
+        return params.latestRun;
+    return undefined;
+}

package/dist/run-reconciler.js

@@ -4,6 +4,7 @@ import { resolveAuthoritativeLinearStopState } from "./linear-workflow.js";
 import { buildRunFailureActivity } from "./linear-session-reporting.js";
 import { getThreadTurns } from "./codex-thread-utils.js";
 import { resolveRecoverablePostRunState } from "./interrupted-run-recovery.js";
+import { resolveEffectiveActiveRun } from "./effective-active-run.js";
 export class RunReconciler {
     db;
     logger;
@@ -33,6 +34,19 @@ export class RunReconciler {
         const { run, issue, recoveryLease } = params;
         const acquiredRecoveryLease = recoveryLease === true;
         let effectiveIssue = issue;
+        const effectiveActiveRun = resolveEffectiveActiveRun({
+            activeRun: issue.activeRunId === run.id ? run : undefined,
+            latestRun: run,
+        });
+        if (effectiveActiveRun?.id === run.id && issue.activeRunId !== run.id) {
+            effectiveIssue = this.withHeldLease(run.projectId, run.linearIssueId, () => this.db.issues.upsertIssue({
+                projectId: run.projectId,
+                linearIssueId: run.linearIssueId,
+                activeRunId: run.id,
+                ...(run.threadId ? { threadId: run.threadId } : {}),
+            })) ?? effectiveIssue;
+            this.logger.info({ issueKey: effectiveIssue.issueKey, runId: run.id, runType: run.runType }, "Reattached detached active run during reconciliation");
+        }
         if (!effectiveIssue.delegatedToPatchRelay) {
             const authority = await this.confirmDelegationAuthorityBeforeRelease(run, effectiveIssue);
             effectiveIssue = authority.issue;

package/dist/tracked-issue-list-query.js

@@ -2,6 +2,7 @@ import { parseGitHubFailureContext, summarizeGitHubFailureContext } from "./gith
 import { derivePatchRelayWaitingReason } from "./waiting-reason.js";
 import { deriveIssueStatusNote } from "./status-note.js";
 import { isIssueSessionReadyForExecution } from "./issue-session.js";
+import { hasDetachedActiveLatestRun } from "./effective-active-run.js";
 function shouldSuppressStatusNote(params) {
     if (!params.activeRunType && params.sessionState !== "running")
         return false;
@@ -155,11 +156,24 @@ export class TrackedIssueListQuery {
             const hasPendingSessionEvents = Number(row.pending_session_event_count ?? 0) > 0;
             const hasPendingWake = hasPendingSessionEvents
                 || this.db.issueSessions.peekIssueSessionWake(String(row.project_id), String(row.linear_issue_id)) !== undefined;
+            const detachedActiveRun = hasDetachedActiveLatestRun({
+                activeRunId: row.active_run_type !== null ? 1 : undefined,
+                latestRun: row.latest_run_status !== null
+                    ? { id: 0, status: String(row.latest_run_status) }
+                    : undefined,
+            });
+            const effectiveActiveRunType = row.active_run_type !== null
+                ? String(row.active_run_type)
+                : detachedActiveRun && row.latest_run_type !== null
+                    ? String(row.latest_run_type)
+                    : undefined;
             const readyForExecution = isIssueSessionReadyForExecution({
-                ...(typeof row.session_state === "string" ? { sessionState: String(row.session_state) } : {}),
+                ...(typeof row.session_state === "string"
+                    ? { sessionState: detachedActiveRun ? "running" : String(row.session_state) }
+                    : {}),
                 factoryState: String(row.factory_state ?? "delegated"),
                 ...(row.delegated_to_patchrelay !== null ? { delegatedToPatchRelay: Number(row.delegated_to_patchrelay) !== 0 } : {}),
-                ...(row.active_run_type !== null ? { activeRunId: 1 } : {}),
+                ...((row.active_run_type !== null || detachedActiveRun) ? { activeRunId: 1 } : {}),
                 blockedByCount,
                 hasPendingWake,
                 hasLegacyPendingRun: row.pending_run_type !== null && row.pending_run_type !== undefined,
@@ -177,9 +191,9 @@ export class TrackedIssueListQuery {
             const sessionSummary = typeof row.summary_text === "string" && row.summary_text.trim().length > 0
                 ? row.summary_text
                 : undefined;
-            const waitingReason = sessionWaitingReason ?? derivePatchRelayWaitingReason({
+            const derivedWaitingReason = derivePatchRelayWaitingReason({
                 ...(row.delegated_to_patchrelay !== null ? { delegatedToPatchRelay: Number(row.delegated_to_patchrelay) !== 0 } : {}),
-                ...(row.active_run_type !== null ? { activeRunType: String(row.active_run_type) } : {}),
+                ...((row.active_run_type !== null || detachedActiveRun) ? { activeRunId: 1 } : {}),
                 blockedByKeys,
                 factoryState: String(row.factory_state ?? "delegated"),
                 ...(row.pending_run_type !== null ? { pendingRunType: String(row.pending_run_type) } : {}),
@@ -192,6 +206,7 @@ export class TrackedIssueListQuery {
                 ...(row.last_blocking_review_head_sha !== null ? { lastBlockingReviewHeadSha: String(row.last_blocking_review_head_sha) } : {}),
                 ...(row.last_github_failure_check_name !== null ? { latestFailureCheckName: String(row.last_github_failure_check_name) } : {}),
             });
+            const waitingReason = detachedActiveRun ? derivedWaitingReason : sessionWaitingReason ?? derivedWaitingReason;
             const latestRun = row.latest_run_type !== null && row.latest_run_status !== null
                 ? {
                     id: 0,
@@ -222,29 +237,39 @@ export class TrackedIssueListQuery {
                 waitingReason,
             }) ?? waitingReason;
             const statusNoteForReturn = shouldSuppressStatusNote({
-                activeRunType: row.active_run_type,
-                sessionState: row.session_state,
+                activeRunType: effectiveActiveRunType,
+                sessionState: detachedActiveRun ? "running" : row.session_state,
                 statusNote: statusNoteCandidate,
             })
                 ? undefined
                 : statusNoteCandidate;
-            const completionCheckActive = typeof row.active_completion_check_thread_id === "string"
-                && row.active_completion_check_thread_id.length > 0
-                && row.active_completion_check_outcome === null
-                && row.active_run_type !== null;
+            const activeCompletionCheckThreadId = row.active_run_type !== null
+                ? row.active_completion_check_thread_id
+                : detachedActiveRun
+                    ? row.latest_run_completion_check_thread_id
+                    : null;
+            const activeCompletionCheckOutcome = row.active_run_type !== null
+                ? row.active_completion_check_outcome
+                : detachedActiveRun
+                    ? row.latest_run_completion_check_outcome
+                    : null;
+            const completionCheckActive = typeof activeCompletionCheckThreadId === "string"
+                && activeCompletionCheckThreadId.length > 0
+                && activeCompletionCheckOutcome === null
+                && effectiveActiveRunType !== undefined;
             return {
                 ...(row.issue_key !== null ? { issueKey: String(row.issue_key) } : {}),
                 ...(row.title !== null ? { title: String(row.title) } : {}),
                 ...(statusNoteForReturn ? { statusNote: statusNoteForReturn } : {}),
                 projectId: String(row.project_id),
                 delegatedToPatchRelay: row.delegated_to_patchrelay === null ? true : Number(row.delegated_to_patchrelay) !== 0,
-                ...(row.session_state !== null ? { sessionState: String(row.session_state) } : {}),
+                ...(row.session_state !== null ? { sessionState: detachedActiveRun ? "running" : String(row.session_state) } : {}),
                 factoryState: String(row.factory_state ?? "delegated"),
                 blockedByCount,
                 blockedByKeys,
                 readyForExecution,
                 ...(row.current_linear_state !== null ? { currentLinearState: String(row.current_linear_state) } : {}),
-                ...(row.active_run_type !== null ? { activeRunType: String(row.active_run_type) } : {}),
+                ...(effectiveActiveRunType ? { activeRunType: effectiveActiveRunType } : {}),
                 ...(row.pending_run_type !== null ? { pendingRunType: String(row.pending_run_type) } : {}),
                 ...(row.latest_run_type !== null ? { latestRunType: String(row.latest_run_type) } : {}),
                 ...(row.latest_run_status !== null ? { latestRunStatus: String(row.latest_run_status) } : {}),

package/dist/tracked-issue-projector.js

@@ -2,6 +2,7 @@ import { parseGitHubFailureContext } from "./github-failure-context.js";
 import { isIssueSessionReadyForExecution } from "./issue-session.js";
 import { deriveIssueStatusNote } from "./status-note.js";
 import { derivePatchRelayWaitingReason } from "./waiting-reason.js";
+import { hasDetachedActiveLatestRun, resolveEffectiveActiveRun } from "./effective-active-run.js";
 export function isResolvedLinearState(stateType, stateName) {
     return stateType === "completed" || stateName?.trim().toLowerCase() === "done";
 }
@@ -9,9 +10,17 @@ export function buildTrackedIssueRecord(params) {
     const unresolvedBlockedBy = params.blockedBy.filter((entry) => !isResolvedLinearState(entry.blockerCurrentLinearStateType, entry.blockerCurrentLinearState));
     const failureContext = parseGitHubFailureContext(params.issue.lastGitHubFailureContextJson);
     const blockedByKeys = unresolvedBlockedBy.map((entry) => entry.blockerIssueKey ?? entry.blockerLinearIssueId);
+    const effectiveActiveRun = resolveEffectiveActiveRun({
+        activeRun: params.issue.activeRunId !== undefined && params.latestRun?.id === params.issue.activeRunId ? params.latestRun : undefined,
+        latestRun: params.latestRun,
+    });
+    const detachedActiveRun = hasDetachedActiveLatestRun({
+        activeRunId: params.issue.activeRunId,
+        latestRun: params.latestRun,
+    });
     const waitingReason = derivePatchRelayWaitingReason({
         delegatedToPatchRelay: params.issue.delegatedToPatchRelay,
-        ...(params.issue.activeRunId !== undefined ? { activeRunId: params.issue.activeRunId } : {}),
+        ...(effectiveActiveRun ? { activeRunId: effectiveActiveRun.id } : {}),
         blockedByKeys,
         factoryState: params.issue.factoryState,
         pendingRunType: params.issue.pendingRunType,
@@ -33,11 +42,9 @@ export function buildTrackedIssueRecord(params) {
         blockedByKeys,
         waitingReason,
     });
-    const completionCheckActive = Boolean(params.issue.activeRunId !== undefined
-        && params.latestRun?.id === params.issue.activeRunId
-        && params.latestRun.status === "running"
-        && params.latestRun.completionCheckThreadId
-        && !params.latestRun.completionCheckOutcome);
+    const completionCheckActive = Boolean(effectiveActiveRun?.status === "running"
+        && effectiveActiveRun.completionCheckThreadId
+        && !effectiveActiveRun.completionCheckOutcome);
     return {
         id: params.issue.id,
         projectId: params.issue.projectId,
@@ -61,7 +68,7 @@ export function buildTrackedIssueRecord(params) {
             sessionState: params.session?.sessionState,
             factoryState: params.issue.factoryState,
             delegatedToPatchRelay: params.issue.delegatedToPatchRelay,
-            activeRunId: params.issue.activeRunId,
+            ...(effectiveActiveRun ? { activeRunId: effectiveActiveRun.id } : {}),
             blockedByCount: unresolvedBlockedBy.length,
             hasPendingWake: params.hasPendingWake,
             hasLegacyPendingRun: params.issue.pendingRunType !== undefined,
@@ -79,8 +86,9 @@ export function buildTrackedIssueRecord(params) {
         ...(failureContext?.summary ? { latestFailureSummary: failureContext.summary } : {}),
         ...(waitingReason ? { waitingReason } : {}),
         ...(completionCheckActive ? { completionCheckActive } : {}),
-        ...(params.issue.activeRunId !== undefined ? { activeRunId: params.issue.activeRunId } : {}),
+        ...(effectiveActiveRun ? { activeRunId: effectiveActiveRun.id } : {}),
         ...(params.issue.agentSessionId ? { activeAgentSessionId: params.issue.agentSessionId } : {}),
+        ...(detachedActiveRun && params.session?.sessionState ? { sessionState: "running" } : {}),
         updatedAt: params.issue.updatedAt,
     };
 }

package/dist/tracked-issue-query.js

@@ -1,5 +1,6 @@
 import { buildTrackedIssueRecord } from "./tracked-issue-projector.js";
 import { deriveIssueSessionState, isIssueSessionReadyForExecution } from "./issue-session.js";
+import { resolveEffectiveActiveRun } from "./effective-active-run.js";
 export class TrackedIssueQuery {
     issues;
     issueSessions;
@@ -55,7 +56,10 @@ export class TrackedIssueQuery {
         if (!issue)
             return undefined;
         const tracked = this.issueToTrackedIssue(issue);
-        const activeRun = issue.activeRunId ? this.runs.getRunById(issue.activeRunId) : undefined;
+        const activeRun = resolveEffectiveActiveRun({
+            activeRun: issue.activeRunId ? this.runs.getRunById(issue.activeRunId) : undefined,
+            latestRun: this.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId),
+        });
         return {
             issue: tracked,
             ...(activeRun ? { activeRun } : {}),

package/package.json

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