patchrelay 0.36.11 → 0.36.13

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.36.11",
-  "commit": "ed9637ca51b3",
-  "builtAt": "2026-04-09T20:38:07.717Z"
+  "version": "0.36.13",
+  "commit": "e015f208d2a5",
+  "builtAt": "2026-04-10T03:05:43.066Z"
 }

package/dist/db.js

@@ -1,4 +1,4 @@
-import { isIssueSessionReadyForExecution, deriveIssueSessionState, deriveIssueSessionReactiveIntent, } from "./issue-session.js";
+import { deriveIssueSessionReactiveIntent, } from "./issue-session.js";
 import {} from "./issue-session-events.js";
 import { IssueStore } from "./db/issue-store.js";
 import { IssueSessionStore } from "./db/issue-session-store.js";
@@ -10,7 +10,7 @@ import { WebhookEventStore } from "./db/webhook-event-store.js";
 import { runPatchRelayMigrations } from "./db/migrations.js";
 import { SqliteConnection } from "./db/shared.js";
 import { syncIssueSessionFromIssue } from "./issue-session-projector.js";
-import { buildTrackedIssueRecord } from "./tracked-issue-projector.js";
+import { TrackedIssueQuery } from "./tracked-issue-query.js";
 function parseObjectJson(raw) {
     if (!raw)
         return undefined;
@@ -97,6 +97,7 @@ export class PatchRelayDatabase {
     issues;
     issueSessions;
     runs;
+    trackedIssues;
     constructor(databasePath, wal) {
         this.connection = new SqliteConnection(databasePath);
         this.connection.pragma("foreign_keys = ON");
@@ -117,6 +118,7 @@ export class PatchRelayDatabase {
             ...(options ? { options } : {}),
         }));
         this.issueSessions = new IssueSessionStore(this.connection, mapIssueSessionRow, mapIssueSessionEventRow, this.issues, this.runs, deriveImplicitReactiveWake);
+        this.trackedIssues = new TrackedIssueQuery(this.issues, this.issueSessions, this.runs);
     }
     runMigrations() {
         runPatchRelayMigrations(this.connection);
@@ -161,27 +163,7 @@ export class PatchRelayDatabase {
         return this.issues.countUnresolvedBlockers(projectId, linearIssueId);
     }
     listIssuesReadyForExecution() {
-        return this.issues.listIssues()
-            .filter((issue) => isIssueSessionReadyForExecution({
-            factoryState: issue.factoryState,
-            sessionState: deriveIssueSessionState({
-                activeRunId: issue.activeRunId,
-                factoryState: issue.factoryState,
-            }),
-            activeRunId: issue.activeRunId,
-            blockedByCount: this.issues.countUnresolvedBlockers(issue.projectId, issue.linearIssueId),
-            hasPendingWake: this.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId) !== undefined,
-            hasLegacyPendingRun: issue.pendingRunType !== undefined,
-            prNumber: issue.prNumber,
-            prState: issue.prState,
-            prReviewState: issue.prReviewState,
-            prCheckStatus: issue.prCheckStatus,
-            latestFailureSource: issue.lastGitHubFailureSource,
-        }))
-            .map((issue) => ({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-        }));
+        return this.trackedIssues.listIssuesReadyForExecution();
     }
     /**
      * Issues idle in pr_open with no active run — candidates for state
@@ -205,26 +187,17 @@ export class PatchRelayDatabase {
         return this.issues.listAwaitingQueueIssues();
     }
     listIssuesByState(projectId, state) {
-        return this.issues.listIssuesByState(projectId, state);
+        return this.trackedIssues.listIssuesByState(projectId, state);
     }
     // ─── View builders ──────────────────────────────────────────────
     issueToTrackedIssue(issue) {
-        return buildTrackedIssueRecord({
-            issue,
-            session: this.issueSessions.getIssueSession(issue.projectId, issue.linearIssueId),
-            blockedBy: this.issues.listIssueDependencies(issue.projectId, issue.linearIssueId),
-            hasPendingWake: this.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId) !== undefined,
-            latestRun: this.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId),
-            latestEvent: this.issueSessions.listIssueSessionEvents(issue.projectId, issue.linearIssueId, { limit: 1 }).at(-1),
-        });
+        return this.trackedIssues.issueToTrackedIssue(issue);
     }
     getTrackedIssue(projectId, linearIssueId) {
-        const issue = this.getIssue(projectId, linearIssueId);
-        return issue ? this.issueToTrackedIssue(issue) : undefined;
+        return this.trackedIssues.getTrackedIssue(projectId, linearIssueId);
     }
     getTrackedIssueByKey(issueKey) {
-        const issue = this.getIssueByKey(issueKey);
-        return issue ? this.issueToTrackedIssue(issue) : undefined;
+        return this.trackedIssues.getTrackedIssueByKey(issueKey);
     }
     listIssues() {
         return this.issues.listIssues();
@@ -234,15 +207,7 @@ export class PatchRelayDatabase {
     }
     // ─── Issue overview for query service ─────────────────────────────
     getIssueOverview(issueKey) {
-        const issue = this.getIssueByKey(issueKey);
-        if (!issue)
-            return undefined;
-        const tracked = this.issueToTrackedIssue(issue);
-        const activeRun = issue.activeRunId ? this.runs.getRunById(issue.activeRunId) : undefined;
-        return {
-            issue: tracked,
-            ...(activeRun ? { activeRun } : {}),
-        };
+        return this.trackedIssues.getIssueOverview(issueKey);
     }
 }
 // ─── Row mappers ──────────────────────────────────────────────────

package/dist/implementation-outcome-policy.js

@@ -0,0 +1,127 @@
+import { execCommand } from "./utils.js";
+import { resolveImplementationDeliveryMode, } from "./prompting/patchrelay.js";
+export class ImplementationOutcomePolicy {
+    config;
+    db;
+    logger;
+    withHeldLease;
+    constructor(config, db, logger, withHeldLease) {
+        this.config = config;
+        this.db = db;
+        this.logger = logger;
+        this.withHeldLease = withHeldLease;
+    }
+    async verifyPublishedRunOutcome(run, issue) {
+        if (run.runType !== "implementation") {
+            return undefined;
+        }
+        const project = this.config.projects.find((entry) => entry.id === run.projectId);
+        const baseBranch = project?.github?.baseBranch ?? "main";
+        const deliveryMode = resolveImplementationDeliveryMode(issue, undefined, run.promptText);
+        if (deliveryMode === "linear_only") {
+            if (issue.prNumber !== undefined) {
+                return `Planning-only implementation should not open a PR, but PR #${issue.prNumber} was observed`;
+            }
+            return this.describeLocalImplementationOutcome(issue, baseBranch, deliveryMode);
+        }
+        if (issue.prNumber && issue.prState && issue.prState !== "closed") {
+            return undefined;
+        }
+        if (project?.github?.repoFullName && issue.branchName) {
+            try {
+                const { stdout, exitCode } = await execCommand("gh", [
+                    "pr",
+                    "list",
+                    "--repo",
+                    project.github.repoFullName,
+                    "--head",
+                    issue.branchName,
+                    "--state",
+                    "all",
+                    "--json",
+                    "number,url,state,author,headRefOid",
+                ], { timeoutMs: 10_000 });
+                if (exitCode === 0) {
+                    const matches = JSON.parse(stdout);
+                    const pr = matches[0];
+                    if (pr?.number) {
+                        this.upsertIssueIfLeaseHeld(issue.projectId, issue.linearIssueId, {
+                            projectId: issue.projectId,
+                            linearIssueId: issue.linearIssueId,
+                            prNumber: pr.number,
+                            ...(pr.url ? { prUrl: pr.url } : {}),
+                            ...(pr.state ? { prState: pr.state.toLowerCase() } : {}),
+                            ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
+                            ...(pr.author?.login ? { prAuthorLogin: pr.author.login } : {}),
+                        }, "published PR verification refresh");
+                        return undefined;
+                    }
+                }
+            }
+            catch (error) {
+                this.logger.debug({
+                    issueKey: issue.issueKey,
+                    branchName: issue.branchName,
+                    repoFullName: project.github.repoFullName,
+                    error: error instanceof Error ? error.message : String(error),
+                }, "Failed to verify published PR state after implementation");
+            }
+        }
+        const details = await this.describeLocalImplementationOutcome(issue, baseBranch, deliveryMode);
+        return details ?? `Implementation completed without opening a PR for branch ${issue.branchName ?? issue.linearIssueId}`;
+    }
+    upsertIssueIfLeaseHeld(projectId, linearIssueId, params, context) {
+        const updated = this.withHeldLease(projectId, linearIssueId, (lease) => this.db.issueSessions.upsertIssueWithLease(lease, params));
+        if (updated === undefined) {
+            this.logger.warn({ projectId, linearIssueId, context }, "Skipping issue write after losing issue-session lease");
+        }
+        return updated;
+    }
+    async describeLocalImplementationOutcome(issue, baseBranch, deliveryMode = "publish_pr") {
+        if (!issue.worktreePath) {
+            return undefined;
+        }
+        try {
+            const status = await execCommand(this.config.runner.gitBin, [
+                "-C",
+                issue.worktreePath,
+                "status",
+                "--short",
+            ], { timeoutMs: 10_000 });
+            const dirtyEntries = status.exitCode === 0
+                ? status.stdout.split("\n").map((line) => line.trim()).filter(Boolean)
+                : [];
+            if (dirtyEntries.length > 0) {
+                if (deliveryMode === "linear_only") {
+                    return `Planning-only implementation should not modify the repo; worktree still has ${dirtyEntries.length} uncommitted change(s)`;
+                }
+                return `Implementation completed without opening a PR; worktree still has ${dirtyEntries.length} uncommitted change(s)`;
+            }
+        }
+        catch {
+            // Best effort only.
+        }
+        try {
+            const ahead = await execCommand(this.config.runner.gitBin, [
+                "-C",
+                issue.worktreePath,
+                "rev-list",
+                "--count",
+                `origin/${baseBranch}..HEAD`,
+            ], { timeoutMs: 10_000 });
+            if (ahead.exitCode === 0) {
+                const count = Number(ahead.stdout.trim());
+                if (Number.isFinite(count) && count > 0) {
+                    if (deliveryMode === "linear_only") {
+                        return `Planning-only implementation should not create repo commits; worktree is ${count} local commit(s) ahead of origin/${baseBranch}`;
+                    }
+                    return `Implementation completed with ${count} local commit(s) ahead of origin/${baseBranch} but no PR was observed`;
+                }
+            }
+        }
+        catch {
+            // Best effort only.
+        }
+        return undefined;
+    }
+}

package/dist/issue-overview-query.js

@@ -0,0 +1,232 @@
+import { parseGitHubFailureContext } from "./github-failure-context.js";
+import { isIssueSessionReadyForExecution } from "./issue-session.js";
+import { deriveIssueStatusNote } from "./status-note.js";
+import { derivePatchRelayWaitingReason } from "./waiting-reason.js";
+export function parseStageReport(reportJson, runStatus) {
+    if (!reportJson)
+        return undefined;
+    try {
+        const parsed = JSON.parse(reportJson);
+        return { ...parsed, status: runStatus };
+    }
+    catch {
+        return undefined;
+    }
+}
+export class IssueOverviewQuery {
+    db;
+    codex;
+    runStatusProvider;
+    constructor(db, codex, runStatusProvider) {
+        this.db = db;
+        this.codex = codex;
+        this.runStatusProvider = runStatusProvider;
+    }
+    async getIssueOverview(issueKey) {
+        const session = this.db.issueSessions.getIssueSessionByKey(issueKey);
+        if (!session) {
+            return await this.getLegacyIssueOverview(issueKey);
+        }
+        return await this.getSessionIssueOverview(issueKey, session);
+    }
+    buildRuns(projectId, linearIssueId) {
+        return this.db.runs.listRunsForIssue(projectId, linearIssueId).map((run) => ({
+            id: run.id,
+            runType: run.runType,
+            status: run.status,
+            startedAt: run.startedAt,
+            ...(run.endedAt ? { endedAt: run.endedAt } : {}),
+            ...(run.threadId ? { threadId: run.threadId } : {}),
+            ...(() => {
+                const report = parseStageReport(run.reportJson, run.status);
+                return report ? { report } : {};
+            })(),
+            ...(() => {
+                const events = this.db.runs.listThreadEvents(run.id).flatMap((event) => {
+                    try {
+                        const parsed = JSON.parse(event.eventJson);
+                        return [{
+                                id: event.id,
+                                method: event.method,
+                                createdAt: event.createdAt,
+                                ...(parsed && typeof parsed === "object" && !Array.isArray(parsed)
+                                    ? { parsedEvent: parsed }
+                                    : {}),
+                            }];
+                    }
+                    catch {
+                        return [{
+                                id: event.id,
+                                method: event.method,
+                                createdAt: event.createdAt,
+                            }];
+                    }
+                });
+                return events.length > 0 ? { events } : {};
+            })(),
+        }));
+    }
+    async getLegacyIssueOverview(issueKey) {
+        const legacy = this.db.getIssueOverview(issueKey);
+        if (!legacy)
+            return undefined;
+        const issueRecord = this.db.issues.getIssueByKey(issueKey);
+        const activeStatus = await this.runStatusProvider.getActiveRunStatus(issueKey);
+        const activeRun = activeStatus?.run ?? legacy.activeRun;
+        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);
+        const statusNote = issueRecord
+            ? deriveIssueStatusNote({
+                issue: issueRecord,
+                latestRun,
+                latestEvent,
+                failureSummary: legacy.issue.latestFailureSummary,
+                blockedByKeys: legacy.issue.blockedByKeys,
+                waitingReason: legacy.issue.waitingReason,
+            })
+            : legacy.issue.statusNote;
+        return {
+            issue: {
+                ...legacy.issue,
+                ...(statusNote ? { statusNote } : {}),
+            },
+            ...(activeRun ? { activeRun } : {}),
+            ...(latestRun ? { latestRun } : {}),
+            ...(liveThread ? { liveThread } : {}),
+            ...(runs.length > 0 ? { runs } : {}),
+            ...(issueRecord
+                ? {
+                    issueContext: {
+                        ...(issueRecord.description ? { description: issueRecord.description } : {}),
+                        ...(issueRecord.currentLinearState ? { currentLinearState: issueRecord.currentLinearState } : {}),
+                        ...(issueRecord.url ? { issueUrl: issueRecord.url } : {}),
+                        ...(issueRecord.worktreePath ? { worktreePath: issueRecord.worktreePath } : {}),
+                        ...(issueRecord.branchName ? { branchName: issueRecord.branchName } : {}),
+                        ...(issueRecord.prUrl ? { prUrl: issueRecord.prUrl } : {}),
+                        ...(issueRecord.priority != null ? { priority: issueRecord.priority } : {}),
+                        ...(issueRecord.estimate != null ? { estimate: issueRecord.estimate } : {}),
+                        ciRepairAttempts: issueRecord.ciRepairAttempts,
+                        queueRepairAttempts: issueRecord.queueRepairAttempts,
+                        reviewFixAttempts: issueRecord.reviewFixAttempts,
+                        ...(legacy.issue.latestFailureSource ? { latestFailureSource: legacy.issue.latestFailureSource } : {}),
+                        ...(legacy.issue.latestFailureHeadSha ? { latestFailureHeadSha: legacy.issue.latestFailureHeadSha } : {}),
+                        ...(legacy.issue.latestFailureCheckName ? { latestFailureCheckName: legacy.issue.latestFailureCheckName } : {}),
+                        ...(legacy.issue.latestFailureStepName ? { latestFailureStepName: legacy.issue.latestFailureStepName } : {}),
+                        ...(legacy.issue.latestFailureSummary ? { latestFailureSummary: legacy.issue.latestFailureSummary } : {}),
+                        runCount,
+                    },
+                }
+                : {}),
+        };
+    }
+    async getSessionIssueOverview(issueKey, session) {
+        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.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);
+        const failureContext = parseGitHubFailureContext(issueRecord?.lastGitHubFailureContextJson);
+        const waitingReason = session.waitingReason ?? derivePatchRelayWaitingReason({
+            ...(activeRun ? { activeRunType: activeRun.runType } : {}),
+            blockedByKeys,
+            factoryState: issueRecord?.factoryState ?? "delegated",
+            pendingRunType: issueRecord?.pendingRunType,
+            prNumber: session.prNumber,
+            prHeadSha: issueRecord?.prHeadSha ?? session.prHeadSha,
+            prReviewState: issueRecord?.prReviewState,
+            prCheckStatus: issueRecord?.prCheckStatus,
+            lastBlockingReviewHeadSha: issueRecord?.lastBlockingReviewHeadSha,
+            latestFailureCheckName: issueRecord?.lastGitHubFailureCheckName,
+        });
+        const issue = {
+            id: issueRecord?.id ?? session.id,
+            projectId: session.projectId,
+            linearIssueId: session.linearIssueId,
+            ...(session.issueKey ? { issueKey: session.issueKey } : {}),
+            ...(issueRecord?.title ? { title: issueRecord.title } : {}),
+            ...(issueRecord?.url ? { issueUrl: issueRecord.url } : {}),
+            ...(issueRecord?.currentLinearState ? { currentLinearState: issueRecord.currentLinearState } : {}),
+            sessionState: session.sessionState,
+            factoryState: issueRecord?.factoryState ?? "delegated",
+            blockedByCount: unresolvedBlockedBy.length,
+            blockedByKeys,
+            readyForExecution: isIssueSessionReadyForExecution({
+                sessionState: session.sessionState,
+                factoryState: issueRecord?.factoryState ?? "delegated",
+                ...(activeRun ? { activeRunId: activeRun.id } : {}),
+                blockedByCount: unresolvedBlockedBy.length,
+                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 } : {}),
+                ...(issueRecord?.prReviewState ? { prReviewState: issueRecord.prReviewState } : {}),
+                ...(issueRecord?.prCheckStatus ? { prCheckStatus: issueRecord.prCheckStatus } : {}),
+                ...(issueRecord?.lastGitHubFailureSource ? { latestFailureSource: issueRecord.lastGitHubFailureSource } : {}),
+            }),
+            ...(issueRecord?.lastGitHubFailureSource ? { latestFailureSource: issueRecord.lastGitHubFailureSource } : {}),
+            ...(issueRecord?.lastGitHubFailureHeadSha ? { latestFailureHeadSha: issueRecord.lastGitHubFailureHeadSha } : {}),
+            ...(issueRecord?.lastGitHubFailureCheckName ? { latestFailureCheckName: issueRecord.lastGitHubFailureCheckName } : {}),
+            ...(() => {
+                const statusNote = issueRecord
+                    ? deriveIssueStatusNote({
+                        issue: issueRecord,
+                        sessionSummary: session.summaryText,
+                        latestRun,
+                        latestEvent,
+                        failureSummary: failureContext?.summary,
+                        blockedByKeys,
+                        waitingReason,
+                    })
+                    : undefined;
+                return statusNote ? { statusNote } : {};
+            })(),
+            ...(waitingReason ? { waitingReason } : {}),
+            ...(activeRun ? { activeRunId: activeRun.id } : {}),
+            ...(issueRecord?.agentSessionId ? { activeAgentSessionId: issueRecord.agentSessionId } : {}),
+            updatedAt: session.updatedAt,
+        };
+        return {
+            issue,
+            session,
+            ...(activeRun ? { activeRun } : {}),
+            ...(latestRun ? { latestRun } : {}),
+            ...(liveThread ? { liveThread } : {}),
+            ...(runs.length > 0 ? { runs } : {}),
+            issueContext: {
+                ...(issueRecord?.description ? { description: issueRecord.description } : {}),
+                ...(issueRecord?.currentLinearState ? { currentLinearState: issueRecord.currentLinearState } : {}),
+                ...(issueRecord?.url ? { issueUrl: issueRecord.url } : {}),
+                ...(session.worktreePath ? { worktreePath: session.worktreePath } : {}),
+                ...(session.branchName ? { branchName: session.branchName } : {}),
+                ...(issueRecord?.prUrl ? { prUrl: issueRecord.prUrl } : {}),
+                ...(issueRecord?.priority != null ? { priority: issueRecord.priority } : {}),
+                ...(issueRecord?.estimate != null ? { estimate: issueRecord.estimate } : {}),
+                ciRepairAttempts: issueRecord?.ciRepairAttempts ?? session.ciRepairAttempts,
+                queueRepairAttempts: issueRecord?.queueRepairAttempts ?? session.queueRepairAttempts,
+                reviewFixAttempts: issueRecord?.reviewFixAttempts ?? session.reviewFixAttempts,
+                ...(issue.latestFailureSource ? { latestFailureSource: issue.latestFailureSource } : {}),
+                ...(issue.latestFailureHeadSha ? { latestFailureHeadSha: issue.latestFailureHeadSha } : {}),
+                ...(issue.latestFailureCheckName ? { latestFailureCheckName: issue.latestFailureCheckName } : {}),
+                ...(issue.latestFailureStepName ? { latestFailureStepName: issue.latestFailureStepName } : {}),
+                ...(issue.latestFailureSummary ? { latestFailureSummary: issue.latestFailureSummary } : {}),
+                runCount,
+            },
+        };
+    }
+    async readLiveThread(run) {
+        if (!run?.threadId)
+            return undefined;
+        return await this.codex.readThread(run.threadId, true).catch(() => undefined);
+    }
+}