patchrelay 0.39.0 → 0.40.1

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.39.0",
-  "commit": "80d285a7e9bd",
-  "builtAt": "2026-04-11T20:04:29.313Z"
+  "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, 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,10 @@ 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":
             return await handleRetryCommand(nested);
         case "close":
@@ -116,6 +120,30 @@ export async function handleOpenCommand(params) {
     const openCommand = buildOpenCommand(params.config, result.worktreePath, result.resumeThreadId);
     return await params.runInteractive(openCommand.command, openCommand.args);
 }
+export async function handleTranscriptSourceCommand(params) {
+    const issueKey = params.commandArgs[0];
+    if (!issueKey) {
+        throw new Error("transcript-source requires <issueKey>.");
+    }
+    const runFlag = params.parsed.flags.get("run");
+    let runId;
+    if (typeof runFlag === "string") {
+        const parsedRunId = Number(runFlag);
+        if (!Number.isSafeInteger(parsedRunId) || parsedRunId <= 0) {
+            throw new Error("--run must be a positive integer.");
+        }
+        runId = parsedRunId;
+    }
+    const result = params.data.transcriptSource(issueKey, runId);
+    if (!result) {
+        throw new Error(`Issue not found: ${issueKey}`);
+    }
+    if (runId !== undefined && result.runId !== runId) {
+        throw new Error(`Run not found for ${issueKey}: ${runId}`);
+    }
+    writeOutput(params.stdout, params.json ? formatJson(result) : formatTranscriptSource(result));
+    return 0;
+}
 export async function handleSessionsCommand(params) {
     const issueKey = params.commandArgs[0];
     if (!issueKey) {
@@ -130,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

@@ -1,11 +1,13 @@
 import { existsSync } from "node:fs";
 import pino from "pino";
 import { CodexAppServerClient } from "../codex-app-server.js";
+import { resolveCodexSessionSource } from "../codex-session-source.js";
 import { extractCompletionCheck } from "../completion-check.js";
 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)
@@ -272,6 +274,69 @@ 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)
+            return undefined;
+        const dbIssue = this.db.issues.getIssueByKey(issueKey);
+        const runs = this.db.runs.listRunsForIssue(issue.projectId, issue.linearIssueId);
+        const selectedRun = runId !== undefined
+            ? runs.find((run) => run.id === runId)
+            : runs.slice().reverse().find((run) => run.threadId);
+        const threadId = selectedRun?.threadId ?? dbIssue.threadId;
+        return {
+            issue,
+            ...(selectedRun ? { runId: selectedRun.id, runType: selectedRun.runType, runStatus: selectedRun.status } : {}),
+            ...(threadId ? { threadId } : {}),
+            ...(selectedRun?.turnId ? { turnId: selectedRun.turnId } : {}),
+            ...(dbIssue.worktreePath ? { worktreePath: dbIssue.worktreePath } : {}),
+            ...(threadId ? { sessionSource: resolveCodexSessionSource(threadId) } : {}),
+        };
+    }
     sessions(issueKey) {
         const issue = this.db.getTrackedIssueByKey(issueKey);
         if (!issue)
@@ -284,6 +349,7 @@ export class CliDataAccess extends CliOperatorApiClient {
             .map((run) => {
             const summary = summarizeRun(run);
             const eventCount = this.db.runs.listThreadEvents(run.id).length;
+            const sessionSource = run.threadId ? resolveCodexSessionSource(run.threadId) : undefined;
             return {
                 runId: run.id,
                 runType: run.runType,
@@ -293,6 +359,7 @@ export class CliDataAccess extends CliOperatorApiClient {
                 ...(run.parentThreadId ? { parentThreadId: run.parentThreadId } : {}),
                 ...(summary ? { summary } : {}),
                 ...(run.failureReason ? { failureReason: run.failureReason } : {}),
+                ...(sessionSource ? { sessionSource } : {}),
                 eventCount,
                 eventCountAvailable: this.config.runner.codex.persistExtendedHistory || eventCount > 0,
                 startedAt: run.startedAt,

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),
@@ -97,6 +117,29 @@ export function formatClose(result) {
 function formatTimestampRange(startedAt, endedAt) {
     return endedAt ? `${startedAt} -> ${endedAt}` : `${startedAt} -> running`;
 }
+function formatSessionSource(sessionSource) {
+    if (!sessionSource)
+        return undefined;
+    if (sessionSource.exists)
+        return sessionSource.path;
+    return sessionSource.error ?? "not found";
+}
+export function formatTranscriptSource(result) {
+    const lines = [
+        value("Issue", result.issue.issueKey ?? result.issue.linearIssueId),
+        value("Worktree", result.worktreePath),
+        value("Run", result.runId !== undefined
+            ? `#${result.runId}${result.runType ? ` ${result.runType}` : ""}${result.runStatus ? ` (${result.runStatus})` : ""}`
+            : undefined),
+        value("Thread", result.threadId),
+        value("Turn", result.turnId),
+        value("Session source", formatSessionSource(result.sessionSource)),
+        result.sessionSource?.startedAt ? value("Started", result.sessionSource.startedAt) : undefined,
+        result.sessionSource?.originator ? value("Originator", result.sessionSource.originator) : undefined,
+        result.sessionSource?.cwd ? value("Working directory", result.sessionSource.cwd) : undefined,
+    ].filter(Boolean);
+    return `${lines.join("\n")}\n`;
+}
 export function formatSessionHistory(result, buildOpenForThread) {
     const lines = [
         `${result.issue.issueKey ?? result.issue.linearIssueId}${result.issue.currentLinearState ? `  ${result.issue.currentLinearState}` : ""}`,
@@ -134,6 +177,18 @@ export function formatSessionHistory(result, buildOpenForThread) {
         else if (session.failureReason) {
             lines.push(value("Failure", truncateLine(session.failureReason)));
         }
+        if (session.sessionSource) {
+            lines.push(value("Session source", formatSessionSource(session.sessionSource)));
+            if (session.sessionSource.startedAt) {
+                lines.push(value("Started", session.sessionSource.startedAt));
+            }
+            if (session.sessionSource.originator) {
+                lines.push(value("Originator", session.sessionSource.originator));
+            }
+            if (session.sessionSource.cwd) {
+                lines.push(value("Working directory", session.sessionSource.cwd));
+            }
+        }
         if (session.threadId && result.worktreePath && buildOpenForThread) {
             const command = buildOpenForThread(session.threadId);
             lines.push(value("Open", formatCommand(command.command, command.args)));

package/dist/cli/help.js

@@ -34,9 +34,11 @@ 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",
+        "  issue transcript-source <issueKey> [--run <id>] [--json]  Show the raw Codex session file for one issue run",
         "  issue close <issueKey> [--failed] [--reason <text>] [--json]",
         "                                                          Force-close one issue and release any active run",
         "  service status [--json]                                 Show systemd state and local health",
@@ -145,11 +147,13 @@ 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",
         "  open <issueKey>                 Open Codex in the issue worktree",
         "  sessions <issueKey>             Show recorded Codex app-server sessions",
+        "  transcript-source <issueKey>    Show the raw Codex session file for one issue run",
         "  retry <issueKey>                Requeue a run",
         "  close <issueKey>                Force-close a stuck issue",
         "",
@@ -158,6 +162,7 @@ export function issueHelpText() {
         "  patchrelay issue show USE-54",
         "  patchrelay issue watch USE-54",
         "  patchrelay issue sessions USE-54",
+        "  patchrelay issue transcript-source USE-54",
         "  patchrelay close USE-54 --reason \"already handled manually\"",
     ].join("\n");
 }

package/dist/cli/index.js

@@ -64,6 +64,9 @@ function validateFlags(command, commandArgs, parsed) {
                 case "sessions":
                     assertKnownFlags(parsed, "issue", ["json"]);
                     return;
+                case "transcript-source":
+                    assertKnownFlags(parsed, "issue", ["run", "json"]);
+                    return;
                 case "retry":
                     assertKnownFlags(parsed, "issue", ["run-type", "reason", "json"]);
                     return;

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/codex-session-source.js

@@ -0,0 +1,85 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+function resolveCodexHome(explicit) {
+    return explicit
+        ?? process.env.CODEX_HOME
+        ?? path.join(homedir(), ".codex");
+}
+function walkSessionFiles(directory, threadId, matches) {
+    const entries = readdirSync(directory, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            walkSessionFiles(fullPath, threadId, matches);
+            continue;
+        }
+        if (!entry.isFile() || !entry.name.endsWith(".jsonl")) {
+            continue;
+        }
+        if (entry.name.includes(threadId)) {
+            matches.push(fullPath);
+        }
+    }
+}
+function readSessionMeta(filePath) {
+    try {
+        const firstLine = readFileSync(filePath, "utf8").split(/\r?\n/, 1)[0];
+        if (!firstLine) {
+            return { error: "session file is empty" };
+        }
+        const parsed = JSON.parse(firstLine);
+        if (parsed.type !== "session_meta" || !parsed.payload || typeof parsed.payload !== "object" || Array.isArray(parsed.payload)) {
+            return { error: "session file does not start with session_meta" };
+        }
+        return { payload: parsed.payload };
+    }
+    catch (error) {
+        return {
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+export function resolveCodexSessionSource(threadId, options) {
+    const codexHome = resolveCodexHome(options?.codexHome);
+    const sessionsDir = path.join(codexHome, "sessions");
+    if (!existsSync(sessionsDir)) {
+        return {
+            threadId,
+            codexHome,
+            sessionsDir,
+            exists: false,
+            error: `sessions directory not found: ${sessionsDir}`,
+        };
+    }
+    const matches = [];
+    walkSessionFiles(sessionsDir, threadId, matches);
+    matches.sort().reverse();
+    let firstError;
+    for (const candidate of matches) {
+        const { payload, error } = readSessionMeta(candidate);
+        if (payload && payload.id === threadId) {
+            return {
+                threadId,
+                codexHome,
+                sessionsDir,
+                exists: true,
+                path: candidate,
+                ...(typeof payload.id === "string" ? { sessionId: payload.id } : {}),
+                ...(typeof payload.timestamp === "string" ? { startedAt: payload.timestamp } : {}),
+                ...(typeof payload.cwd === "string" ? { cwd: payload.cwd } : {}),
+                ...(typeof payload.originator === "string" ? { originator: payload.originator } : {}),
+            };
+        }
+        if (!firstError && error) {
+            firstError = `${candidate}: ${error}`;
+        }
+    }
+    return {
+        threadId,
+        codexHome,
+        sessionsDir,
+        exists: false,
+        ...(firstError ? { error: firstError } : { error: `session file not found for thread ${threadId}` }),
+    };
+}

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.39.0",
+  "version": "0.40.1",
   "license": "MIT",
   "type": "module",
   "repository": {