patchrelay 0.36.7 → 0.36.9

package/dist/issue-query-service.js

@@ -29,7 +29,7 @@ export class IssueQueryService {
         return await this.codex.readThread(run.threadId, true).catch(() => undefined);
     }
     buildRuns(projectId, linearIssueId) {
-        return this.db.listRunsForIssue(projectId, linearIssueId).map((run) => ({
+        return this.db.runs.listRunsForIssue(projectId, linearIssueId).map((run) => ({
             id: run.id,
             runType: run.runType,
             status: run.status,
@@ -41,7 +41,7 @@ export class IssueQueryService {
                 return report ? { report } : {};
             })(),
             ...(() => {
-                const events = this.db.listThreadEvents(run.id).flatMap((event) => {
+                const events = this.db.runs.listThreadEvents(run.id).flatMap((event) => {
                     try {
                         const parsed = JSON.parse(event.eventJson);
                         return [{
@@ -66,16 +66,16 @@ export class IssueQueryService {
         }));
     }
     async getIssueOverview(issueKey) {
-        const session = this.db.getIssueSessionByKey(issueKey);
+        const session = this.db.issueSessions.getIssueSessionByKey(issueKey);
         if (!session) {
             const legacy = this.db.getIssueOverview(issueKey);
             if (!legacy)
                 return undefined;
-            const issueRecord = this.db.getIssueByKey(issueKey);
+            const issueRecord = this.db.issues.getIssueByKey(issueKey);
             const activeStatus = await this.runStatusProvider.getActiveRunStatus(issueKey);
             const activeRun = activeStatus?.run ?? legacy.activeRun;
-            const latestRun = this.db.getLatestRunForIssue(legacy.issue.projectId, legacy.issue.linearIssueId);
-            const latestEvent = this.db.listIssueSessionEvents(legacy.issue.projectId, legacy.issue.linearIssueId, { limit: 1 }).at(-1);
+            const latestRun = this.db.runs.getLatestRunForIssue(legacy.issue.projectId, legacy.issue.linearIssueId);
+            const latestEvent = this.db.issueSessions.listIssueSessionEvents(legacy.issue.projectId, legacy.issue.linearIssueId, { limit: 1 }).at(-1);
             const runs = this.buildRuns(legacy.issue.projectId, legacy.issue.linearIssueId);
             const runCount = runs.length;
             const liveThread = await this.readLiveThread(activeRun);
@@ -123,16 +123,16 @@ export class IssueQueryService {
                     : {}),
             };
         }
-        const issueRecord = this.db.getIssueByKey(issueKey);
-        const blockedBy = this.db.listIssueDependencies(session.projectId, session.linearIssueId);
+        const issueRecord = this.db.issues.getIssueByKey(issueKey);
+        const blockedBy = this.db.issues.listIssueDependencies(session.projectId, session.linearIssueId);
         const unresolvedBlockedBy = blockedBy.filter((entry) => (entry.blockerCurrentLinearStateType !== "completed"
             && entry.blockerCurrentLinearState?.trim().toLowerCase() !== "done"));
         const blockedByKeys = unresolvedBlockedBy.map((entry) => entry.blockerIssueKey ?? entry.blockerLinearIssueId);
         const activeStatus = await this.runStatusProvider.getActiveRunStatus(issueKey);
         const activeRun = activeStatus?.run
-            ?? (session.activeRunId !== undefined ? this.db.getRun(session.activeRunId) : undefined);
-        const latestRun = this.db.getLatestRunForIssue(session.projectId, session.linearIssueId);
-        const latestEvent = this.db.listIssueSessionEvents(session.projectId, session.linearIssueId, { limit: 1 }).at(-1);
+            ?? (session.activeRunId !== undefined ? this.db.runs.getRunById(session.activeRunId) : undefined);
+        const latestRun = this.db.runs.getLatestRunForIssue(session.projectId, session.linearIssueId);
+        const latestEvent = this.db.issueSessions.listIssueSessionEvents(session.projectId, session.linearIssueId, { limit: 1 }).at(-1);
         const runs = this.buildRuns(session.projectId, session.linearIssueId);
         const runCount = runs.length;
         const liveThread = await this.readLiveThread(activeRun);
@@ -166,7 +166,7 @@ export class IssueQueryService {
                 factoryState: issueRecord?.factoryState ?? "delegated",
                 ...(activeRun ? { activeRunId: activeRun.id } : {}),
                 blockedByCount: unresolvedBlockedBy.length,
-                hasPendingWake: this.db.peekIssueSessionWake(session.projectId, session.linearIssueId) !== undefined,
+                hasPendingWake: this.db.issueSessions.peekIssueSessionWake(session.projectId, session.linearIssueId) !== undefined,
                 hasLegacyPendingRun: issueRecord?.pendingRunType !== undefined,
                 ...(session.prNumber !== undefined ? { prNumber: session.prNumber } : {}),
                 ...(issueRecord?.prState ? { prState: issueRecord.prState } : {}),
@@ -231,7 +231,7 @@ export class IssueQueryService {
         const overview = await this.getIssueOverview(issueKey);
         if (!overview)
             return undefined;
-        const issueRecord = this.db.getIssueByKey(issueKey);
+        const issueRecord = this.db.issues.getIssueByKey(issueKey);
         const latestRunReport = parseStageReport(overview.latestRun?.reportJson, overview.latestRun?.status ?? "unknown");
         const runs = (overview.runs ?? this.buildRuns(overview.issue.projectId, overview.issue.linearIssueId)).map((run) => ({
             run: {

package/dist/issue-session-lease-service.js

@@ -0,0 +1,143 @@
+import { randomUUID } from "node:crypto";
+import { getThreadTurns } from "./codex-thread-utils.js";
+const ISSUE_SESSION_LEASE_MS = 10 * 60_000;
+export class IssueSessionLeaseService {
+    db;
+    logger;
+    workerId;
+    readThreadWithRetry;
+    activeSessionLeases = new Map();
+    constructor(db, logger, workerId, readThreadWithRetry) {
+        this.db = db;
+        this.logger = logger;
+        this.workerId = workerId;
+        this.readThreadWithRetry = readThreadWithRetry;
+    }
+    hasLocalLease(projectId, linearIssueId) {
+        return this.activeSessionLeases.has(this.issueSessionLeaseKey(projectId, linearIssueId));
+    }
+    getHeldLease(projectId, linearIssueId) {
+        const leaseId = this.activeSessionLeases.get(this.issueSessionLeaseKey(projectId, linearIssueId));
+        if (!leaseId)
+            return undefined;
+        return { projectId, linearIssueId, leaseId };
+    }
+    withHeldLease(projectId, linearIssueId, fn) {
+        const lease = this.getHeldLease(projectId, linearIssueId);
+        if (!lease)
+            return undefined;
+        return this.db.issueSessions.withIssueSessionLease(projectId, linearIssueId, lease.leaseId, () => fn(lease));
+    }
+    acquire(projectId, linearIssueId) {
+        const leaseId = randomUUID();
+        const leasedUntil = new Date(Date.now() + ISSUE_SESSION_LEASE_MS).toISOString();
+        const acquired = this.db.issueSessions.acquireIssueSessionLease({
+            projectId,
+            linearIssueId,
+            leaseId,
+            workerId: this.workerId,
+            leasedUntil,
+        });
+        if (!acquired)
+            return undefined;
+        this.activeSessionLeases.set(this.issueSessionLeaseKey(projectId, linearIssueId), leaseId);
+        return leaseId;
+    }
+    forceAcquire(projectId, linearIssueId) {
+        const leaseId = randomUUID();
+        const leasedUntil = new Date(Date.now() + ISSUE_SESSION_LEASE_MS).toISOString();
+        const acquired = this.db.issueSessions.forceAcquireIssueSessionLease({
+            projectId,
+            linearIssueId,
+            leaseId,
+            workerId: this.workerId,
+            leasedUntil,
+        });
+        if (!acquired)
+            return undefined;
+        this.activeSessionLeases.set(this.issueSessionLeaseKey(projectId, linearIssueId), leaseId);
+        return leaseId;
+    }
+    claimForReconciliation(projectId, linearIssueId) {
+        const key = this.issueSessionLeaseKey(projectId, linearIssueId);
+        if (this.activeSessionLeases.has(key)) {
+            return "owned";
+        }
+        const session = this.db.issueSessions.getIssueSession(projectId, linearIssueId);
+        if (!session)
+            return "skip";
+        const leasedUntilMs = session.leasedUntil ? Date.parse(session.leasedUntil) : undefined;
+        if (leasedUntilMs !== undefined && Number.isFinite(leasedUntilMs) && leasedUntilMs > Date.now()) {
+            return "skip";
+        }
+        return this.acquire(projectId, linearIssueId) ? true : "skip";
+    }
+    async reclaimForeignRecoveryLeaseIfSafe(run, issue) {
+        const key = this.issueSessionLeaseKey(run.projectId, run.linearIssueId);
+        if (this.activeSessionLeases.has(key)) {
+            return false;
+        }
+        const session = this.db.issueSessions.getIssueSession(run.projectId, run.linearIssueId);
+        if (!session?.leaseId || !session.workerId || session.workerId === this.workerId) {
+            return false;
+        }
+        if (issue.activeRunId !== run.id) {
+            return false;
+        }
+        let safeToReclaim = !run.threadId;
+        if (!safeToReclaim && run.threadId) {
+            try {
+                const thread = await this.readThreadWithRetry(run.threadId, 1);
+                const latestTurn = getThreadTurns(thread).at(-1);
+                safeToReclaim = thread.status === "notLoaded"
+                    || latestTurn?.status === "interrupted"
+                    || latestTurn?.status === "completed";
+            }
+            catch {
+                safeToReclaim = true;
+            }
+        }
+        if (!safeToReclaim) {
+            return false;
+        }
+        const leaseId = this.forceAcquire(run.projectId, run.linearIssueId);
+        if (!leaseId) {
+            return false;
+        }
+        this.logger.info({
+            issueKey: issue.issueKey,
+            runId: run.id,
+            previousWorkerId: session.workerId,
+            previousLeaseId: session.leaseId,
+            reclaimedLeaseId: leaseId,
+        }, "Reclaimed foreign issue-session lease for active-run recovery");
+        return true;
+    }
+    heartbeat(projectId, linearIssueId) {
+        const key = this.issueSessionLeaseKey(projectId, linearIssueId);
+        const leaseId = this.activeSessionLeases.get(key) ?? this.db.issueSessions.getIssueSession(projectId, linearIssueId)?.leaseId;
+        if (!leaseId)
+            return false;
+        const renewed = this.db.issueSessions.renewIssueSessionLease({
+            projectId,
+            linearIssueId,
+            leaseId,
+            leasedUntil: new Date(Date.now() + ISSUE_SESSION_LEASE_MS).toISOString(),
+        });
+        if (renewed) {
+            this.activeSessionLeases.set(key, leaseId);
+            return true;
+        }
+        this.activeSessionLeases.delete(key);
+        return false;
+    }
+    release(projectId, linearIssueId) {
+        const key = this.issueSessionLeaseKey(projectId, linearIssueId);
+        const leaseId = this.activeSessionLeases.get(key);
+        this.db.issueSessions.releaseIssueSessionLease(projectId, linearIssueId, leaseId);
+        this.activeSessionLeases.delete(key);
+    }
+    issueSessionLeaseKey(projectId, linearIssueId) {
+        return `${projectId}:${linearIssueId}`;
+    }
+}

package/dist/issue-session-projector.js

@@ -0,0 +1,114 @@
+import { isoNow } from "./db/shared.js";
+import { buildTrackedIssueRecord } from "./tracked-issue-projector.js";
+import { extractLatestAssistantSummary, } from "./issue-session-events.js";
+import { deriveIssueSessionState, deriveIssueSessionWakeReason, } from "./issue-session.js";
+export function syncIssueSessionFromIssue(params) {
+    const { connection, issues, issueSessions, runs, issue, options } = params;
+    const existing = issueSessions.getIssueSession(issue.projectId, issue.linearIssueId);
+    const latestRun = runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
+    const latestRunType = options?.lastRunType ?? latestRun?.runType ?? existing?.lastRunType;
+    const summaryText = resolveIssueSessionSummary(issue, runs, latestRun, existing?.summaryText, options?.summaryText);
+    const activeThreadId = issue.threadId ?? existing?.activeThreadId;
+    const threadGeneration = activeThreadId && activeThreadId !== existing?.activeThreadId
+        ? (existing?.threadGeneration ?? 0) + 1
+        : (existing?.threadGeneration ?? (activeThreadId ? 1 : 0));
+    const sessionState = deriveIssueSessionState({
+        ...(issue.activeRunId !== undefined ? { activeRunId: issue.activeRunId } : {}),
+        factoryState: issue.factoryState,
+    });
+    const tracked = buildTrackedIssueRecord({
+        issue,
+        session: existing,
+        blockedBy: issues.listIssueDependencies(issue.projectId, issue.linearIssueId),
+        hasPendingWake: issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId) !== undefined,
+        latestRun,
+        latestEvent: issueSessions.listIssueSessionEvents(issue.projectId, issue.linearIssueId, { limit: 1 }).at(-1),
+    });
+    const lastWakeReason = options?.lastWakeReason
+        ?? deriveIssueSessionWakeReason({
+            pendingRunType: issue.pendingRunType,
+            factoryState: issue.factoryState,
+            prNumber: issue.prNumber,
+            prState: issue.prState,
+            prReviewState: issue.prReviewState,
+            prCheckStatus: issue.prCheckStatus,
+            latestFailureSource: issue.lastGitHubFailureSource,
+        })
+        ?? existing?.lastWakeReason;
+    const now = isoNow();
+    if (existing) {
+        connection.prepare(`
+      UPDATE issue_sessions SET
+        issue_key = ?,
+        repo_id = ?,
+        branch_name = ?,
+        worktree_path = ?,
+        pr_number = ?,
+        pr_head_sha = ?,
+        pr_author_login = ?,
+        session_state = ?,
+        waiting_reason = ?,
+        summary_text = ?,
+        active_thread_id = ?,
+        thread_generation = ?,
+        active_run_id = ?,
+        last_run_type = ?,
+        last_wake_reason = ?,
+        ci_repair_attempts = ?,
+        queue_repair_attempts = ?,
+        review_fix_attempts = ?,
+        updated_at = ?
+      WHERE project_id = ? AND linear_issue_id = ?
+    `).run(issue.issueKey ?? null, issue.projectId, issue.branchName ?? null, issue.worktreePath ?? null, issue.prNumber ?? null, issue.prHeadSha ?? null, issue.prAuthorLogin ?? null, sessionState, tracked.waitingReason ?? null, summaryText ?? null, activeThreadId ?? null, threadGeneration, issue.activeRunId ?? null, latestRunType ?? null, lastWakeReason ?? null, issue.ciRepairAttempts, issue.queueRepairAttempts, issue.reviewFixAttempts, now, issue.projectId, issue.linearIssueId);
+        return;
+    }
+    connection.prepare(`
+    INSERT INTO issue_sessions (
+      project_id, linear_issue_id, issue_key, repo_id, branch_name, worktree_path,
+      pr_number, pr_head_sha, pr_author_login, session_state, waiting_reason, summary_text,
+      active_thread_id, thread_generation, active_run_id, last_run_type, last_wake_reason,
+      ci_repair_attempts, queue_repair_attempts, review_fix_attempts,
+      created_at, updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(issue.projectId, issue.linearIssueId, issue.issueKey ?? null, issue.projectId, issue.branchName ?? null, issue.worktreePath ?? null, issue.prNumber ?? null, issue.prHeadSha ?? null, issue.prAuthorLogin ?? null, sessionState, tracked.waitingReason ?? null, summaryText ?? null, activeThreadId ?? null, threadGeneration, issue.activeRunId ?? null, latestRunType ?? null, lastWakeReason ?? null, issue.ciRepairAttempts, issue.queueRepairAttempts, issue.reviewFixAttempts, now, now);
+}
+function resolveIssueSessionSummary(issue, runs, latestRun, existingSummaryText, explicitSummaryText) {
+    if (explicitSummaryText?.trim()) {
+        return explicitSummaryText;
+    }
+    const latestSummary = extractLatestAssistantSummary(latestRun);
+    if (latestRun && (latestRun.status === "queued" || latestRun.status === "running")) {
+        return latestSummary;
+    }
+    if (shouldKeepPreviousIssueSummary(issue, latestRun)) {
+        return findLatestCompletedRunSummary(runs, issue.projectId, issue.linearIssueId)
+            ?? existingSummaryText
+            ?? latestSummary;
+    }
+    return latestSummary ?? existingSummaryText;
+}
+function shouldKeepPreviousIssueSummary(issue, latestRun) {
+    if (!latestRun || latestRun.status !== "failed") {
+        return false;
+    }
+    if (latestRun.summaryJson || latestRun.reportJson) {
+        return false;
+    }
+    return issue.factoryState === "pr_open"
+        || issue.factoryState === "awaiting_queue"
+        || issue.factoryState === "done";
+}
+function findLatestCompletedRunSummary(runs, projectId, linearIssueId) {
+    const issueRuns = runs.listRunsForIssue(projectId, linearIssueId);
+    for (let index = issueRuns.length - 1; index >= 0; index -= 1) {
+        const run = issueRuns[index];
+        if (!run || run.status !== "completed") {
+            continue;
+        }
+        const summary = extractLatestAssistantSummary(run);
+        if (summary?.trim()) {
+            return summary;
+        }
+    }
+    return undefined;
+}

package/dist/linear-session-sync.js

@@ -22,11 +22,11 @@ export class LinearSessionSync {
         if (issue.agentSessionId) {
             return issue;
         }
-        const recoveredAgentSessionId = this.db.findLatestAgentSessionIdForIssue(issue.linearIssueId);
+        const recoveredAgentSessionId = this.db.webhookEvents.findLatestAgentSessionIdForIssue(issue.linearIssueId);
         if (!recoveredAgentSessionId)
             return issue;
         this.logger.info({ issueKey: issue.issueKey, agentSessionId: recoveredAgentSessionId }, "Recovered missing Linear agent session id from webhook history");
-        return this.db.upsertIssue({
+        return this.db.issues.upsertIssue({
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             agentSessionId: recoveredAgentSessionId,
@@ -99,7 +99,7 @@ export class LinearSessionSync {
             currentLinearState: liveIssue.stateName,
             currentLinearStateType: liveIssue.stateType,
         })) {
-            this.db.upsertIssue({
+            this.db.issues.upsertIssue({
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
@@ -112,7 +112,7 @@ export class LinearSessionSync {
             return;
         const normalizedCurrent = liveIssue.stateName?.trim().toLowerCase();
         if (normalizedCurrent === targetState.trim().toLowerCase()) {
-            this.db.upsertIssue({
+            this.db.issues.upsertIssue({
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
@@ -121,7 +121,7 @@ export class LinearSessionSync {
             return;
         }
         const updated = await linear.setIssueState(issue.linearIssueId, targetState);
-        this.db.upsertIssue({
+        this.db.issues.upsertIssue({
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             ...(updated.stateName ? { currentLinearState: updated.stateName } : {}),
@@ -174,7 +174,7 @@ export class LinearSessionSync {
         if (now - lastEmit < PROGRESS_THROTTLE_MS)
             return;
         this.progressThrottle.set(run.id, now);
-        const issue = this.db.getIssue(run.projectId, run.linearIssueId);
+        const issue = this.db.issues.getIssue(run.projectId, run.linearIssueId);
         if (issue) {
             void this.emitActivity(issue, activity, { ephemeral: true });
         }
@@ -192,7 +192,7 @@ export class LinearSessionSync {
                 body,
             });
             if (result.id !== issue.statusCommentId) {
-                this.db.upsertIssue({
+                this.db.issues.upsertIssue({
                     projectId: issue.projectId,
                     linearIssueId: issue.linearIssueId,
                     statusCommentId: result.id,
@@ -229,9 +229,9 @@ function resolveProgressActivity(notification) {
     return undefined;
 }
 function renderStatusComment(db, issue, trackedIssue, options) {
-    const activeRun = issue.activeRunId ? db.getRun(issue.activeRunId) : undefined;
-    const latestRun = db.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
-    const latestEvent = db.listIssueSessionEvents(issue.projectId, issue.linearIssueId, { limit: 1 }).at(-1);
+    const activeRun = issue.activeRunId ? db.runs.getRunById(issue.activeRunId) : undefined;
+    const latestRun = db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
+    const latestEvent = db.issueSessions.listIssueSessionEvents(issue.projectId, issue.linearIssueId, { limit: 1 }).at(-1);
     const activeRunType = issue.activeRunId !== undefined
         ? (options?.activeRunType ?? activeRun?.runType)
         : undefined;

package/dist/queue-health-monitor.js

@@ -25,7 +25,7 @@ export class QueueHealthMonitor {
         this.feed = feed;
     }
     async reconcile() {
-        for (const issue of this.db.listAwaitingQueueIssues()) {
+        for (const issue of this.db.issues.listAwaitingQueueIssues()) {
             await this.probeQueuedIssue(issue);
         }
     }
@@ -68,7 +68,7 @@ export class QueueHealthMonitor {
         }
         this.probeFailureFeedTimes.delete(`${issue.projectId}::${issue.linearIssueId}`);
         if (pr.state === "MERGED") {
-            this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "merged" });
+            this.db.issues.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "merged" });
             this.advancer.advanceIdleIssue(issue, "done", { clearFailureProvenance: true });
             return;
         }
@@ -101,13 +101,13 @@ export class QueueHealthMonitor {
             if (isDuplicateProbe(issue, pendingRunContext)) {
                 return;
             }
-            this.db.upsertIssue({
+            this.db.issues.upsertIssue({
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 lastAttemptedFailureHeadSha: headRefOid,
                 lastAttemptedFailureSignature: signature,
             });
-            this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 eventType: "merge_steward_incident",
@@ -115,7 +115,7 @@ export class QueueHealthMonitor {
                 dedupeKey: `queue_health:queue_repair:${issue.linearIssueId}:${signature}`,
             });
             this.advancer.advanceIdleIssue(issue, "repairing_queue");
-            if (this.db.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
+            if (this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
                 this.advancer.enqueueIssue(issue.projectId, issue.linearIssueId);
             }
             this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, headRefOid, reason }, "Queue health: queue issue detected, dispatching repair");