patchrelay 0.35.6 → 0.35.8

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.35.6",
-  "commit": "724dfad4eb3b",
-  "builtAt": "2026-04-03T11:34:35.008Z"
+  "version": "0.35.8",
+  "commit": "727fa6d1f476",
+  "builtAt": "2026-04-03T23:33:50.106Z"
 }

package/dist/idle-reconciliation.js

@@ -0,0 +1,262 @@
+import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
+import { parseGitHubFailureContext } from "./github-failure-context.js";
+import { parseStoredQueueRepairContext } from "./merge-queue-incident.js";
+import { execCommand } from "./utils.js";
+function isDuplicateRepairAttempt(issue, context) {
+    const signature = typeof context?.failureSignature === "string" ? context.failureSignature : undefined;
+    const headSha = typeof context?.failureHeadSha === "string"
+        ? context.failureHeadSha
+        : typeof context?.headSha === "string" ? context.headSha : undefined;
+    if (!signature)
+        return false;
+    return issue.lastAttemptedFailureSignature === signature
+        && (headSha === undefined || issue.lastAttemptedFailureHeadSha === headSha);
+}
+function buildFailureContext(issue) {
+    const storedFailureContext = parseGitHubFailureContext(issue.lastGitHubFailureContextJson);
+    const queueRepairContext = issue.lastQueueIncidentJson
+        ? parseStoredQueueRepairContext(issue.lastQueueIncidentJson)
+        : undefined;
+    if (!queueRepairContext
+        && !issue.lastGitHubFailureSource
+        && !issue.lastGitHubFailureHeadSha
+        && !issue.lastGitHubFailureSignature
+        && !issue.lastGitHubFailureCheckName
+        && !issue.lastGitHubFailureCheckUrl
+        && !storedFailureContext) {
+        return undefined;
+    }
+    return {
+        ...(issue.lastGitHubFailureSource ? { failureReason: issue.lastGitHubFailureSource } : {}),
+        ...(issue.lastGitHubFailureHeadSha ? { failureHeadSha: issue.lastGitHubFailureHeadSha } : {}),
+        ...(issue.lastGitHubFailureSignature ? { failureSignature: issue.lastGitHubFailureSignature } : {}),
+        ...(issue.lastGitHubFailureCheckName ? { checkName: issue.lastGitHubFailureCheckName } : {}),
+        ...(issue.lastGitHubFailureCheckUrl ? { checkUrl: issue.lastGitHubFailureCheckUrl } : {}),
+        ...(storedFailureContext ? storedFailureContext : {}),
+        ...(queueRepairContext ? queueRepairContext : {}),
+    };
+}
+export function resolveBranchOwnerForStateTransition(newState, pendingRunType) {
+    if (pendingRunType)
+        return "patchrelay";
+    if (newState === "awaiting_queue")
+        return "merge_steward";
+    if (newState === "repairing_ci" || newState === "repairing_queue")
+        return "patchrelay";
+    return undefined;
+}
+export class IdleIssueReconciler {
+    db;
+    config;
+    deps;
+    logger;
+    feed;
+    constructor(db, config, deps, logger, feed) {
+        this.db = db;
+        this.config = config;
+        this.deps = deps;
+        this.logger = logger;
+        this.feed = feed;
+    }
+    async reconcile() {
+        for (const issue of this.db.listIdleNonTerminalIssues()) {
+            if (issue.prState === "merged") {
+                this.advanceIdleIssue(issue, "done", { clearFailureProvenance: true });
+                continue;
+            }
+            if (issue.prReviewState === "approved" && issue.prCheckStatus !== "failed") {
+                if (issue.factoryState !== "awaiting_queue" || issue.branchOwner !== "merge_steward") {
+                    this.advanceIdleIssue(issue, "awaiting_queue", { clearFailureProvenance: true });
+                }
+                else if (!issue.queueLabelApplied) {
+                    await this.deps.requestMergeQueueAdmission(issue, issue.projectId);
+                }
+                continue;
+            }
+            if (issue.prCheckStatus === "failed") {
+                await this.routeFailedIssue(issue);
+                continue;
+            }
+            // Probe GitHub for stale pr_open issues: detect missed reviews,
+            // merge conflicts, and other state that webhooks may have missed.
+            if (issue.factoryState === "pr_open") {
+                await this.reconcileFromGitHub(issue);
+            }
+        }
+        for (const issue of this.db.listBlockedDelegatedIssues()) {
+            const unresolved = this.db.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
+            if (unresolved === 0) {
+                this.db.upsertIssue({
+                    projectId: issue.projectId,
+                    linearIssueId: issue.linearIssueId,
+                    pendingRunType: "implementation",
+                });
+                this.deps.enqueueIssue(issue.projectId, issue.linearIssueId);
+            }
+        }
+    }
+    advanceIdleIssue(issue, newState, options) {
+        if (issue.factoryState === newState && !options?.pendingRunType && !options?.clearFailureProvenance) {
+            return;
+        }
+        this.logger.info({ issueKey: issue.issueKey, from: issue.factoryState, to: newState, pendingRunType: options?.pendingRunType }, "Reconciliation: advancing idle issue");
+        const resetQueueLabel = newState === "awaiting_queue" || issue.factoryState === "awaiting_queue";
+        this.db.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            factoryState: newState,
+            ...(options?.pendingRunType ? { pendingRunType: options.pendingRunType } : {}),
+            ...(options?.pendingRunType
+                ? {
+                    pendingRunContextJson: options.pendingRunContext ? JSON.stringify(options.pendingRunContext) : null,
+                }
+                : {}),
+            ...(resetQueueLabel ? { queueLabelApplied: false } : {}),
+            ...(options?.clearFailureProvenance
+                ? {
+                    lastGitHubFailureSource: null,
+                    lastGitHubFailureHeadSha: null,
+                    lastGitHubFailureSignature: null,
+                    lastGitHubFailureCheckName: null,
+                    lastGitHubFailureCheckUrl: null,
+                    lastGitHubFailureContextJson: null,
+                    lastGitHubFailureAt: null,
+                    lastQueueIncidentJson: null,
+                    lastAttemptedFailureHeadSha: null,
+                    lastAttemptedFailureSignature: null,
+                }
+                : {}),
+        });
+        const branchOwner = resolveBranchOwnerForStateTransition(newState, options?.pendingRunType);
+        if (branchOwner) {
+            this.db.setBranchOwner(issue.projectId, issue.linearIssueId, branchOwner);
+        }
+        this.feed?.publish({
+            level: "info",
+            kind: "stage",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: newState,
+            status: "reconciled",
+            summary: `Reconciliation: ${issue.factoryState} \u2192 ${newState}`,
+        });
+        if (newState === "awaiting_queue" && issue.factoryState !== "awaiting_queue") {
+            void this.deps.requestMergeQueueAdmission(issue, issue.projectId);
+        }
+        if (options?.pendingRunType) {
+            this.deps.enqueueIssue(issue.projectId, issue.linearIssueId);
+        }
+    }
+    async routeFailedIssue(issue) {
+        if (issue.lastGitHubFailureSource === "queue_eviction") {
+            const pendingRunContext = buildFailureContext(issue);
+            if (isDuplicateRepairAttempt(issue, pendingRunContext)) {
+                this.advanceIdleIssue(issue, "repairing_queue");
+            }
+            else {
+                this.advanceIdleIssue(issue, "repairing_queue", {
+                    pendingRunType: "queue_repair",
+                    ...(pendingRunContext ? { pendingRunContext } : {}),
+                });
+            }
+            return;
+        }
+        if (issue.lastGitHubFailureSource === "branch_ci") {
+            const pendingRunContext = buildFailureContext(issue);
+            if (isDuplicateRepairAttempt(issue, pendingRunContext)) {
+                this.advanceIdleIssue(issue, "repairing_ci");
+            }
+            else {
+                this.advanceIdleIssue(issue, "repairing_ci", {
+                    pendingRunType: "ci_repair",
+                    ...(pendingRunContext ? { pendingRunContext } : {}),
+                });
+            }
+            return;
+        }
+        if (issue.factoryState === "awaiting_queue") {
+            const inferProject = this.config.projects.find((p) => p.id === issue.projectId);
+            const inferProtocol = resolveMergeQueueProtocol(inferProject);
+            let inferred = "branch_ci";
+            const probeSha = issue.lastGitHubFailureHeadSha ?? issue.lastGitHubCiSnapshotHeadSha;
+            if (inferProject?.github?.repoFullName && issue.prNumber && probeSha) {
+                try {
+                    const { stdout } = await execCommand("gh", [
+                        "api",
+                        `repos/${inferProject.github.repoFullName}/commits/${probeSha}/check-runs`,
+                        "--jq", `.check_runs[] | select(.name == "${inferProtocol.evictionCheckName}" and .conclusion == "failure") | .name`,
+                    ], { timeoutMs: 10_000 });
+                    if (stdout.trim().length > 0)
+                        inferred = "queue_eviction";
+                }
+                catch { /* best effort */ }
+            }
+            const inferRunType = inferred === "queue_eviction" ? "queue_repair" : "ci_repair";
+            const inferState = inferred === "queue_eviction" ? "repairing_queue" : "repairing_ci";
+            this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, inferred }, "Inferred failure provenance for awaiting_queue issue");
+            const pendingRunContext = buildFailureContext(issue);
+            this.advanceIdleIssue(issue, inferState, {
+                pendingRunType: inferRunType,
+                ...(pendingRunContext ? { pendingRunContext } : {}),
+            });
+            return;
+        }
+        const pendingRunContext = buildFailureContext(issue);
+        if (isDuplicateRepairAttempt(issue, pendingRunContext)) {
+            this.advanceIdleIssue(issue, "repairing_ci");
+        }
+        else {
+            this.advanceIdleIssue(issue, "repairing_ci", {
+                pendingRunType: "ci_repair",
+                ...(pendingRunContext ? { pendingRunContext } : {}),
+            });
+        }
+    }
+    async reconcileFromGitHub(issue) {
+        const project = this.config.projects.find((p) => p.id === issue.projectId);
+        if (!project?.github?.repoFullName || !issue.prNumber)
+            return;
+        try {
+            const { stdout } = await execCommand("gh", [
+                "pr", "view", String(issue.prNumber),
+                "--repo", project.github.repoFullName,
+                "--json", "state,reviewDecision,mergeable,mergeStateStatus",
+            ], { timeoutMs: 10_000 });
+            const pr = JSON.parse(stdout);
+            if (pr.state === "MERGED") {
+                this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "merged" });
+                this.advanceIdleIssue(issue, "done", { clearFailureProvenance: true });
+                return;
+            }
+            if (pr.reviewDecision === "APPROVED") {
+                this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prReviewState: "approved" });
+                this.advanceIdleIssue(issue, "awaiting_queue", { clearFailureProvenance: true });
+                return;
+            }
+            // Merge conflict detected — dispatch a repair run to rebase the branch.
+            if (pr.mergeable === "CONFLICTING" || pr.mergeStateStatus === "DIRTY") {
+                this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, mergeable: pr.mergeable }, "Reconciliation: PR has merge conflicts, dispatching rebase");
+                this.advanceIdleIssue(issue, "repairing_queue", {
+                    pendingRunType: "queue_repair",
+                    pendingRunContext: {
+                        source: "idle_reconciliation",
+                        failureReason: "merge_conflict_detected",
+                        failureSignature: `conflict:${issue.prNumber}`,
+                    },
+                });
+                this.feed?.publish({
+                    level: "warn",
+                    kind: "github",
+                    issueKey: issue.issueKey,
+                    projectId: issue.projectId,
+                    stage: "repairing_queue",
+                    status: "conflict_detected",
+                    summary: `PR #${issue.prNumber} has merge conflicts with main, dispatching rebase`,
+                });
+            }
+        }
+        catch (error) {
+            this.logger.debug({ issueKey: issue.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to query GitHub PR state during reconciliation");
+        }
+    }
+}

