patchrelay 0.40.0 → 0.40.1

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.40.0",
-  "commit": "c1cef920f5e3",
-  "builtAt": "2026-04-11T22:19:02.944Z"
+  "version": "0.40.1",
+  "commit": "a0d40b1e8b30",
+  "builtAt": "2026-04-12T19:50:43.295Z"
 }

package/dist/cli/commands/issues.js

@@ -2,7 +2,7 @@ import { setTimeout as delay } from "node:timers/promises";
 import { getRunTypeFlag } from "../args.js";
 import { CliUsageError } from "../errors.js";
 import { formatJson } from "../formatters/json.js";
-import { formatClose, formatInspect, formatList, formatLive, formatOpen, formatRetry, formatSessionHistory, formatTranscriptSource, formatWorktree } from "../formatters/text.js";
+import { formatAudit, formatClose, formatInspect, formatList, formatLive, formatOpen, formatRetry, formatSessionHistory, formatTranscriptSource, formatWorktree } from "../formatters/text.js";
 import { buildOpenCommand } from "../interactive.js";
 import { writeOutput } from "../output.js";
 export async function handleIssueCommand(params) {
@@ -36,6 +36,8 @@ export async function handleIssueCommand(params) {
             return await handleOpenCommand(nested);
         case "sessions":
             return await handleSessionsCommand(nested);
+        case "audit":
+            return await handleAuditCommand(nested);
         case "transcript-source":
             return await handleTranscriptSourceCommand(nested);
         case "retry":
@@ -156,6 +158,18 @@ export async function handleSessionsCommand(params) {
         : formatSessionHistory(result, (threadId) => buildOpenCommand(params.config, result.worktreePath ?? "", threadId)));
     return 0;
 }
+export async function handleAuditCommand(params) {
+    const issueKey = params.commandArgs[0];
+    if (!issueKey) {
+        throw new Error("audit requires <issueKey>.");
+    }
+    const result = params.data.audit(issueKey);
+    if (!result) {
+        throw new Error(`Issue not found: ${issueKey}`);
+    }
+    writeOutput(params.stdout, params.json ? formatJson(result) : formatAudit(result));
+    return 0;
+}
 export async function handleRetryCommand(params) {
     const issueKey = params.commandArgs[0];
     if (!issueKey) {

package/dist/cli/data.js

@@ -7,6 +7,7 @@ import { getThreadTurns } from "../codex-thread-utils.js";
 import { PatchRelayDatabase } from "../db.js";
 import { buildManualRetryAttemptReset, resolveRetryTarget } from "../manual-issue-actions.js";
 import { WorktreeManager } from "../worktree-manager.js";
+import { parseDelegationObservedPayload, parseRunReleasedAuthorityPayload } from "../delegation-audit.js";
 import { CliOperatorApiClient } from "./operator-client.js";
 function safeJsonParse(value) {
     if (!value)
@@ -273,6 +274,50 @@ export class CliDataAccess extends CliOperatorApiClient {
             ...(run ? { releasedRunId: run.id } : {}),
         };
     }
+    audit(issueKey) {
+        const issue = this.db.getTrackedIssueByKey(issueKey);
+        if (!issue)
+            return undefined;
+        const events = this.db.issueSessions
+            .listIssueSessionEvents(issue.projectId, issue.linearIssueId)
+            .flatMap((event) => {
+            const delegationObserved = parseDelegationObservedPayload(event);
+            if (delegationObserved) {
+                return [{
+                        createdAt: event.createdAt,
+                        eventType: event.eventType,
+                        summary: [
+                            delegationObserved.source,
+                            `observed=${delegationObserved.observedDelegatedToPatchRelay ? "delegated" : "undelegated"}`,
+                            `applied=${delegationObserved.appliedDelegatedToPatchRelay ? "delegated" : "undelegated"}`,
+                            `hydration=${delegationObserved.hydration}`,
+                            delegationObserved.reason ? `reason=${delegationObserved.reason}` : undefined,
+                        ].filter(Boolean).join(" "),
+                        details: delegationObserved,
+                    }];
+            }
+            const authorityRelease = parseRunReleasedAuthorityPayload(event);
+            if (authorityRelease) {
+                return [{
+                        createdAt: event.createdAt,
+                        eventType: event.eventType,
+                        summary: `released run #${authorityRelease.runId} (${authorityRelease.runType}) via ${authorityRelease.source}: ${authorityRelease.reason}`,
+                        details: authorityRelease,
+                    }];
+            }
+            if (event.eventType === "delegated" || event.eventType === "undelegated") {
+                return [{
+                        createdAt: event.createdAt,
+                        eventType: event.eventType,
+                        summary: event.eventType === "delegated"
+                            ? "PatchRelay accepted delegation"
+                            : "PatchRelay recorded undelegation",
+                    }];
+            }
+            return [];
+        });
+        return { issue, events };
+    }
     transcriptSource(issueKey, runId) {
         const issue = this.db.getTrackedIssueByKey(issueKey);
         if (!issue)

package/dist/cli/formatters/text.js

@@ -84,6 +84,26 @@ export function formatRetry(result) {
         .filter(Boolean)
         .join("\n")}\n`;
 }
+export function formatAudit(result) {
+    const lines = [
+        `${result.issue.issueKey ?? result.issue.linearIssueId}${result.issue.currentLinearState ? `  ${result.issue.currentLinearState}` : ""}`,
+    ];
+    if (result.events.length === 0) {
+        lines.push("No delegation audit events recorded.");
+        return `${lines.join("\n")}\n`;
+    }
+    for (const event of result.events) {
+        lines.push("");
+        lines.push([event.createdAt, event.eventType].join("  "));
+        lines.push(event.summary);
+        if (event.details && Object.keys(event.details).length > 0) {
+            lines.push(Object.entries(event.details)
+                .map(([key, value]) => `${key}=${value === undefined ? "-" : typeof value === "string" ? value : JSON.stringify(value)}`)
+                .join(" "));
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}
 export function formatClose(result) {
     return `${[
         value("Issue", result.issue.issueKey ?? result.issue.linearIssueId),

package/dist/cli/help.js

@@ -34,6 +34,7 @@ export function rootHelpText() {
         "  issue list [--active] [--failed] [--repo <id>] [--json]",
         "                                                          List tracked issues",
         "  issue show <issueKey> [--json]                          Show the latest known issue state",
+        "  issue audit <issueKey> [--json]                         Show delegation/release audit events for one issue",
         "  issue watch <issueKey> [--json]                         Follow the active run until it settles",
         "  issue open <issueKey> [--print] [--json]                Open Codex in the issue worktree",
         "  issue sessions <issueKey> [--json]                      Show recorded Codex app-server sessions for one issue",
@@ -146,6 +147,7 @@ export function issueHelpText() {
         "",
         "Commands:",
         "  show <issueKey>                 Show the latest known issue state",
+        "  audit <issueKey>                Show delegation/release audit events",
         "  list                            List tracked issues",
         "  watch <issueKey>                Follow issue activity until it settles",
         "  path <issueKey>                 Print the issue worktree path",

package/dist/cli/watch/state-visualization.js

@@ -127,7 +127,7 @@ export function buildPatchRelayQueueObservations(issue, feedEvents) {
                 case "awaiting_queue":
                     observations.push({
                         tone: "info",
-                        text: "PatchRelay has finished active work and is waiting for downstream merge flow.",
+                        text: "PatchRelay has finished active work. Delivery now depends on downstream review and merge automation.",
                     });
                     break;
                 case "repairing_queue":

package/dist/db/issue-session-store.js

@@ -1,4 +1,4 @@
-import { deriveSessionWakePlan } from "../issue-session-events.js";
+import { deriveSessionWakePlan, isActionableIssueSessionEventType } from "../issue-session-events.js";
 import { isoNow } from "./shared.js";
 export class IssueSessionStore {
     connection;
@@ -90,13 +90,8 @@ export class IssueSessionStore {
     `).run(isoNow(), projectId, linearIssueId);
     }
     hasPendingIssueSessionEvents(projectId, linearIssueId) {
-        const row = this.connection.prepare(`
-      SELECT 1
-      FROM issue_session_events
-      WHERE project_id = ? AND linear_issue_id = ? AND processed_at IS NULL
-      LIMIT 1
-    `).get(projectId, linearIssueId);
-        return row !== undefined;
+        return this.listIssueSessionEvents(projectId, linearIssueId, { pendingOnly: true })
+            .some((event) => isActionableIssueSessionEventType(event.eventType));
     }
     peekIssueSessionWake(projectId, linearIssueId) {
         const issue = this.issues.getIssue(projectId, linearIssueId);

package/dist/delegation-audit.js

@@ -0,0 +1,39 @@
+export function appendDelegationObservedEvent(db, params) {
+    db.issueSessions.appendIssueSessionEventRespectingActiveLease(params.projectId, params.linearIssueId, {
+        projectId: params.projectId,
+        linearIssueId: params.linearIssueId,
+        eventType: "delegation_observed",
+        eventJson: JSON.stringify(params.payload),
+    });
+}
+export function appendRunReleasedAuthorityEvent(db, params) {
+    db.issueSessions.appendIssueSessionEventRespectingActiveLease(params.projectId, params.linearIssueId, {
+        projectId: params.projectId,
+        linearIssueId: params.linearIssueId,
+        eventType: "run_released_authority",
+        eventJson: JSON.stringify(params.payload),
+    });
+}
+export function parseDelegationObservedPayload(event) {
+    if (event.eventType !== "delegation_observed" || !event.eventJson) {
+        return undefined;
+    }
+    return parseObject(event.eventJson);
+}
+export function parseRunReleasedAuthorityPayload(event) {
+    if (event.eventType !== "run_released_authority" || !event.eventJson) {
+        return undefined;
+    }
+    return parseObject(event.eventJson);
+}
+function parseObject(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/issue-overview-query.js

@@ -88,7 +88,7 @@ export class IssueOverviewQuery {
         const runCount = runs.length;
         const liveThread = await this.readLiveThread(activeRun);
         const failureContext = parseGitHubFailureContext(issueRecord?.lastGitHubFailureContextJson);
-        const waitingReason = session.waitingReason ?? derivePatchRelayWaitingReason({
+        const derivedWaitingReason = derivePatchRelayWaitingReason({
             delegatedToPatchRelay: issueRecord?.delegatedToPatchRelay,
             ...(activeRun ? { activeRunType: activeRun.runType } : {}),
             blockedByKeys,
@@ -102,6 +102,7 @@ export class IssueOverviewQuery {
             lastBlockingReviewHeadSha: issueRecord?.lastBlockingReviewHeadSha,
             latestFailureCheckName: issueRecord?.lastGitHubFailureCheckName,
         });
+        const waitingReason = derivedWaitingReason ?? session.waitingReason;
         const issue = {
             id: issueRecord?.id ?? session.id,
             projectId: session.projectId,

package/dist/issue-session-events.js

@@ -7,14 +7,19 @@ const TERMINAL_SESSION_EVENTS = new Set([
     "pr_closed",
     "pr_merged",
 ]);
+const NON_ACTIONABLE_SESSION_EVENTS = new Set([
+    "delegation_observed",
+    "run_released_authority",
+]);
 const RUN_TYPES = new Set(["implementation", "review_fix", "branch_upkeep", "ci_repair", "queue_repair"]);
 function parseRunType(value) {
     return typeof value === "string" && RUN_TYPES.has(value) ? value : undefined;
 }
 export function deriveSessionWakePlan(issue, events) {
-    if (events.length === 0)
+    const actionableEvents = events.filter((event) => !NON_ACTIONABLE_SESSION_EVENTS.has(event.eventType));
+    if (actionableEvents.length === 0)
         return undefined;
-    if (events.some((event) => TERMINAL_SESSION_EVENTS.has(event.eventType))) {
+    if (actionableEvents.some((event) => TERMINAL_SESSION_EVENTS.has(event.eventType))) {
         return undefined;
     }
     const context = {};
@@ -22,7 +27,7 @@ export function deriveSessionWakePlan(issue, events) {
     let wakeReason;
     let runType;
     let resumeThread = false;
-    for (const event of events) {
+    for (const event of actionableEvents) {
         const payload = parseEventJson(event.eventJson);
         switch (event.eventType) {
             case "merge_steward_incident":
@@ -128,6 +133,9 @@ export function deriveSessionWakePlan(issue, events) {
     }
     return { runType, wakeReason, resumeThread, context };
 }
+export function isActionableIssueSessionEventType(eventType) {
+    return !NON_ACTIONABLE_SESSION_EVENTS.has(eventType);
+}
 export function extractLatestAssistantSummary(run) {
     if (!run)
         return undefined;

package/dist/merged-linear-completion-reconciler.js

@@ -2,24 +2,47 @@ import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
 import { resolvePreferredCompletedLinearState } from "./linear-workflow.js";
 import { isCompletedLinearState } from "./pr-state.js";
 import { hasTrustedNoPrCompletion } from "./trusted-no-pr-completion.js";
+const COMPLETION_RECONCILE_WINDOW_MS = 60 * 60 * 1000;
+const COMPLETION_RECONCILE_SUCCESS_BACKOFF_MS = 60 * 60 * 1000;
+const COMPLETION_RECONCILE_FAILURE_BACKOFF_MS = 5 * 60 * 1000;
+const COMPLETION_RECONCILE_RATE_LIMIT_BACKOFF_MS = 30 * 60 * 1000;
+const COMPLETION_RECONCILE_MAX_ISSUES_PER_PASS = 10;
 export class MergedLinearCompletionReconciler {
     db;
     linearProvider;
     logger;
+    retryAfterByIssueKey = new Map();
+    globalRetryAfter;
     constructor(db, linearProvider, logger) {
         this.db = db;
         this.linearProvider = linearProvider;
         this.logger = logger;
     }
     async reconcile() {
-        for (const issue of this.db.issues.listIssues()) {
-            if (issue.factoryState !== "done" && issue.prState !== "merged") {
+        const now = Date.now();
+        if (this.globalRetryAfter !== undefined) {
+            if (this.globalRetryAfter > now) {
+                return;
+            }
+            this.globalRetryAfter = undefined;
+        }
+        const candidates = this.db.issues.listIssues()
+            .filter((issue) => this.isRecentCompletionCandidate(issue, now))
+            .sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt));
+        this.pruneRetryBackoff(candidates, now);
+        let attemptedIssues = 0;
+        for (const issue of candidates) {
+            if (attemptedIssues >= COMPLETION_RECONCILE_MAX_ISSUES_PER_PASS) {
+                break;
+            }
+            if (!this.shouldAttemptIssue(issue, now)) {
                 continue;
             }
             const linear = await this.linearProvider.forProject(issue.projectId).catch(() => undefined);
             if (!linear) {
                 continue;
             }
+            attemptedIssues += 1;
             try {
                 const liveIssue = await linear.getIssue(issue.linearIssueId);
                 this.db.issues.replaceIssueDependencies({
@@ -37,6 +60,7 @@ export class MergedLinearCompletionReconciler {
                 const trustedNoPrDone = hasTrustedNoPrCompletion(issue, latestRun);
                 if (issue.prState === "merged" || trustedNoPrDone) {
                     await this.reconcileCompletedLinearState(issue, liveIssue, linear);
+                    this.settleIssue(issue, now);
                     continue;
                 }
                 if (issue.factoryState === "done" && !isCompletedLinearState(liveIssue.stateType, liveIssue.stateName)) {
@@ -45,9 +69,15 @@ export class MergedLinearCompletionReconciler {
                 else {
                     this.refreshCachedLinearState(issue, liveIssue);
                 }
+                this.settleIssue(issue, now);
             }
             catch (error) {
+                this.deferIssue(issue, error, now);
                 this.logger.warn({ issueKey: issue.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to reconcile merged or stale completed issue state");
+                if (isRateLimitedError(error)) {
+                    this.globalRetryAfter = now + COMPLETION_RECONCILE_RATE_LIMIT_BACKOFF_MS;
+                    break;
+                }
             }
         }
     }
@@ -92,6 +122,9 @@ export class MergedLinearCompletionReconciler {
         }, "Reopened stale local done state from live Linear workflow");
     }
     refreshCachedLinearState(issue, liveIssue) {
+        if (issue.currentLinearState === liveIssue.stateName && issue.currentLinearStateType === liveIssue.stateType) {
+            return;
+        }
         this.db.issues.upsertIssue({
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
@@ -99,6 +132,55 @@ export class MergedLinearCompletionReconciler {
             ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
         });
     }
+    isRecentCompletionCandidate(issue, now) {
+        if (issue.factoryState !== "done" && issue.prState !== "merged") {
+            return false;
+        }
+        const updatedAt = Date.parse(issue.updatedAt);
+        return Number.isFinite(updatedAt) && now - updatedAt <= COMPLETION_RECONCILE_WINDOW_MS;
+    }
+    shouldAttemptIssue(issue, now) {
+        const retry = this.retryAfterByIssueKey.get(this.issueKey(issue));
+        if (!retry) {
+            return true;
+        }
+        if (retry.updatedAt !== issue.updatedAt) {
+            this.retryAfterByIssueKey.delete(this.issueKey(issue));
+            return true;
+        }
+        return retry.retryAfter <= now;
+    }
+    settleIssue(issue, now) {
+        this.retryAfterByIssueKey.set(this.issueKey(issue), {
+            retryAfter: now + COMPLETION_RECONCILE_SUCCESS_BACKOFF_MS,
+            updatedAt: issue.updatedAt,
+        });
+    }
+    deferIssue(issue, error, now) {
+        const message = error instanceof Error ? error.message : String(error);
+        const backoffMs = /ratelimit|rate limit/i.test(message)
+            ? COMPLETION_RECONCILE_RATE_LIMIT_BACKOFF_MS
+            : COMPLETION_RECONCILE_FAILURE_BACKOFF_MS;
+        this.retryAfterByIssueKey.set(this.issueKey(issue), {
+            retryAfter: now + backoffMs,
+            updatedAt: issue.updatedAt,
+        });
+    }
+    pruneRetryBackoff(candidates, now) {
+        const candidateKeys = new Set(candidates.map((issue) => this.issueKey(issue)));
+        for (const [key, retry] of this.retryAfterByIssueKey.entries()) {
+            if (!candidateKeys.has(key) || retry.retryAfter <= now) {
+                this.retryAfterByIssueKey.delete(key);
+            }
+        }
+    }
+    issueKey(issue) {
+        return `${issue.projectId}::${issue.linearIssueId}`;
+    }
+}
+function isRateLimitedError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /ratelimit|rate limit/i.test(message);
 }
 function resolveOpenWorkflowState(issue) {
     const reactiveIntent = deriveIssueSessionReactiveIntent({

package/dist/run-reconciler.js

@@ -1,3 +1,4 @@
+import { appendDelegationObservedEvent, appendRunReleasedAuthorityEvent } from "./delegation-audit.js";
 import { TERMINAL_STATES } from "./factory-state.js";
 import { resolveAuthoritativeLinearStopState } from "./linear-workflow.js";
 import { buildRunFailureActivity } from "./linear-session-reporting.js";
@@ -31,39 +32,40 @@ export class RunReconciler {
     async reconcile(params) {
         const { run, issue, recoveryLease } = params;
         const acquiredRecoveryLease = recoveryLease === true;
-        if (!issue.delegatedToPatchRelay) {
-            this.withHeldLease(run.projectId, run.linearIssueId, () => {
-                this.db.runs.finishRun(run.id, { status: "released", failureReason: "Issue was un-delegated during active run" });
-                this.db.issues.upsertIssue({ projectId: run.projectId, linearIssueId: run.linearIssueId, activeRunId: null, factoryState: issue.factoryState });
-            });
-            const pausedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
-            void this.linearSync.syncSession(pausedIssue, { activeRunType: run.runType });
-            this.releaseLease(run.projectId, run.linearIssueId);
-            return;
+        let effectiveIssue = issue;
+        if (!effectiveIssue.delegatedToPatchRelay) {
+            const authority = await this.confirmDelegationAuthorityBeforeRelease(run, effectiveIssue);
+            effectiveIssue = authority.issue;
+            if (authority.released) {
+                const pausedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? effectiveIssue;
+                void this.linearSync.syncSession(pausedIssue, { activeRunType: run.runType });
+                this.releaseLease(run.projectId, run.linearIssueId);
+                return;
+            }
         }
-        if (TERMINAL_STATES.has(issue.factoryState)) {
+        if (TERMINAL_STATES.has(effectiveIssue.factoryState)) {
             this.withHeldLease(run.projectId, run.linearIssueId, () => {
                 this.db.runs.finishRun(run.id, { status: "released", failureReason: "Issue reached terminal state during active run" });
                 this.db.issues.upsertIssue({ projectId: run.projectId, linearIssueId: run.linearIssueId, activeRunId: null });
             });
-            this.logger.info({ issueKey: issue.issueKey, runId: run.id, factoryState: issue.factoryState }, "Reconciliation: released run on terminal issue");
-            const releasedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
+            this.logger.info({ issueKey: effectiveIssue.issueKey, runId: run.id, factoryState: effectiveIssue.factoryState }, "Reconciliation: released run on terminal issue");
+            const releasedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? effectiveIssue;
             void this.linearSync.syncSession(releasedIssue, { activeRunType: run.runType });
             this.releaseLease(run.projectId, run.linearIssueId);
             return;
         }
         if (!run.threadId) {
             if (recoveryLease === "owned") {
-                this.logger.debug({ issueKey: issue.issueKey, runId: run.id, runType: run.runType }, "Skipping zombie reconciliation for locally-owned launch that has not created a thread yet");
+                this.logger.debug({ issueKey: effectiveIssue.issueKey, runId: run.id, runType: run.runType }, "Skipping zombie reconciliation for locally-owned launch that has not created a thread yet");
                 return;
             }
-            this.logger.warn({ issueKey: issue.issueKey, runId: run.id, runType: run.runType }, "Zombie run detected (no thread)");
+            this.logger.warn({ issueKey: effectiveIssue.issueKey, runId: run.id, runType: run.runType }, "Zombie run detected (no thread)");
             this.withHeldLease(run.projectId, run.linearIssueId, () => {
                 this.db.runs.finishRun(run.id, { status: "failed", failureReason: "Zombie: never started (no thread after restart)" });
                 this.db.issues.upsertIssue({ projectId: run.projectId, linearIssueId: run.linearIssueId, activeRunId: null });
             });
-            this.recoverOrEscalate(issue, run.runType, "zombie");
-            const recoveredIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
+            this.recoverOrEscalate(effectiveIssue, run.runType, "zombie");
+            const recoveredIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? effectiveIssue;
             void this.linearSync.emitActivity(recoveredIssue, buildRunFailureActivity(run.runType, "The Codex turn never started before PatchRelay restarted."));
             void this.linearSync.syncSession(recoveredIssue, { activeRunType: run.runType });
             this.releaseLease(run.projectId, run.linearIssueId);
@@ -74,13 +76,13 @@ export class RunReconciler {
             thread = await this.readThreadWithRetry(run.threadId);
         }
         catch {
-            this.logger.warn({ issueKey: issue.issueKey, runId: run.id, runType: run.runType, threadId: run.threadId }, "Stale thread during reconciliation");
+            this.logger.warn({ issueKey: effectiveIssue.issueKey, runId: run.id, runType: run.runType, threadId: run.threadId }, "Stale thread during reconciliation");
             this.withHeldLease(run.projectId, run.linearIssueId, () => {
                 this.db.runs.finishRun(run.id, { status: "failed", failureReason: "Stale thread after restart" });
                 this.db.issues.upsertIssue({ projectId: run.projectId, linearIssueId: run.linearIssueId, activeRunId: null });
             });
-            this.recoverOrEscalate(issue, run.runType, "stale_thread");
-            const recoveredIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
+            this.recoverOrEscalate(effectiveIssue, run.runType, "stale_thread");
+            const recoveredIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? effectiveIssue;
             void this.linearSync.emitActivity(recoveredIssue, buildRunFailureActivity(run.runType, "PatchRelay lost the active Codex thread after restart and needs to recover."));
             void this.linearSync.syncSession(recoveredIssue, { activeRunType: run.runType });
             this.releaseLease(run.projectId, run.linearIssueId);
@@ -111,7 +113,7 @@ export class RunReconciler {
                         status: "reconciled",
                         summary: `Linear state ${stopState.stateName} -> done`,
                     });
-                    const doneIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
+                    const doneIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? effectiveIssue;
                     void this.linearSync.syncSession(doneIssue, { activeRunType: run.runType });
                     this.releaseLease(run.projectId, run.linearIssueId);
                     return;
@@ -120,14 +122,14 @@ export class RunReconciler {
         }
         const latestTurn = getThreadTurns(thread).at(-1);
         if (latestTurn?.status === "interrupted") {
-            await this.interruptedRunRecovery.handle(run, issue);
+            await this.interruptedRunRecovery.handle(run, effectiveIssue);
             return;
         }
         if (latestTurn?.status === "completed") {
             await this.runFinalizer.finalizeCompletedRun({
                 source: "reconciliation",
                 run,
-                issue,
+                issue: effectiveIssue,
                 thread,
                 threadId: run.threadId,
                 ...(latestTurn.id ? { completedTurnId: latestTurn.id } : {}),
@@ -139,4 +141,111 @@ export class RunReconciler {
             this.releaseLease(run.projectId, run.linearIssueId);
         }
     }
+    async confirmDelegationAuthorityBeforeRelease(run, issue) {
+        const installation = this.db.linearInstallations.getLinearInstallationForProject(run.projectId);
+        const linear = await this.linearProvider.forProject(run.projectId).catch(() => undefined);
+        if (!installation?.actorId || !linear) {
+            appendDelegationObservedEvent(this.db, {
+                projectId: run.projectId,
+                linearIssueId: run.linearIssueId,
+                payload: {
+                    source: "run_reconciler",
+                    ...(installation?.actorId ? { actorId: installation.actorId } : {}),
+                    previousDelegatedToPatchRelay: issue.delegatedToPatchRelay,
+                    observedDelegatedToPatchRelay: issue.delegatedToPatchRelay,
+                    appliedDelegatedToPatchRelay: issue.delegatedToPatchRelay,
+                    hydration: "live_linear_failed",
+                    activeRunId: run.id,
+                    decision: "none",
+                    reason: "live_linear_unavailable_before_undelegation_release",
+                },
+            });
+            return { issue, released: false };
+        }
+        const linearIssue = await linear.getIssue(run.linearIssueId).catch(() => undefined);
+        if (!linearIssue) {
+            appendDelegationObservedEvent(this.db, {
+                projectId: run.projectId,
+                linearIssueId: run.linearIssueId,
+                payload: {
+                    source: "run_reconciler",
+                    actorId: installation.actorId,
+                    previousDelegatedToPatchRelay: issue.delegatedToPatchRelay,
+                    observedDelegatedToPatchRelay: issue.delegatedToPatchRelay,
+                    appliedDelegatedToPatchRelay: issue.delegatedToPatchRelay,
+                    hydration: "live_linear_failed",
+                    activeRunId: run.id,
+                    decision: "none",
+                    reason: "live_linear_refresh_failed_before_undelegation_release",
+                },
+            });
+            return { issue, released: false };
+        }
+        const delegated = linearIssue.delegateId === installation.actorId;
+        appendDelegationObservedEvent(this.db, {
+            projectId: run.projectId,
+            linearIssueId: run.linearIssueId,
+            payload: {
+                source: "run_reconciler",
+                actorId: installation.actorId,
+                ...(linearIssue.delegateId ? { observedDelegateId: linearIssue.delegateId } : {}),
+                previousDelegatedToPatchRelay: issue.delegatedToPatchRelay,
+                observedDelegatedToPatchRelay: delegated,
+                appliedDelegatedToPatchRelay: delegated,
+                hydration: "live_linear",
+                activeRunId: run.id,
+                decision: delegated ? "resume_issue" : "release_run",
+                reason: delegated
+                    ? "live_linear_confirmed_issue_is_still_delegated"
+                    : "live_linear_confirmed_issue_is_no_longer_delegated",
+            },
+        });
+        if (delegated) {
+            const repairedIssue = this.withHeldLease(run.projectId, run.linearIssueId, () => this.db.issues.upsertIssue({
+                projectId: run.projectId,
+                linearIssueId: run.linearIssueId,
+                delegatedToPatchRelay: true,
+                ...(linearIssue.identifier ? { issueKey: linearIssue.identifier } : {}),
+                ...(linearIssue.title ? { title: linearIssue.title } : {}),
+                ...(linearIssue.description ? { description: linearIssue.description } : {}),
+                ...(linearIssue.url ? { url: linearIssue.url } : {}),
+                ...(linearIssue.priority != null ? { priority: linearIssue.priority } : {}),
+                ...(linearIssue.estimate != null ? { estimate: linearIssue.estimate } : {}),
+                ...(linearIssue.stateName ? { currentLinearState: linearIssue.stateName } : {}),
+                ...(linearIssue.stateType ? { currentLinearStateType: linearIssue.stateType } : {}),
+            })) ?? issue;
+            return { issue: repairedIssue, released: false };
+        }
+        appendRunReleasedAuthorityEvent(this.db, {
+            projectId: run.projectId,
+            linearIssueId: run.linearIssueId,
+            payload: {
+                runId: run.id,
+                runType: run.runType,
+                localDelegatedToPatchRelay: issue.delegatedToPatchRelay,
+                liveDelegatedToPatchRelay: delegated,
+                source: "run_reconciler",
+                reason: "Issue was un-delegated during active run",
+            },
+        });
+        this.withHeldLease(run.projectId, run.linearIssueId, () => {
+            this.db.runs.finishRun(run.id, { status: "released", failureReason: "Issue was un-delegated during active run" });
+            this.db.issues.upsertIssue({
+                projectId: run.projectId,
+                linearIssueId: run.linearIssueId,
+                activeRunId: null,
+                factoryState: issue.factoryState,
+                delegatedToPatchRelay: false,
+                ...(linearIssue.identifier ? { issueKey: linearIssue.identifier } : {}),
+                ...(linearIssue.title ? { title: linearIssue.title } : {}),
+                ...(linearIssue.description ? { description: linearIssue.description } : {}),
+                ...(linearIssue.url ? { url: linearIssue.url } : {}),
+                ...(linearIssue.priority != null ? { priority: linearIssue.priority } : {}),
+                ...(linearIssue.estimate != null ? { estimate: linearIssue.estimate } : {}),
+                ...(linearIssue.stateName ? { currentLinearState: linearIssue.stateName } : {}),
+                ...(linearIssue.stateType ? { currentLinearStateType: linearIssue.stateType } : {}),
+            });
+        });
+        return { issue, released: true };
+    }
 }

package/dist/service-runtime.js

@@ -30,13 +30,12 @@ export class ServiceRuntime {
     async start() {
         try {
             await this.codex.start();
-            await this.runReconciler.reconcileActiveRuns();
             for (const issue of this.readyIssueSource.listIssuesReadyForExecution()) {
                 this.enqueueIssue(issue.projectId, issue.linearIssueId);
             }
             this.ready = true;
             this.startupError = undefined;
-            this.scheduleBackgroundReconcile();
+            void this.runBackgroundReconcile();
         }
         catch (error) {
             this.ready = false;

package/dist/service-startup-recovery.js

@@ -1,3 +1,4 @@
+import { appendDelegationObservedEvent } from "./delegation-audit.js";
 import { isResumablePausedLocalWork } from "./paused-issue-state.js";
 export class ServiceStartupRecovery {
     db;
@@ -65,6 +66,24 @@ export class ServiceStartupRecovery {
                 })),
             });
             const delegated = liveIssue.delegateId === installation.actorId;
+            if (issue.delegatedToPatchRelay !== delegated) {
+                appendDelegationObservedEvent(this.db, {
+                    projectId: issue.projectId,
+                    linearIssueId: issue.linearIssueId,
+                    payload: {
+                        source: "startup_recovery",
+                        actorId: installation.actorId,
+                        ...(liveIssue.delegateId ? { observedDelegateId: liveIssue.delegateId } : {}),
+                        previousDelegatedToPatchRelay: issue.delegatedToPatchRelay,
+                        observedDelegatedToPatchRelay: delegated,
+                        appliedDelegatedToPatchRelay: delegated,
+                        hydration: "live_linear",
+                        ...(issue.activeRunId !== undefined ? { activeRunId: issue.activeRunId } : {}),
+                        decision: delegated ? "resume_issue" : "none",
+                        reason: "startup_recovery_refreshed_linear_delegation",
+                    },
+                });
+            }
             const unresolvedBlockers = this.db.issues.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
             const latestRun = this.db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
             const shouldRecoverPausedLocalWork = delegated

package/dist/service.js

@@ -106,7 +106,10 @@ export class PatchRelayService {
             }
         }
         await this.runtime.start();
-        await this.startupRecovery.recoverDelegatedIssueStateFromLinear();
+        void this.startupRecovery.recoverDelegatedIssueStateFromLinear().catch((error) => {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger.warn({ error: msg }, "Background delegated issue recovery failed");
+        });
         void this.startupRecovery.syncKnownAgentSessions().catch((error) => {
             const msg = error instanceof Error ? error.message : String(error);
             this.logger.warn({ error: msg }, "Background agent session sync failed");

package/dist/waiting-reason.js

@@ -10,7 +10,7 @@ export const PATCHRELAY_WAITING_REASONS = {
     waitingForReviewOnNewHead: "Waiting on review of a newer pushed head",
     sameHeadStillBlocked: "Requested changes still block the current head",
     waitingForMergeStewardRepair: "Waiting to repair a merge-steward incident",
-    waitingForDownstreamAutomation: "Waiting on downstream review/merge automation",
+    waitingForDownstreamAutomation: "PatchRelay work is done; waiting on downstream review/merge automation",
     workComplete: "PatchRelay work is complete",
     waitingForOperatorIntervention: "Waiting on operator intervention",
     waitingForExternalReview: "Waiting on external review",

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

@@ -1,5 +1,6 @@
 import { triggerEventAllowed } from "../project-resolution.js";
 import { resolveAwaitingInputReason } from "../awaiting-input-reason.js";
+import { appendDelegationObservedEvent } from "../delegation-audit.js";
 import { decideActiveRunRelease, decideAgentSession, decideRunIntent, decideUnDelegation, isTerminalDelegationState, mergeIssueMetadata, resolveReDelegationResume, } from "./decision-helpers.js";
 import { buildOperatorRetryEvent } from "../operator-retry-event.js";
 export class DesiredStageRecorder {
@@ -25,8 +26,20 @@ export class DesiredStageRecorder {
         if (!existingIssue && !this.isDelegatedToPatchRelay(params.project, normalizedIssue) && !incomingAgentSessionId) {
             return { issue: undefined, wakeRunType: undefined, delegated: false };
         }
-        const hydratedIssue = await this.syncIssueDependencies(params.project.id, normalizedIssue);
-        const delegated = this.isDelegatedToPatchRelay(params.project, hydratedIssue);
+        const syncResult = await this.syncIssueDependencies(params.project.id, normalizedIssue);
+        const hydratedIssue = syncResult.issue;
+        const delegation = this.resolveDelegationTruth({
+            project: params.project,
+            normalizedIssue,
+            hydratedIssue,
+            existingIssue,
+            triggerEvent: params.normalized.triggerEvent,
+            webhookId: params.normalized.webhookId,
+            actorId: params.normalized.actor?.id,
+            hydration: syncResult.hydration,
+            activeRunId: activeRun?.id,
+        });
+        const delegated = delegation.delegated;
         const unresolvedBlockers = this.db.issues.countUnresolvedBlockers(params.project.id, normalizedIssue.id);
         const terminal = isTerminalDelegationState(existingIssue, hydratedIssue);
         const openPrExists = existingIssue?.prNumber !== undefined
@@ -200,16 +213,56 @@ export class DesiredStageRecorder {
             return false;
         return issue.delegateId === installation.actorId;
     }
+    resolveDelegationTruth(params) {
+        const previousDelegated = params.existingIssue?.delegatedToPatchRelay;
+        const observedDelegated = this.isDelegatedToPatchRelay(params.project, params.hydratedIssue);
+        const explicitDelegateSignal = params.triggerEvent === "delegateChanged";
+        const hasObservedDelegate = params.hydratedIssue.delegateId !== undefined;
+        let delegated = observedDelegated;
+        let reason = hasObservedDelegate
+            ? "delegate_id_present"
+            : `missing_delegate_identity_after_${params.hydration}`;
+        if (!hasObservedDelegate && !explicitDelegateSignal && previousDelegated !== undefined) {
+            delegated = previousDelegated;
+            reason = `preserved_previous_delegation_after_${params.hydration}`;
+        }
+        if (previousDelegated !== delegated
+            || params.hydration === "live_linear_failed"
+            || (!hasObservedDelegate && previousDelegated !== undefined)) {
+            appendDelegationObservedEvent(this.db, {
+                projectId: params.project.id,
+                linearIssueId: params.normalizedIssue.id,
+                payload: {
+                    source: "linear_webhook",
+                    webhookId: params.webhookId,
+                    triggerEvent: params.triggerEvent,
+                    ...(params.actorId ? { actorId: params.actorId } : {}),
+                    ...(params.hydratedIssue.delegateId ? { observedDelegateId: params.hydratedIssue.delegateId } : {}),
+                    ...(previousDelegated !== undefined ? { previousDelegatedToPatchRelay: previousDelegated } : {}),
+                    observedDelegatedToPatchRelay: observedDelegated,
+                    appliedDelegatedToPatchRelay: delegated,
+                    hydration: params.hydration,
+                    ...(params.activeRunId !== undefined ? { activeRunId: params.activeRunId } : {}),
+                    decision: "none",
+                    reason,
+                },
+            });
+        }
+        return { delegated };
+    }
     async syncIssueDependencies(projectId, issue) {
         let source = issue;
+        let hydration = "webhook_only";
         if (!source.relationsKnown) {
             const linear = await this.linearProvider.forProject(projectId);
             if (linear) {
                 try {
                     source = mergeIssueMetadata(source, await linear.getIssue(issue.id));
+                    hydration = "live_linear";
                 }
                 catch {
                     // Preserve existing dependency rows when webhook relation data is incomplete.
+                    hydration = "live_linear_failed";
                 }
             }
         }
@@ -226,6 +279,6 @@ export class DesiredStageRecorder {
                 })),
             });
         }
-        return source;
+        return { issue: source, hydration };
     }
 }

package/package.json

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