patchrelay 0.75.0 → 0.75.2

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[retry.logLevel ?? "warn"]({ item: entry.item, error: err.message, attempt: nextAttempt, retryDelayMs: retry.delayMs }, retry.message ?? "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,11 @@
 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;
+const DEFAULT_ISSUE_RUN_CAPACITY_RETRY_DELAY_MS = 5_000;
+const EVENT_LOOP_MONITOR_INTERVAL_MS = 1_000;
 function makeIssueQueueKey(item) {
     return `${item.projectId}${ISSUE_KEY_DELIMITER}${item.issueId}`;
 }
@@ -19,6 +23,9 @@ export class ServiceRuntime {
     githubAppAuthError;
     startupError;
     reconcileTimer;
+    eventLoopMonitorTimer;
+    eventLoopMonitorExpectedAt = 0;
+    eventLoopLagMs = 0;
     reconcileInProgress = false;
     constructor(codex, logger, runReconciler, readyIssueSource, webhookProcessor, issueProcessor, options = {}) {
         this.codex = codex;
@@ -27,11 +34,23 @@ 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) => this.processIssueWithCapacity(item, issueProcessor), logger, makeIssueQueueKey, {
+            retryOnError: (error, _item, attempt) => {
+                if (error instanceof IssueRunCapacityFullError) {
+                    return {
+                        delayMs: this.getIssueRunCapacityRetryDelayMs(),
+                        logLevel: "debug",
+                        message: "Issue run capacity is full; keeping item queued for retry",
+                    };
+                }
+                return retrySqliteLockedQueueFailure(error, attempt);
+            },
+        });
     }
     async start() {
         try {
             await this.codex.start();
+            this.startEventLoopMonitor();
             for (const issue of this.readyIssueSource.listIssuesReadyForExecution()) {
                 this.enqueueIssue(issue.projectId, issue.linearIssueId);
             }
@@ -48,6 +67,7 @@ export class ServiceRuntime {
     async stop() {
         this.ready = false;
         this.clearBackgroundReconcile();
+        this.clearEventLoopMonitor();
         await this.codex.stop();
     }
     enqueueWebhookEvent(eventId, options) {
@@ -69,10 +89,29 @@ export class ServiceRuntime {
             codexStarted: this.codex.isStarted(),
             linearConnected: this.linearConnected,
             githubAppAuthHealthy: this.githubAppAuthHealthy,
+            eventLoopLagMs: this.eventLoopLagMs,
             ...(this.githubAppAuthError ? { githubAppAuthError: this.githubAppAuthError } : {}),
             ...(this.startupError ? { startupError: this.startupError } : {}),
         };
     }
+    startEventLoopMonitor() {
+        this.clearEventLoopMonitor();
+        this.eventLoopMonitorExpectedAt = Date.now() + EVENT_LOOP_MONITOR_INTERVAL_MS;
+        const timer = setInterval(() => {
+            const now = Date.now();
+            this.eventLoopLagMs = Math.max(0, now - this.eventLoopMonitorExpectedAt);
+            this.eventLoopMonitorExpectedAt = now + EVENT_LOOP_MONITOR_INTERVAL_MS;
+        }, EVENT_LOOP_MONITOR_INTERVAL_MS);
+        timer.unref?.();
+        this.eventLoopMonitorTimer = timer;
+    }
+    clearEventLoopMonitor() {
+        if (this.eventLoopMonitorTimer !== undefined) {
+            clearInterval(this.eventLoopMonitorTimer);
+            this.eventLoopMonitorTimer = undefined;
+        }
+        this.eventLoopLagMs = 0;
+    }
     scheduleBackgroundReconcile() {
         this.clearBackgroundReconcile();
         const timer = setTimeout(() => {
@@ -113,6 +152,35 @@ export class ServiceRuntime {
             }
         }
     }
+    getMaxActiveIssueRuns() {
+        const configured = this.options.maxActiveIssueRuns ?? DEFAULT_MAX_ACTIVE_ISSUE_RUNS;
+        return Math.max(1, Math.floor(configured));
+    }
+    getIssueRunCapacityRetryDelayMs() {
+        const configured = this.options.issueRunCapacityRetryDelayMs ?? DEFAULT_ISSUE_RUN_CAPACITY_RETRY_DELAY_MS;
+        return Math.max(1, Math.floor(configured));
+    }
+    getActiveIssueRunCount() {
+        return Math.max(0, this.readyIssueSource.countActiveIssueRuns?.() ?? 0);
+    }
+    async processIssueWithCapacity(item, processor) {
+        const activeIssueRuns = this.getActiveIssueRunCount();
+        const maxActiveIssueRuns = this.getMaxActiveIssueRuns();
+        if (activeIssueRuns >= maxActiveIssueRuns) {
+            throw new IssueRunCapacityFullError(activeIssueRuns, maxActiveIssueRuns);
+        }
+        await processor.processIssue(item);
+    }
+}
+class IssueRunCapacityFullError extends Error {
+    activeIssueRuns;
+    maxActiveIssueRuns;
+    constructor(activeIssueRuns, maxActiveIssueRuns) {
+        super(`active issue run capacity is full (${activeIssueRuns}/${maxActiveIssueRuns})`);
+        this.activeIssueRuns = activeIssueRuns;
+        this.maxActiveIssueRuns = maxActiveIssueRuns;
+        this.name = "IssueRunCapacityFullError";
+    }
 }
 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

@@ -14,6 +14,7 @@ import { ServiceStartupRecovery } from "./service-startup-recovery.js";
 import { WakeDispatcher } from "./wake-dispatcher.js";
 import { WebhookHandler } from "./webhook-handler.js";
 import { acceptIncomingWebhook } from "./service-webhooks.js";
+import { runWebhookEventRetention } from "./event-retention.js";
 import { parseStringArray, TrackedIssueListQuery } from "./tracked-issue-list-query.js";
 import { AgentInputService } from "./agent-input-service.js";
 import { CodexFollowupIntentClassifier } from "./followup-intent.js";
@@ -36,6 +37,7 @@ export class PatchRelayService {
     issueActions;
     startupRecovery;
     trackedIssueListQuery;
+    eventRetentionTimer;
     constructor(config, db, codex, linearProvider, logger, configPath) {
         this.config = config;
         this.db = db;
@@ -67,7 +69,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 +82,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();
@@ -178,6 +183,7 @@ export class PatchRelayService {
             });
         }
         await this.runtime.start();
+        this.scheduleEventRetention(60_000);
         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");
@@ -188,6 +194,10 @@ export class PatchRelayService {
         });
     }
     async stop() {
+        if (this.eventRetentionTimer !== undefined) {
+            clearTimeout(this.eventRetentionTimer);
+            this.eventRetentionTimer = undefined;
+        }
         this.githubAppTokenManager?.stop();
         await this.runtime.stop();
     }
@@ -277,6 +287,37 @@ export class PatchRelayService {
     getReadiness() {
         return this.runtime.getReadiness();
     }
+    scheduleEventRetention(delayMs = 24 * 60 * 60 * 1000) {
+        if (this.eventRetentionTimer !== undefined) {
+            clearTimeout(this.eventRetentionTimer);
+        }
+        const timer = setTimeout(() => {
+            void this.runEventRetentionMaintenance();
+        }, delayMs);
+        timer.unref?.();
+        this.eventRetentionTimer = timer;
+    }
+    async runEventRetentionMaintenance() {
+        try {
+            const result = await runWebhookEventRetention({
+                db: this.db,
+                config: this.config,
+            });
+            if (result.deleted > 0 || result.archived > 0 || result.remaining > 0) {
+                this.logger.info(result, "Webhook event retention maintenance completed");
+            }
+            if (this.config.database.wal) {
+                const checkpoint = this.db.runWalCheckpoint("PASSIVE");
+                this.logger.debug({ checkpoint }, "SQLite WAL checkpoint completed");
+            }
+        }
+        catch (error) {
+            this.logger.warn({ error: error instanceof Error ? error.message : String(error) }, "Webhook event retention maintenance failed");
+        }
+        finally {
+            this.scheduleEventRetention();
+        }
+    }
     listTrackedIssues() {
         return this.trackedIssueListQuery.listTrackedIssues();
     }

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