package/dist/linear-session-sync.js

@@ -0,0 +1,143 @@
+import { buildAgentSessionPlanForIssue } from "./agent-session-plan.js";
+import { buildAgentSessionExternalUrls } from "./agent-session-presentation.js";
+const PROGRESS_THROTTLE_MS = 5_000;
+export class LinearSessionSync {
+    config;
+    db;
+    linearProvider;
+    logger;
+    feed;
+    progressThrottle = new Map();
+    constructor(config, db, linearProvider, logger, feed) {
+        this.config = config;
+        this.db = db;
+        this.linearProvider = linearProvider;
+        this.logger = logger;
+        this.feed = feed;
+    }
+    async emitActivity(issue, content, options) {
+        if (!issue.agentSessionId)
+            return;
+        try {
+            const linear = await this.linearProvider.forProject(issue.projectId);
+            if (!linear)
+                return;
+            const allowEphemeral = content.type === "thought" || content.type === "action";
+            await linear.createAgentActivity({
+                agentSessionId: issue.agentSessionId,
+                content,
+                ...(options?.ephemeral && allowEphemeral ? { ephemeral: true } : {}),
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger.warn({ issueKey: issue.issueKey, type: content.type, error: msg }, "Failed to emit Linear activity");
+            this.feed?.publish({
+                level: "warn",
+                kind: "linear",
+                issueKey: issue.issueKey,
+                projectId: issue.projectId,
+                status: "linear_error",
+                summary: `Linear activity failed: ${msg}`,
+            });
+        }
+    }
+    async syncSession(issue, options) {
+        if (!issue.agentSessionId)
+            return;
+        try {
+            const linear = await this.linearProvider.forProject(issue.projectId);
+            if (!linear?.updateAgentSession)
+                return;
+            const externalUrls = buildAgentSessionExternalUrls(this.config, {
+                ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+                ...(issue.prUrl ? { prUrl: issue.prUrl } : {}),
+            });
+            await linear.updateAgentSession({
+                agentSessionId: issue.agentSessionId,
+                plan: buildAgentSessionPlanForIssue(issue, options),
+                ...(externalUrls ? { externalUrls } : {}),
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger.warn({ issueKey: issue.issueKey, error: msg }, "Failed to update Linear plan");
+        }
+    }
+    async syncCodexPlan(issue, params) {
+        if (!issue.agentSessionId)
+            return;
+        const plan = params.plan;
+        if (!Array.isArray(plan))
+            return;
+        const STATUS_MAP = {
+            pending: "pending",
+            inProgress: "inProgress",
+            completed: "completed",
+        };
+        const steps = plan.map((entry) => {
+            const e = entry;
+            const step = typeof e.step === "string" ? e.step : String(e.step ?? "");
+            const status = typeof e.status === "string" ? (STATUS_MAP[e.status] ?? "pending") : "pending";
+            return { content: step, status };
+        });
+        const fullPlan = [
+            { content: "Prepare workspace", status: "completed" },
+            ...steps,
+            { content: "Merge", status: "pending" },
+        ];
+        try {
+            const linear = await this.linearProvider.forProject(issue.projectId);
+            if (!linear?.updateAgentSession)
+                return;
+            await linear.updateAgentSession({
+                agentSessionId: issue.agentSessionId,
+                plan: fullPlan,
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger.warn({ issueKey: issue.issueKey, error: msg }, "Failed to sync codex plan to Linear");
+        }
+    }
+    maybeEmitProgress(notification, run) {
+        const activity = resolveProgressActivity(notification);
+        if (!activity)
+            return;
+        const now = Date.now();
+        const lastEmit = this.progressThrottle.get(run.id) ?? 0;
+        if (now - lastEmit < PROGRESS_THROTTLE_MS)
+            return;
+        this.progressThrottle.set(run.id, now);
+        const issue = this.db.getIssue(run.projectId, run.linearIssueId);
+        if (issue) {
+            void this.emitActivity(issue, activity, { ephemeral: true });
+        }
+    }
+    clearProgress(runId) {
+        this.progressThrottle.delete(runId);
+    }
+}
+function resolveProgressActivity(notification) {
+    if (notification.method === "item/started") {
+        const item = notification.params.item;
+        if (!item)
+            return undefined;
+        const type = typeof item.type === "string" ? item.type : undefined;
+        if (type === "commandExecution") {
+            const cmd = item.command;
+            const cmdStr = Array.isArray(cmd) ? cmd.join(" ") : typeof cmd === "string" ? cmd : undefined;
+            return { type: "action", action: "Running", parameter: cmdStr?.slice(0, 120) ?? "command" };
+        }
+        if (type === "mcpToolCall") {
+            const server = typeof item.server === "string" ? item.server : "";
+            const tool = typeof item.tool === "string" ? item.tool : "";
+            return { type: "action", action: "Using", parameter: `${server}/${tool}` };
+        }
+        if (type === "dynamicToolCall") {
+            const tool = typeof item.tool === "string" ? item.tool : "tool";
+            return { type: "action", action: "Using", parameter: tool };
+        }
+    }
+    return undefined;
+}

package/dist/queue-health-monitor.js

@@ -0,0 +1,131 @@
+import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
+import { execCommand } from "./utils.js";
+const QUEUE_HEALTH_GRACE_MS = 120_000;
+const QUEUE_HEALTH_PROBE_FAILURE_COOLDOWN_MS = 300_000;
+function isDuplicateProbe(issue, context) {
+    const signature = typeof context?.failureSignature === "string" ? context.failureSignature : undefined;
+    const headSha = typeof context?.failureHeadSha === "string" ? context.failureHeadSha : undefined;
+    if (!signature)
+        return false;
+    return issue.lastAttemptedFailureSignature === signature
+        && (headSha === undefined || issue.lastAttemptedFailureHeadSha === headSha);
+}
+export class QueueHealthMonitor {
+    db;
+    config;
+    advancer;
+    logger;
+    feed;
+    probeFailureFeedTimes = new Map();
+    constructor(db, config, advancer, logger, feed) {
+        this.db = db;
+        this.config = config;
+        this.advancer = advancer;
+        this.logger = logger;
+        this.feed = feed;
+    }
+    async reconcile() {
+        for (const issue of this.db.listAwaitingQueueIssues()) {
+            await this.probeQueuedIssue(issue);
+        }
+    }
+    async probeQueuedIssue(issue) {
+        if (!issue.prNumber)
+            return;
+        const project = this.config.projects.find((p) => p.id === issue.projectId);
+        if (!project?.github?.repoFullName)
+            return;
+        const age = Date.now() - Date.parse(issue.updatedAt);
+        if (age < QUEUE_HEALTH_GRACE_MS)
+            return;
+        const protocol = resolveMergeQueueProtocol(project);
+        let pr;
+        try {
+            const { stdout } = await execCommand("gh", [
+                "pr", "view", String(issue.prNumber),
+                "--repo", project.github.repoFullName,
+                "--json", "state,mergeable,mergeStateStatus,headRefOid,labels",
+            ], { timeoutMs: 10_000 });
+            pr = JSON.parse(stdout);
+        }
+        catch (error) {
+            this.logger.debug({ issueKey: issue.issueKey, prNumber: issue.prNumber, error: error instanceof Error ? error.message : String(error) }, "Queue health: failed to probe GitHub PR state");
+            const issueKey = `${issue.projectId}::${issue.linearIssueId}`;
+            const lastFeedAt = this.probeFailureFeedTimes.get(issueKey) ?? 0;
+            if (Date.now() - lastFeedAt >= QUEUE_HEALTH_PROBE_FAILURE_COOLDOWN_MS) {
+                this.probeFailureFeedTimes.set(issueKey, Date.now());
+                this.feed?.publish({
+                    level: "info",
+                    kind: "github",
+                    issueKey: issue.issueKey,
+                    projectId: issue.projectId,
+                    stage: "awaiting_queue",
+                    status: "queue_health_probe_failed",
+                    summary: `Queue health: failed to probe PR #${issue.prNumber}`,
+                });
+            }
+            return;
+        }
+        this.probeFailureFeedTimes.delete(`${issue.projectId}::${issue.linearIssueId}`);
+        if (pr.state === "MERGED") {
+            this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "merged" });
+            this.advancer.advanceIdleIssue(issue, "done", { clearFailureProvenance: true });
+            return;
+        }
+        if (pr.state !== "OPEN")
+            return;
+        const hasQueueLabel = pr.labels?.some((l) => l.name === protocol.admissionLabel) ?? false;
+        if (!hasQueueLabel)
+            return;
+        const isDirty = pr.mergeStateStatus === "DIRTY" || pr.mergeable === "CONFLICTING";
+        let hasEvictionCheckRun = false;
+        if (!isDirty) {
+            try {
+                const { stdout: checksOut } = await execCommand("gh", [
+                    "api", `repos/${project.github.repoFullName}/commits/${pr.headRefOid}/check-runs`,
+                    "--jq", `.check_runs[] | select(.name == "${protocol.evictionCheckName}" and .conclusion == "failure") | .name`,
+                ], { timeoutMs: 10_000 });
+                hasEvictionCheckRun = checksOut.trim().length > 0;
+            }
+            catch {
+                // Best-effort check.
+            }
+        }
+        if (isDirty || hasEvictionCheckRun) {
+            const headRefOid = pr.headRefOid ?? "unknown";
+            const reason = hasEvictionCheckRun ? "queue_eviction_missed" : "preemptive_conflict";
+            const signature = `preemptive_queue_conflict:${headRefOid}`;
+            const pendingRunContext = {
+                source: "queue_health_monitor",
+                failureReason: reason,
+                failureHeadSha: headRefOid,
+                failureSignature: signature,
+            };
+            if (isDuplicateProbe(issue, pendingRunContext)) {
+                return;
+            }
+            this.db.upsertIssue({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                lastAttemptedFailureHeadSha: headRefOid,
+                lastAttemptedFailureSignature: signature,
+            });
+            this.advancer.advanceIdleIssue(issue, "repairing_queue", {
+                pendingRunType: "queue_repair",
+                pendingRunContext,
+            });
+            this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, headRefOid, reason }, "Queue health: queue issue detected, dispatching repair");
+            this.feed?.publish({
+                level: "warn",
+                kind: "github",
+                issueKey: issue.issueKey,
+                projectId: issue.projectId,
+                stage: "repairing_queue",
+                status: hasEvictionCheckRun ? "queue_health_eviction_detected" : "queue_health_conflict_detected",
+                summary: hasEvictionCheckRun
+                    ? `Queue health: missed eviction detected on PR #${issue.prNumber}, dispatching repair`
+                    : `Queue health: merge conflict detected on PR #${issue.prNumber}, dispatching preemptive repair`,
+            });
+        }
+    }
+}