patchrelay 0.74.8 → 0.75.1

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.74.8",
-  "commit": "5016ef557bde",
-  "builtAt": "2026-05-29T12:02:10.583Z"
+  "version": "0.75.1",
+  "commit": "3f8fb3c35611",
+  "builtAt": "2026-06-05T20:39:12.061Z"
 }

package/dist/cli/cluster-health/index.js

@@ -1,6 +1,6 @@
 import { hasOpenPr } from "../../pr-state.js";
 import { collectActiveOverlapFindings } from "./active-overlap.js";
-import { evaluateLocalIssueHealth, isResolvedDependency, needsReviewAutomation, } from "./local-issue-health.js";
+import { evaluateLocalIssueHealth, evaluateTerminalIssueHealth, isActiveWorkflowIssue, isTerminalFailureIssue, isResolvedDependency, needsReviewAutomation, } from "./local-issue-health.js";
 import { evaluateGitHubIssueHealth } from "./github-issue-health.js";
 import { collectReviewQuillAttemptOwners, } from "./review-quill-probe.js";
 import { probeOptionalService, probePatchRelayService, } from "./service-probe.js";
@@ -10,7 +10,8 @@ export async function collectClusterHealth(config, db, runCommand) {
     const ciEntries = [];
     const now = Date.now();
     const issues = db.listIssues();
-    const openIssues = issues.filter((issue) => issue.factoryState !== "done");
+    const activeWorkflowIssues = issues.filter((issue) => isActiveWorkflowIssue(issue));
+    const historicalTerminalIssues = issues.filter((issue) => isTerminalFailureIssue(issue));
     const trackedByKey = new Map(issues
         .filter((issue) => issue.issueKey)
         .map((issue) => [issue.issueKey, issue]));
@@ -21,7 +22,7 @@ export async function collectClusterHealth(config, db, runCommand) {
         scope: "service:patchrelay",
         message: patchRelayProbe.message,
     });
-    const snapshots = openIssues.map((issue) => {
+    const snapshots = activeWorkflowIssues.map((issue) => {
         const tracked = db.getTrackedIssue(issue.projectId, issue.linearIssueId);
         const deps = db.issues.listIssueDependencies(issue.projectId, issue.linearIssueId);
         const blockedBy = deps.filter((dep) => !isResolvedDependency(dep));
@@ -99,6 +100,17 @@ export async function collectClusterHealth(config, db, runCommand) {
             });
         }
     }
+    for (const issue of historicalTerminalIssues) {
+        const finding = evaluateTerminalIssueHealth(issue);
+        if (finding) {
+            checks.push({
+                ...finding,
+                ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+                projectId: issue.projectId,
+                ...(issue.prNumber !== undefined ? { prNumber: issue.prNumber } : {}),
+            });
+        }
+    }
     checks.push(...await collectActiveOverlapFindings(snapshots, runCommand));
     for (const snapshot of snapshots) {
         if (!hasOpenPr(snapshot.issue.prNumber, snapshot.issue.prState)) {
@@ -118,18 +130,18 @@ export async function collectClusterHealth(config, db, runCommand) {
         }
     }
     const workflowFailures = checks.filter((check) => check.scope.startsWith("issue:") || check.scope.startsWith("github:"));
-    if (workflowFailures.every((check) => check.status === "pass" || check.status === "warn") && openIssues.length > 0) {
+    if (workflowFailures.every((check) => check.status === "pass" || check.status === "warn") && activeWorkflowIssues.length > 0) {
         checks.push({
             status: "pass",
             scope: "workflow",
-            message: `All ${openIssues.length} non-done issues currently have active work, a tracked blocker, or a downstream owner`,
+            message: `All ${activeWorkflowIssues.length} active workflow issues currently have active work, a tracked blocker, or a downstream owner`,
         });
     }
-    if (openIssues.length === 0) {
+    if (activeWorkflowIssues.length === 0) {
         checks.push({
             status: "pass",
             scope: "workflow",
-            message: "No non-done issues are currently tracked",
+            message: "No active workflow issues are currently tracked",
         });
     }
     if (ciEntries.length > 0) {
@@ -144,8 +156,8 @@ export async function collectClusterHealth(config, db, runCommand) {
     }
     const summary = {
         trackedIssues: issues.length,
-        openIssues: openIssues.length,
-        activeRuns: openIssues.filter((issue) => issue.activeRunId !== undefined).length,
+        openIssues: activeWorkflowIssues.length,
+        activeRuns: activeWorkflowIssues.filter((issue) => issue.activeRunId !== undefined).length,
         blockedIssues: snapshots.filter((snapshot) => snapshot.blockedBy.length > 0).length,
         readyIssues: snapshots.filter((snapshot) => snapshot.readyForExecution).length,
         ciTrackedPrs: ciEntries.length,

package/dist/cli/cluster-health/local-issue-health.js

@@ -13,21 +13,30 @@ export function isResolvedDependency(dep) {
         || state === "cancelled";
 }
 export function needsReviewAutomation(issue) {
-    if (issue.factoryState === "awaiting_queue" || issue.factoryState === "done") {
+    if (issue.factoryState === "awaiting_queue" || !isActiveWorkflowIssue(issue)) {
         return false;
     }
     return hasOpenPr(issue.prNumber, issue.prState);
 }
-export function evaluateLocalIssueHealth(snapshot) {
-    const { issue, session, missingTrackedBlockers, blockedBy, ageMs, readyForExecution } = snapshot;
-    const pausedNoPrWork = isUndelegatedPausedNoPrWork(issue);
+export function isActiveWorkflowIssue(issue) {
+    return issue.factoryState !== "done" && !isTerminalFailureIssue(issue);
+}
+export function isTerminalFailureIssue(issue) {
+    return issue.factoryState === "failed" || issue.factoryState === "escalated";
+}
+export function evaluateTerminalIssueHealth(issue) {
     if (issue.factoryState === "failed" || issue.factoryState === "escalated") {
         return {
-            status: "fail",
+            status: "warn",
             scope: "issue:terminal",
-            message: `Issue is in terminal failure state ${issue.factoryState}`,
+            message: `Historical terminal issue is in failure state ${issue.factoryState}`,
         };
     }
+    return undefined;
+}
+export function evaluateLocalIssueHealth(snapshot) {
+    const { issue, session, missingTrackedBlockers, blockedBy, ageMs, readyForExecution } = snapshot;
+    const pausedNoPrWork = isUndelegatedPausedNoPrWork(issue);
     if (missingTrackedBlockers.length > 0) {
         return {
             status: "fail",

package/dist/cli/output.js

@@ -34,7 +34,7 @@ export function formatClusterHealth(report) {
         lines.push(`${marker} [${detail}] ${check.message}`);
     }
     lines.push("");
-    lines.push(`Summary: tracked=${report.summary.trackedIssues} non_done=${report.summary.openIssues} active_runs=${report.summary.activeRuns} blocked=${report.summary.blockedIssues} ready=${report.summary.readyIssues}`);
+    lines.push(`Summary: tracked=${report.summary.trackedIssues} active=${report.summary.openIssues} active_runs=${report.summary.activeRuns} blocked=${report.summary.blockedIssues} ready=${report.summary.readyIssues}`);
     if (report.summary.ciTrackedPrs > 0) {
         lines.push(`CI summary: prs=${report.summary.ciTrackedPrs} pending=${report.summary.ciPending} success=${report.summary.ciSuccess} failure=${report.summary.ciFailure} unknown=${report.summary.ciUnknown} missing_owner=${report.summary.ciOrphaned}`);
         for (const entry of report.ci) {

package/dist/cli/watch/use-detail-stream.js

@@ -1,4 +1,7 @@
 import { useEffect, useRef } from "react";
+const DETAIL_REHYDRATE_INTERVAL_MS = 3000;
+const FEED_REHYDRATE_LIMIT = 100;
+const MAX_CACHED_FEED_EVENTS = 300;
 export function useDetailStream(options) {
     const optionsRef = useRef(options);
     optionsRef.current = options;
@@ -14,10 +17,24 @@ export function useDetailStream(options) {
         if (bearerToken) {
             headers.authorization = `Bearer ${bearerToken}`;
         }
-        void rehydrate(baseUrl, issueKey, headers, abortController.signal, dispatch);
+        const feedState = {
+            lastFeedEventId: undefined,
+            feedEvents: [],
+        };
+        let inFlight = false;
+        const runRehydrate = () => {
+            if (inFlight)
+                return;
+            inFlight = true;
+            void rehydrate(baseUrl, issueKey, headers, abortController.signal, dispatch, feedState)
+                .finally(() => {
+                inFlight = false;
+            });
+        };
+        runRehydrate();
         const intervalId = setInterval(() => {
-            void rehydrate(baseUrl, issueKey, headers, abortController.signal, dispatch);
-        }, 3000);
+            runRehydrate();
+        }, DETAIL_REHYDRATE_INTERVAL_MS);
         return () => {
             clearInterval(intervalId);
             abortController.abort();
@@ -25,17 +42,22 @@ export function useDetailStream(options) {
     }, [options.issueKey, options.active]);
 }
 // ─── Rehydration ──────────────────────────────────────────────────
-async function rehydrate(baseUrl, issueKey, headers, signal, dispatch) {
+async function rehydrate(baseUrl, issueKey, headers, signal, dispatch, feedState) {
     try {
         const url = new URL(`/api/issues/${encodeURIComponent(issueKey)}`, baseUrl);
-        const response = await fetch(url, { headers: { ...headers, accept: "application/json" }, signal });
+        const feedUrl = buildFeedUrl(baseUrl, issueKey, feedState.lastFeedEventId);
+        const [response, newFeedEvents] = await Promise.all([
+            fetch(url, { headers: { ...headers, accept: "application/json" }, signal }),
+            fetchFeedEvents(feedUrl, headers, signal),
+        ]);
         if (!response.ok)
             return;
+        updateFeedState(feedState, newFeedEvents);
         const data = await response.json();
         dispatch({
             type: "timeline-rehydrate",
             runs: Array.isArray(data.runs) ? data.runs : [],
-            feedEvents: [],
+            feedEvents: feedState.feedEvents,
             liveThread: data.liveThread ?? null,
             activeRunId: data.activeRun?.id ?? null,
             activeRunStartedAt: data.activeRun?.startedAt ?? null,
@@ -46,3 +68,39 @@ async function rehydrate(baseUrl, issueKey, headers, signal, dispatch) {
         // Rehydration is best-effort
     }
 }
+function buildFeedUrl(baseUrl, issueKey, afterId) {
+    const feedUrl = new URL(`/api/issues/${encodeURIComponent(issueKey)}/feed`, baseUrl);
+    feedUrl.searchParams.set("limit", String(FEED_REHYDRATE_LIMIT));
+    if (afterId !== undefined) {
+        feedUrl.searchParams.set("afterId", String(afterId));
+    }
+    return feedUrl;
+}
+async function fetchFeedEvents(url, headers, signal) {
+    try {
+        const response = await fetch(url, { headers: { ...headers, accept: "application/json" }, signal });
+        if (!response.ok)
+            return [];
+        const data = await response.json();
+        return Array.isArray(data.events) ? data.events : [];
+    }
+    catch {
+        return [];
+    }
+}
+function updateFeedState(feedState, newEvents) {
+    if (newEvents.length === 0)
+        return;
+    const byId = new Map();
+    for (const event of feedState.feedEvents) {
+        byId.set(event.id, event);
+    }
+    for (const event of newEvents) {
+        byId.set(event.id, event);
+    }
+    const feedEvents = [...byId.values()]
+        .sort((left, right) => left.id - right.id)
+        .slice(-MAX_CACHED_FEED_EVENTS);
+    feedState.feedEvents = feedEvents;
+    feedState.lastFeedEventId = feedEvents.at(-1)?.id;
+}

package/dist/db.js

@@ -38,6 +38,7 @@ export class PatchRelayDatabase {
         this.connection.pragma("foreign_keys = ON");
         if (wal) {
             this.connection.pragma("journal_mode = WAL");
+            this.connection.pragma("synchronous = NORMAL");
         }
         this.linearInstallations = new LinearInstallationStore(this.connection);
         this.operatorFeed = new OperatorFeedStore(this.connection);

package/dist/http.js

@@ -264,6 +264,19 @@ export async function buildHttpServer(config, service, logger) {
             }
             return reply.send({ ok: true, ...result });
         });
+        app.get("/api/issues/:issueKey/feed", async (request, reply) => {
+            const issueKey = request.params.issueKey;
+            const afterId = getPositiveIntegerQueryParam(request, "afterId");
+            const requestedLimit = getPositiveIntegerQueryParam(request, "limit");
+            const result = service.listIssueFeedEvents(issueKey, {
+                ...(afterId !== undefined ? { afterId } : {}),
+                limit: requestedLimit ? Math.min(requestedLimit, 100) : 100,
+            });
+            if (!result) {
+                return reply.code(404).send({ ok: false, reason: "issue_not_found" });
+            }
+            return reply.send({ ok: true, events: result.events });
+        });
         app.get("/api/issues/:issueKey/live", async (request, reply) => {
             const issueKey = request.params.issueKey;
             const result = await service.getActiveRunStatus(issueKey);

package/dist/idle-reconciliation.js

@@ -12,6 +12,10 @@ import { fetchPullRequestSnapshot } from "./reconcile-pr-fetch.js";
 import { buildPrStateUpdates } from "./reconcile-pr-state-updates.js";
 import { buildRepairWakeDedupeKey, buildRequestedChangesWakeIdentity, reactiveWakeEventType } from "./reactive-wake-keys.js";
 import { execCommand } from "./utils.js";
+import { LinearIssueProjectionService } from "./linear-issue-projection.js";
+import { TerminalWakeReconciler } from "./terminal-wake-reconciler.js";
+const BLOCKED_DEPENDENCY_REFRESH_SUCCESS_BACKOFF_MS = 60_000;
+const BLOCKED_DEPENDENCY_REFRESH_FAILURE_BACKOFF_MS = 5 * 60_000;
 export class IdleIssueReconciler {
     db;
     config;
@@ -20,9 +24,13 @@ export class IdleIssueReconciler {
     feed;
     deployEvaluator;
     syncIssue;
+    linearProvider;
+    blockedDependencyRefreshAfter = new Map();
+    terminalWakeReconciler;
+    linearIssueProjection;
     constructor(db, config, wakeDispatcher, logger, feed, 
     // Injectable for tests; production uses the real `gh`-backed watcher.
-    deployEvaluator = evaluateDeploy, syncIssue) {
+    deployEvaluator = evaluateDeploy, syncIssue, linearProvider) {
         this.db = db;
         this.config = config;
         this.wakeDispatcher = wakeDispatcher;
@@ -30,6 +38,11 @@ export class IdleIssueReconciler {
         this.feed = feed;
         this.deployEvaluator = deployEvaluator;
         this.syncIssue = syncIssue;
+        this.linearProvider = linearProvider;
+        this.terminalWakeReconciler = new TerminalWakeReconciler(db, logger);
+        this.linearIssueProjection = linearProvider
+            ? new LinearIssueProjectionService(db, linearProvider, logger)
+            : undefined;
     }
     async reconcile() {
         // Wrap the entire reconcile pass in a dispatcher tick. Every
@@ -82,9 +95,21 @@ export class IdleIssueReconciler {
                 continue;
             await this.reconcileFromGitHub(issue);
         }
+        this.terminalWakeReconciler.reconcile();
         for (const issue of this.db.issues.listBlockedDelegatedIssues()) {
             if (!issue.delegatedToPatchRelay)
                 continue;
+            const dependencyKey = `${issue.projectId}::${issue.linearIssueId}`;
+            const refreshAfter = this.blockedDependencyRefreshAfter.get(dependencyKey);
+            if (this.linearIssueProjection) {
+                if (refreshAfter === undefined || refreshAfter <= Date.now()) {
+                    const refresh = await this.linearIssueProjection.refreshIssue(issue.projectId, issue.linearIssueId);
+                    this.blockedDependencyRefreshAfter.set(dependencyKey, Date.now() + (refresh.refreshed ? BLOCKED_DEPENDENCY_REFRESH_SUCCESS_BACKOFF_MS : BLOCKED_DEPENDENCY_REFRESH_FAILURE_BACKOFF_MS));
+                    if (!refresh.refreshed) {
+                        continue;
+                    }
+                }
+            }
             const unresolved = this.db.issues.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
             if (unresolved === 0) {
                 this.wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {

package/dist/linear-client.js

@@ -113,6 +113,45 @@ export class LinearGraphqlClient {
         }
         return this.mapIssue(response.issue);
     }
+    async listIssuesDelegatedTo(params) {
+        const teamIds = params.teamIds.filter((teamId) => teamId.trim().length > 0);
+        if (teamIds.length === 0) {
+            return [];
+        }
+        const first = Math.max(1, Math.min(params.first ?? 100, 100));
+        const issues = [];
+        let after;
+        do {
+            const response = await this.request(`
+        query PatchRelayDelegatedIssues($delegateId: ID!, $teamIds: [ID!], $first: Int!, $after: String) {
+          issues(
+            first: $first
+            after: $after
+            filter: {
+              delegate: { id: { eq: $delegateId } }
+              team: { id: { in: $teamIds } }
+            }
+          ) {
+            nodes {
+              ${LINEAR_ISSUE_SELECTION}
+            }
+            pageInfo {
+              hasNextPage
+              endCursor
+            }
+          }
+        }
+        `, {
+                delegateId: params.delegateId,
+                teamIds,
+                first,
+                after: after ?? null,
+            });
+            issues.push(...(response.issues.nodes ?? []).map((issue) => this.mapIssue(issue)));
+            after = response.issues.pageInfo.hasNextPage ? response.issues.pageInfo.endCursor ?? undefined : undefined;
+        } while (after);
+        return issues;
+    }
     async createIssue(params) {
         const response = await this.request(`
       mutation PatchRelayCreateIssue($input: IssueCreateInput!) {

package/dist/linear-issue-projection.js

@@ -0,0 +1,79 @@
+export class LinearIssueProjectionService {
+    db;
+    linearProvider;
+    logger;
+    constructor(db, linearProvider, logger) {
+        this.db = db;
+        this.linearProvider = linearProvider;
+        this.logger = logger;
+    }
+    async refreshIssue(projectId, linearIssueId) {
+        return refreshIssueFromLinear({
+            db: this.db,
+            linearProvider: this.linearProvider,
+            projectId,
+            linearIssueId,
+            logger: this.logger,
+        });
+    }
+}
+export async function refreshIssueFromLinear(params) {
+    const linear = await params.linearProvider.forProject(params.projectId).catch((error) => {
+        params.logger?.warn({
+            projectId: params.projectId,
+            linearIssueId: params.linearIssueId,
+            error: error instanceof Error ? error.message : String(error),
+        }, "Failed to resolve Linear client while refreshing issue projection");
+        return undefined;
+    });
+    if (!linear) {
+        return { refreshed: false, error: "linear_client_unavailable" };
+    }
+    try {
+        const liveIssue = await linear.getIssue(params.linearIssueId);
+        upsertLinearIssueProjection(params.db, params.projectId, liveIssue);
+        return { refreshed: true, liveIssue };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        params.logger?.warn({
+            projectId: params.projectId,
+            linearIssueId: params.linearIssueId,
+            error: message,
+        }, "Failed to refresh issue projection from Linear");
+        return { refreshed: false, error: message };
+    }
+}
+export function upsertLinearIssueProjection(db, projectId, liveIssue) {
+    replaceIssueDependenciesFromLinearIssue(db, projectId, liveIssue);
+    db.issues.replaceIssueParentLink({
+        projectId,
+        childLinearIssueId: liveIssue.id,
+        parentLinearIssueId: liveIssue.parentId ?? null,
+    });
+    db.issues.upsertIssue({
+        projectId,
+        linearIssueId: liveIssue.id,
+        ...(liveIssue.identifier ? { issueKey: liveIssue.identifier } : {}),
+        ...(liveIssue.title ? { title: liveIssue.title } : {}),
+        ...(liveIssue.description ? { description: liveIssue.description } : {}),
+        ...(liveIssue.url ? { url: liveIssue.url } : {}),
+        ...(liveIssue.priority != null ? { priority: liveIssue.priority } : {}),
+        ...(liveIssue.estimate != null ? { estimate: liveIssue.estimate } : {}),
+        ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
+        ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
+    });
+}
+export function replaceIssueDependenciesFromLinearIssue(db, projectId, liveIssue) {
+    db.issues.replaceIssueDependencies({
+        projectId,
+        linearIssueId: liveIssue.id,
+        blockers: liveIssue.blockedBy.map((blocker) => ({
+            blockerLinearIssueId: blocker.id,
+            ...(blocker.identifier ? { blockerIssueKey: blocker.identifier } : {}),
+            ...(blocker.title ? { blockerTitle: blocker.title } : {}),
+            ...(blocker.stateName ? { blockerCurrentLinearState: blocker.stateName } : {}),
+            ...(blocker.stateType ? { blockerCurrentLinearStateType: blocker.stateType } : {}),
+        })),
+    });
+}

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

@@ -2,6 +2,7 @@ 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";
+import { replaceIssueDependenciesFromLinearIssue } from "./linear-issue-projection.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;
@@ -45,17 +46,7 @@ export class MergedLinearCompletionReconciler {
             attemptedIssues += 1;
             try {
                 const liveIssue = await linear.getIssue(issue.linearIssueId);
-                this.db.issues.replaceIssueDependencies({
-                    projectId: issue.projectId,
-                    linearIssueId: issue.linearIssueId,
-                    blockers: liveIssue.blockedBy.map((blocker) => ({
-                        blockerLinearIssueId: blocker.id,
-                        ...(blocker.identifier ? { blockerIssueKey: blocker.identifier } : {}),
-                        ...(blocker.title ? { blockerTitle: blocker.title } : {}),
-                        ...(blocker.stateName ? { blockerCurrentLinearState: blocker.stateName } : {}),
-                        ...(blocker.stateType ? { blockerCurrentLinearStateType: blocker.stateType } : {}),
-                    })),
-                });
+                replaceIssueDependenciesFromLinearIssue(this.db, issue.projectId, liveIssue);
                 const latestRun = this.db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
                 const trustedNoPrDone = hasTrustedNoPrCompletion(issue, latestRun);
                 if (issue.prState === "merged" || trustedNoPrDone) {

package/dist/queue-failure-policy.js

@@ -0,0 +1,11 @@
+const SQLITE_LOCK_RETRY_DELAYS_MS = [250, 1_000, 2_500, 5_000, 10_000];
+export function retrySqliteLockedQueueFailure(error, attempt) {
+    if (!isSqliteDatabaseLockedError(error)) {
+        return undefined;
+    }
+    const delayMs = SQLITE_LOCK_RETRY_DELAYS_MS[attempt - 1];
+    return delayMs === undefined ? undefined : { delayMs };
+}
+export function isSqliteDatabaseLockedError(error) {
+    return /\bdatabase is locked\b/i.test(error.message);
+}

package/dist/run-admission-controller.js

@@ -0,0 +1,23 @@
+export class RunAdmissionController {
+    db;
+    linearIssueProjection;
+    constructor(db, linearIssueProjection) {
+        this.db = db;
+        this.linearIssueProjection = linearIssueProjection;
+    }
+    async check(params) {
+        if (params.runType !== "implementation") {
+            return { allowed: true };
+        }
+        const knownDependencyRows = this.db.issues.listIssueDependencies(params.projectId, params.linearIssueId).length;
+        const refresh = await this.linearIssueProjection.refreshIssue(params.projectId, params.linearIssueId);
+        if (!refresh.refreshed && knownDependencyRows > 0) {
+            return { allowed: false, reason: "dependency_refresh_failed", knownDependencyRows };
+        }
+        const blockerCount = this.db.issues.countUnresolvedBlockers(params.projectId, params.linearIssueId);
+        if (blockerCount > 0) {
+            return { allowed: false, reason: "blocked", blockerCount };
+        }
+        return { allowed: true };
+    }
+}

package/dist/run-orchestrator.js

@@ -24,6 +24,8 @@ import { buildIssueTriageHash, IssueTriageService } from "./issue-triage.js";
 import { loadConfig } from "./config.js";
 import { CodexThreadMaterializingError, isThreadMaterializingError } from "./codex-thread-errors.js";
 import { emitTelemetry, noopTelemetry } from "./telemetry.js";
+import { LinearIssueProjectionService } from "./linear-issue-projection.js";
+import { RunAdmissionController } from "./run-admission-controller.js";
 function lowerCaseFirst(value) {
     return value ? `${value.slice(0, 1).toLowerCase()}${value.slice(1)}` : value;
 }
@@ -64,6 +66,8 @@ export class RunOrchestrator {
     runNotificationHandler;
     runReconciler;
     mergedLinearCompletionReconciler;
+    linearIssueProjection;
+    runAdmission;
     codexRuntimeConfig;
     threadPorts = {
         readThreadWithRetry: (threadId, maxRetries) => this.readThreadWithRetry(threadId, maxRetries),
@@ -133,7 +137,9 @@ export class RunOrchestrator {
         this.interruptedRunRecovery = new InterruptedRunRecovery(db, logger, this.linearSync, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, this.recoveryPorts.failRunAndClear, this.recoveryPorts.restoreIdleWorktree, this.runCompletionPolicy, (projectId, issueId) => this.enqueueIssue(projectId, issueId), feed);
         this.runReconciler = new RunReconciler(db, logger, linearProvider, this.linearSync, this.interruptedRunRecovery, this.runFinalizer, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, this.threadPorts.readThreadWithRetry, this.recoveryPorts.recoverOrEscalate, (projectId) => this.config.projects.find((project) => project.id === projectId)?.github?.repoFullName, feed);
         this.runWakePlanner = new RunWakePlanner(db);
-        this.idleReconciler = new IdleIssueReconciler(db, config, this.wakeDispatcher, logger, feed, undefined, (issue) => this.linearSync.syncSession(issue));
+        this.linearIssueProjection = new LinearIssueProjectionService(db, linearProvider, logger);
+        this.runAdmission = new RunAdmissionController(db, this.linearIssueProjection);
+        this.idleReconciler = new IdleIssueReconciler(db, config, this.wakeDispatcher, logger, feed, undefined, (issue) => this.linearSync.syncSession(issue), linearProvider);
         this.mergedLinearCompletionReconciler = new MergedLinearCompletionReconciler(db, linearProvider, logger);
         this.queueHealthMonitor = new QueueHealthMonitor(db, config, {
             advanceIdleIssue: (issue, newState, options) => this.idleReconciler.advanceIdleIssue(issue, newState, options),
@@ -312,12 +318,21 @@ export class RunOrchestrator {
             return;
         }
         const { runType, context, resumeThread } = wake;
-        if (runType === "implementation" && this.db.issues.countUnresolvedBlockers(item.projectId, item.issueId) > 0) {
-            const blockerCount = this.db.issues.countUnresolvedBlockers(item.projectId, item.issueId);
+        const admission = await this.runAdmission.check({
+            projectId: item.projectId,
+            linearIssueId: item.issueId,
+            runType,
+        });
+        if (!admission.allowed) {
             this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(item.projectId, item.issueId);
             this.releaseIssueSessionLease(item.projectId, item.issueId);
-            this.emitRunSkipped(item, "blocked", issue, { runType, blockerCount });
-            this.logger.info({ issueKey: issue.issueKey }, "Skipped implementation launch because the issue is blocked");
+            this.emitRunSkipped(item, admission.reason, issue, { runType, ...admission });
+            if (admission.reason === "dependency_refresh_failed") {
+                this.logger.info({ issueKey: issue.issueKey, projectId: item.projectId, knownDependencyRows: admission.knownDependencyRows }, "Skipped implementation launch because dependency refresh failed for an issue with known blockers");
+            }
+            else {
+                this.logger.info({ issueKey: issue.issueKey, blockerCount: admission.blockerCount }, "Skipped implementation launch because the issue is blocked");
+            }
             return;
         }
         const remainingZombieDelayMs = shouldDelayZombieRecoveryLaunch(issue, issueSession, runType);

package/dist/service-queue.js

@@ -2,24 +2,33 @@ export class SerialWorkQueue {
     onDequeue;
     logger;
     getKey;
+    options;
     items = [];
     queuedKeys = new Set();
     pending = false;
-    constructor(onDequeue, logger, getKey) {
+    constructor(onDequeue, logger, getKey, options = {}) {
         this.onDequeue = onDequeue;
         this.logger = logger;
         this.getKey = getKey;
+        this.options = options;
     }
     enqueue(item, options) {
+        this.enqueueEntry({ item, attempt: 0 }, options);
+    }
+    size() {
+        return this.items.length;
+    }
+    enqueueEntry(entry, options) {
+        const { item } = entry;
         const key = this.getKey?.(item);
         if (key && this.queuedKeys.has(key)) {
             return;
         }
         if (options?.priority) {
-            this.items.unshift(item);
+            this.items.unshift(entry);
         }
         else {
-            this.items.push(item);
+            this.items.push(entry);
         }
         if (key) {
             this.queuedKeys.add(key);
@@ -31,22 +40,45 @@ export class SerialWorkQueue {
             });
         }
     }
+    scheduleRetry(entry, delayMs) {
+        const key = this.getKey?.(entry.item);
+        if (key && this.queuedKeys.has(key)) {
+            return;
+        }
+        if (key) {
+            this.queuedKeys.add(key);
+        }
+        const timer = setTimeout(() => {
+            if (key) {
+                this.queuedKeys.delete(key);
+            }
+            this.enqueueEntry(entry);
+        }, delayMs);
+        timer.unref?.();
+    }
     async drain() {
         while (this.items.length > 0) {
-            const next = this.items.shift();
-            if (next === undefined) {
+            const entry = this.items.shift();
+            if (entry === undefined) {
                 continue;
             }
-            const key = this.getKey?.(next);
+            const key = this.getKey?.(entry.item);
             if (key) {
                 this.queuedKeys.delete(key);
             }
             try {
-                await this.onDequeue(next);
+                await this.onDequeue(entry.item);
             }
             catch (error) {
                 const err = error instanceof Error ? error : new Error(String(error));
-                this.logger.error({ item: next, error: err.message, stack: err.stack }, "Queue item processing failed");
+                const nextAttempt = entry.attempt + 1;
+                const retry = this.options.retryOnError?.(err, entry.item, nextAttempt);
+                if (retry) {
+                    this.logger.warn({ item: entry.item, error: err.message, attempt: nextAttempt, retryDelayMs: retry.delayMs }, "Queue item processing failed; retrying");
+                    this.scheduleRetry({ item: entry.item, attempt: nextAttempt }, retry.delayMs);
+                    continue;
+                }
+                this.logger.error({ item: entry.item, error: err.message, stack: err.stack }, "Queue item processing failed");
             }
         }
         this.pending = false;

package/dist/service-runtime.js

@@ -1,7 +1,9 @@
 import { SerialWorkQueue } from "./service-queue.js";
+import { retrySqliteLockedQueueFailure } from "./queue-failure-policy.js";
 const ISSUE_KEY_DELIMITER = "::";
 const DEFAULT_RECONCILE_INTERVAL_MS = 5_000;
 const DEFAULT_RECONCILE_TIMEOUT_MS = 60_000;
+const DEFAULT_MAX_ACTIVE_ISSUE_RUNS = 4;
 function makeIssueQueueKey(item) {
     return `${item.projectId}${ISSUE_KEY_DELIMITER}${item.issueId}`;
 }
@@ -27,7 +29,9 @@ export class ServiceRuntime {
         this.readyIssueSource = readyIssueSource;
         this.options = options;
         this.webhookQueue = new SerialWorkQueue((eventId) => webhookProcessor.processWebhookEvent(eventId), logger, (eventId) => String(eventId));
-        this.issueQueue = new SerialWorkQueue((item) => issueProcessor.processIssue(item), logger, makeIssueQueueKey);
+        this.issueQueue = new SerialWorkQueue((item) => issueProcessor.processIssue(item), logger, makeIssueQueueKey, {
+            retryOnError: (error, _item, attempt) => retrySqliteLockedQueueFailure(error, attempt),
+        });
     }
     async start() {
         try {
@@ -54,6 +58,16 @@ export class ServiceRuntime {
         this.webhookQueue.enqueue(eventId, options);
     }
     enqueueIssue(projectId, issueId) {
+        if (!this.hasIssueRunCapacity()) {
+            this.logger.warn({
+                projectId,
+                issueId,
+                activeIssueRuns: this.getActiveIssueRunCount(),
+                queuedIssueRuns: this.issueQueue.size(),
+                maxActiveIssueRuns: this.getMaxActiveIssueRuns(),
+            }, "Skipped issue enqueue: active run capacity is full");
+            return;
+        }
         this.issueQueue.enqueue({ projectId, issueId });
     }
     setLinearConnected(connected) {
@@ -100,6 +114,9 @@ export class ServiceRuntime {
             // Pick up issues that became ready outside the webhook path
             // (e.g. CLI retry, manual DB edits) without requiring a restart.
             for (const issue of this.readyIssueSource.listIssuesReadyForExecution()) {
+                if (!this.hasIssueRunCapacity()) {
+                    break;
+                }
                 this.enqueueIssue(issue.projectId, issue.linearIssueId);
             }
         }
@@ -113,6 +130,16 @@ export class ServiceRuntime {
             }
         }
     }
+    getMaxActiveIssueRuns() {
+        const configured = this.options.maxActiveIssueRuns ?? DEFAULT_MAX_ACTIVE_ISSUE_RUNS;
+        return Math.max(1, Math.floor(configured));
+    }
+    getActiveIssueRunCount() {
+        return Math.max(0, this.readyIssueSource.countActiveIssueRuns?.() ?? 0);
+    }
+    hasIssueRunCapacity() {
+        return this.getActiveIssueRunCount() + this.issueQueue.size() < this.getMaxActiveIssueRuns();
+    }
 }
 function promiseWithTimeout(promise, timeoutMs, label) {
     return new Promise((resolve, reject) => {

package/dist/service-startup-recovery.js

@@ -2,13 +2,16 @@ import { appendDelegationObservedEvent } from "./delegation-audit.js";
 import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
 import { isResumablePausedLocalWork } from "./paused-issue-state.js";
 import { buildRepairWakeDedupeKey, buildRequestedChangesWakeIdentity, reactiveWakeEventType } from "./reactive-wake-keys.js";
+import { upsertLinearIssueProjection } from "./linear-issue-projection.js";
 export class ServiceStartupRecovery {
+    config;
     db;
     linearProvider;
     linearSync;
     enqueueIssue;
     logger;
-    constructor(db, linearProvider, linearSync, enqueueIssue, logger) {
+    constructor(config, db, linearProvider, linearSync, enqueueIssue, logger) {
+        this.config = config;
         this.db = db;
         this.linearProvider = linearProvider;
         this.linearSync = linearSync;
@@ -20,6 +23,9 @@ export class ServiceStartupRecovery {
             if (issue.factoryState === "done") {
                 continue;
             }
+            if (!issue.activeRunId) {
+                continue;
+            }
             const syncedIssue = issue.agentSessionId
                 ? issue
                 : (() => {
@@ -35,7 +41,11 @@ export class ServiceStartupRecovery {
             if (!syncedIssue.agentSessionId) {
                 continue;
             }
-            const activeRun = syncedIssue.activeRunId ? this.db.runs.getRunById(syncedIssue.activeRunId) : undefined;
+            const activeRunId = syncedIssue.activeRunId;
+            if (!activeRunId) {
+                continue;
+            }
+            const activeRun = this.db.runs.getRunById(activeRunId);
             if (!activeRun) {
                 continue;
             }
@@ -43,6 +53,7 @@ export class ServiceStartupRecovery {
         }
     }
     async recoverDelegatedIssueStateFromLinear() {
+        await this.discoverDelegatedIssuesFromLinear();
         for (const issue of this.db.issues.listIssues()) {
             if (issue.factoryState === "done" || issue.activeRunId !== undefined) {
                 continue;
@@ -59,17 +70,7 @@ export class ServiceStartupRecovery {
             if (!liveIssue) {
                 continue;
             }
-            this.db.issues.replaceIssueDependencies({
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                blockers: liveIssue.blockedBy.map((blocker) => ({
-                    blockerLinearIssueId: blocker.id,
-                    ...(blocker.identifier ? { blockerIssueKey: blocker.identifier } : {}),
-                    ...(blocker.title ? { blockerTitle: blocker.title } : {}),
-                    ...(blocker.stateName ? { blockerCurrentLinearState: blocker.stateName } : {}),
-                    ...(blocker.stateType ? { blockerCurrentLinearStateType: blocker.stateType } : {}),
-                })),
-            });
+            upsertLinearIssueProjection(this.db, issue.projectId, liveIssue);
             const delegated = liveIssue.delegateId === installation.actorId;
             if (issue.delegatedToPatchRelay !== delegated) {
                 appendDelegationObservedEvent(this.db, {
@@ -169,6 +170,86 @@ export class ServiceStartupRecovery {
             }
         }
     }
+    async discoverDelegatedIssuesFromLinear() {
+        for (const project of this.config.projects) {
+            const installation = this.db.linearInstallations.getLinearInstallationForProject(project.id);
+            if (!installation?.actorId) {
+                continue;
+            }
+            const linear = await this.linearProvider.forProject(project.id).catch(() => undefined);
+            if (!linear?.listIssuesDelegatedTo) {
+                continue;
+            }
+            const liveIssues = await linear.listIssuesDelegatedTo({
+                delegateId: installation.actorId,
+                teamIds: project.linearTeamIds,
+            }).catch((error) => {
+                this.logger.warn({
+                    projectId: project.id,
+                    error: error instanceof Error ? error.message : String(error),
+                }, "Failed to discover delegated Linear issues during startup recovery");
+                return [];
+            });
+            for (const liveIssue of liveIssues) {
+                if (!this.shouldRecoverDiscoveredIssue(project, liveIssue, installation.actorId)) {
+                    continue;
+                }
+                const existing = this.db.issues.getIssue(project.id, liveIssue.id);
+                if (existing) {
+                    continue;
+                }
+                this.upsertDiscoveredDelegatedIssue(project, liveIssue);
+            }
+        }
+    }
+    shouldRecoverDiscoveredIssue(project, liveIssue, actorId) {
+        if (liveIssue.delegateId !== actorId)
+            return false;
+        if (liveIssue.stateType === "completed" || liveIssue.stateType === "canceled")
+            return false;
+        if (project.linearTeamIds.length > 0 && (!liveIssue.teamId || !project.linearTeamIds.includes(liveIssue.teamId))) {
+            return false;
+        }
+        return true;
+    }
+    upsertDiscoveredDelegatedIssue(project, liveIssue) {
+        upsertLinearIssueProjection(this.db, project.id, liveIssue);
+        const existing = this.db.issues.getIssue(project.id, liveIssue.id);
+        const updated = this.db.issues.upsertIssue({
+            projectId: project.id,
+            linearIssueId: liveIssue.id,
+            delegatedToPatchRelay: true,
+            factoryState: existing?.factoryState ?? "delegated",
+            ...(liveIssue.identifier ? { issueKey: liveIssue.identifier } : {}),
+            ...(liveIssue.title ? { title: liveIssue.title } : {}),
+            ...(liveIssue.description ? { description: liveIssue.description } : {}),
+            ...(liveIssue.url ? { url: liveIssue.url } : {}),
+            ...(liveIssue.priority != null ? { priority: liveIssue.priority } : {}),
+            ...(liveIssue.estimate != null ? { estimate: liveIssue.estimate } : {}),
+            ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
+            ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
+        });
+        const hasPendingWake = this.db.workflowWakes.peekIssueWake(project.id, liveIssue.id) !== undefined;
+        const unresolvedBlockers = this.db.issues.countUnresolvedBlockers(project.id, liveIssue.id);
+        if (!hasPendingWake && unresolvedBlockers === 0) {
+            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(project.id, liveIssue.id, {
+                projectId: project.id,
+                linearIssueId: liveIssue.id,
+                eventType: "delegated",
+                dedupeKey: `delegated:${liveIssue.id}`,
+            });
+        }
+        if (this.db.workflowWakes.peekIssueWake(project.id, liveIssue.id)) {
+            this.enqueueIssue(project.id, liveIssue.id);
+        }
+        this.logger.info({
+            issueKey: updated.issueKey,
+            projectId: project.id,
+            unresolvedBlockers,
+        }, unresolvedBlockers === 0
+            ? "Discovered delegated Linear issue during startup recovery and queued implementation"
+            : "Discovered delegated blocked Linear issue during startup recovery");
+    }
     appendReactiveWakeEvent(projectId, linearIssueId, issue, runType) {
         const eventType = reactiveWakeEventType(runType);
         const dedupeKey = runType === "queue_repair" || runType === "ci_repair"

package/dist/service.js

@@ -67,7 +67,10 @@ export class PatchRelayService {
         leaseRelease = (projectId, issueId) => this.orchestrator.leaseService.release(projectId, issueId);
         this.webhookHandler = new WebhookHandler(config, db, this.linearProvider, codex, dispatcher, logger, this.feed, undefined, agentInput, telemetry);
         this.githubWebhookHandler = new GitHubWebhookHandler(config, db, this.linearProvider, dispatcher, logger, codex, this.feed);
-        const runtime = new ServiceRuntime(codex, logger, this.orchestrator, { listIssuesReadyForExecution: () => db.listIssuesReadyForExecution() }, this.webhookHandler, {
+        const runtime = new ServiceRuntime(codex, logger, this.orchestrator, {
+            listIssuesReadyForExecution: () => db.listIssuesReadyForExecution(),
+            countActiveIssueRuns: () => db.runs.listActiveRuns().length,
+        }, this.webhookHandler, {
             processIssue: async (item) => {
                 await this.orchestrator.run(item);
             },
@@ -77,7 +80,7 @@ export class PatchRelayService {
         this.queryService = new IssueQueryService(db, codex, this.orchestrator);
         this.runtime = runtime;
         this.issueActions = new ServiceIssueActions(config, db, agentInput, codex, runtime, this.feed, logger);
-        this.startupRecovery = new ServiceStartupRecovery(db, this.linearProvider, this.orchestrator.linearSync, (projectId, issueId) => runtime.enqueueIssue(projectId, issueId), logger);
+        this.startupRecovery = new ServiceStartupRecovery(config, db, this.linearProvider, this.orchestrator.linearSync, (projectId, issueId) => runtime.enqueueIssue(projectId, issueId), logger);
         this.trackedIssueListQuery = new TrackedIssueListQuery(db);
         // Optional GitHub App token management for bot identity
         const ghAppCredentials = resolveGitHubAppCredentials();
@@ -338,6 +341,22 @@ export class PatchRelayService {
     async getIssueOverview(issueKey) {
         return await this.queryService.getIssueOverview(issueKey);
     }
+    listIssueFeedEvents(issueKey, options) {
+        const session = this.db.issueSessions.getIssueSessionByKey(issueKey);
+        const issue = this.db.issues.getIssueByKey(issueKey);
+        const projectId = session?.projectId ?? issue?.projectId;
+        const resolvedIssueKey = session?.issueKey ?? issue?.issueKey ?? issueKey;
+        if (!projectId)
+            return undefined;
+        return {
+            events: this.db.operatorFeed.list({
+                issueKey: resolvedIssueKey,
+                projectId,
+                ...(options?.afterId !== undefined ? { afterId: options.afterId } : {}),
+                limit: Math.min(options?.limit ?? 100, 100),
+            }),
+        };
+    }
     async getActiveRunStatus(issueKey) {
         return await this.orchestrator.getActiveRunStatus(issueKey);
     }

package/dist/telemetry.js

@@ -78,8 +78,24 @@ export class OperatorFeedTelemetrySink {
                     };
                 }
                 return undefined;
+            case "health.invariant":
+                return {
+                    level: event.status === "observed" ? "warn" : "info",
+                    kind: "workflow",
+                    ...(event.issueKey ? { issueKey: event.issueKey } : {}),
+                    ...(event.projectId ? { projectId: event.projectId } : {}),
+                    ...(event.runType ? { stage: event.runType } : {}),
+                    status: `health_${event.status}`,
+                    summary: event.status === "observed"
+                        ? `Health warning: ${formatInvariant(event.invariant)}`
+                        : `Health repaired: ${formatInvariant(event.invariant)}`,
+                    ...(event.detail ? { detail: event.detail } : {}),
+                };
             default:
                 return undefined;
         }
     }
 }
+function formatInvariant(invariant) {
+    return invariant.replaceAll("_", " ");
+}

package/dist/terminal-wake-reconciler.js

@@ -0,0 +1,28 @@
+import { TERMINAL_STATES } from "./factory-state.js";
+export class TerminalWakeReconciler {
+    db;
+    logger;
+    constructor(db, logger) {
+        this.db = db;
+        this.logger = logger;
+    }
+    reconcile() {
+        for (const issue of this.db.issues.listIssues()) {
+            if (!TERMINAL_STATES.has(issue.factoryState) || issue.activeRunId !== undefined) {
+                continue;
+            }
+            if (!this.db.issueSessions.hasPendingIssueSessionEvents(issue.projectId, issue.linearIssueId)
+                && issue.pendingRunType === undefined) {
+                continue;
+            }
+            this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(issue.projectId, issue.linearIssueId);
+            this.db.issues.upsertIssue({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                pendingRunType: null,
+                pendingRunContextJson: null,
+            });
+            this.logger.info({ issueKey: issue.issueKey, factoryState: issue.factoryState }, "Reconciliation: cleared stale terminal wake");
+        }
+    }
+}

package/dist/webhooks/issue-dependency-sync.js

@@ -1,3 +1,4 @@
+import { replaceIssueDependenciesFromLinearIssue } from "../linear-issue-projection.js";
 import { mergeIssueMetadata } from "./decision-helpers.js";
 /**
  * Brings the local dependency / parent-link state for `issue` up to date.
@@ -24,17 +25,7 @@ export async function syncIssueDependencies(db, linearProvider, projectId, issue
         }
     }
     if (source.relationsKnown) {
-        db.issues.replaceIssueDependencies({
-            projectId,
-            linearIssueId: source.id,
-            blockers: source.blockedBy.map((blocker) => ({
-                blockerLinearIssueId: blocker.id,
-                ...(blocker.identifier ? { blockerIssueKey: blocker.identifier } : {}),
-                ...(blocker.title ? { blockerTitle: blocker.title } : {}),
-                ...(blocker.stateName ? { blockerCurrentLinearState: blocker.stateName } : {}),
-                ...(blocker.stateType ? { blockerCurrentLinearStateType: blocker.stateType } : {}),
-            })),
-        });
+        replaceIssueDependenciesFromLinearIssue(db, projectId, source);
     }
     db.issues.replaceIssueParentLink({
         projectId,

package/package.json

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