patchrelay 0.18.0 → 0.19.0

package/dist/agent-session-plan.js

@@ -14,33 +14,33 @@ export function formatRunTypeLabel(runType) {
 function implementationPlan() {
     return [
         { content: "Prepare workspace", status: "pending" },
-        { content: "Implement or update branch", status: "pending" },
-        { content: "Await review", status: "pending" },
-        { content: "Land change", status: "pending" },
+        { content: "Implementing", status: "pending" },
+        { content: "Awaiting verification", status: "pending" },
+        { content: "Merge", status: "pending" },
     ];
 }
 function reviewFixPlan() {
     return [
         { content: "Prepare workspace", status: "completed" },
-        { content: "Address review feedback", status: "pending" },
-        { content: "Await re-review", status: "pending" },
-        { content: "Land change", status: "pending" },
+        { content: "Addressing review feedback", status: "pending" },
+        { content: "Awaiting re-verification", status: "pending" },
+        { content: "Merge", status: "pending" },
     ];
 }
 function ciRepairPlan(attempt) {
     return [
         { content: "Prepare workspace", status: "completed" },
-        { content: "Implement or update branch", status: "completed" },
-        { content: `Repair failing checks (${attemptLabel(attempt)})`, status: "pending" },
-        { content: "Return to merge flow", status: "pending" },
+        { content: "Implementing", status: "completed" },
+        { content: `Repairing checks (${attemptLabel(attempt)})`, status: "pending" },
+        { content: "Merge", status: "pending" },
     ];
 }
 function queueRepairPlan(attempt) {
     return [
         { content: "Prepare workspace", status: "completed" },
-        { content: "Implement or update branch", status: "completed" },
-        { content: "Review approved", status: "completed" },
-        { content: `Repair merge queue (${attemptLabel(attempt)})`, status: "pending" },
+        { content: "Implementing", status: "completed" },
+        { content: "Verification passed", status: "completed" },
+        { content: `Repairing merge (${attemptLabel(attempt)})`, status: "pending" },
     ];
 }
 function awaitingInputPlan() {
@@ -101,9 +101,9 @@ export function buildAgentSessionPlan(params) {
         case "awaiting_queue":
             return setStatuses([
                 { content: "Prepare workspace", status: "completed" },
-                { content: "Implement or update branch", status: "completed" },
-                { content: "Review approved", status: "completed" },
-                { content: "Queued for merge", status: "inProgress" },
+                { content: "Implementing", status: "completed" },
+                { content: "Verification passed", status: "completed" },
+                { content: "Awaiting merge", status: "inProgress" },
             ], ["completed", "completed", "completed", "inProgress"]);
         case "repairing_queue":
             return setStatuses(queueRepairPlan(params.queueRepairAttempts ?? 1), ["completed", "completed", "completed", "inProgress"]);
@@ -116,8 +116,8 @@ export function buildAgentSessionPlan(params) {
         case "done":
             return setStatuses([
                 { content: "Prepare workspace", status: "completed" },
-                { content: "Implement or update branch", status: "completed" },
-                { content: "Review approved", status: "completed" },
+                { content: "Implementing", status: "completed" },
+                { content: "Verification passed", status: "completed" },
                 { content: "Merged", status: "completed" },
             ], ["completed", "completed", "completed", "completed"]);
     }

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.18.0",
-  "commit": "37f3bf8f344f",
-  "builtAt": "2026-03-25T19:56:49.875Z"
+  "version": "0.19.0",
+  "commit": "0172365b885d",
+  "builtAt": "2026-03-25T20:06:12.646Z"
 }

package/dist/cli/watch/TimelineRow.js

@@ -28,15 +28,24 @@ function FeedRow({ entry }) {
     const statusLabel = feed.status ?? feed.feedKind;
     return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: formatTime(entry.at) }), _jsx(Text, { color: "cyan", children: statusLabel.padEnd(16) }), _jsx(Text, { children: feed.summary })] }));
 }
+const RUN_TYPE_LABELS = {
+    implementation: "implementing",
+    ci_repair: "repairing checks",
+    review_fix: "addressing feedback",
+    queue_repair: "repairing merge",
+};
+function runLabel(runType) {
+    return RUN_TYPE_LABELS[runType] ?? runType;
+}
 function RunStartRow({ entry }) {
     const run = entry.run;
-    return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: formatTime(entry.at) }), _jsx(Text, { bold: true, color: "yellow", children: run.runType.padEnd(16) }), _jsx(Text, { bold: true, children: "run started" })] }));
+    return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: formatTime(entry.at) }), _jsx(Text, { bold: true, color: "yellow", children: runLabel(run.runType).padEnd(20) }), _jsx(Text, { bold: true, children: "started" })] }));
 }
 function RunEndRow({ entry }) {
     const run = entry.run;
     const color = run.status === "completed" ? "green" : "red";
     const duration = run.endedAt ? formatDuration(run.startedAt, run.endedAt) : "";
-    return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: formatTime(entry.at) }), _jsx(Text, { bold: true, color: color, children: run.runType.padEnd(16) }), _jsx(Text, { bold: true, color: color, children: run.status }), duration ? _jsxs(Text, { dimColor: true, children: ["(", duration, ")"] }) : null] }));
+    return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: formatTime(entry.at) }), _jsx(Text, { bold: true, color: color, children: runLabel(run.runType).padEnd(20) }), _jsx(Text, { bold: true, color: color, children: run.status }), duration ? _jsxs(Text, { dimColor: true, children: ["(", duration, ")"] }) : null] }));
 }
 function ItemRow({ entry }) {
     const item = entry.item;

package/dist/config.js

@@ -30,6 +30,10 @@ const projectSchema = z.object({
     allow_labels: z.array(z.string().min(1)).default([]),
     trigger_events: z.array(z.string().min(1)).min(1).optional(),
     branch_prefix: z.string().min(1).optional(),
+    /** Check names that are review gates (AI Review, quality analysis). Default: code class. */
+    review_checks: z.array(z.string().min(1)).default([]),
+    /** Check names that are policy gates (conventional title, release policy). Default: code class. */
+    gate_checks: z.array(z.string().min(1)).default([]),
     github: z.object({
         webhook_secret: z.string().min(1).optional(),
         repo_full_name: z.string().min(1).optional(),
@@ -394,6 +398,8 @@ export function loadConfig(configPath = process.env.PATCHRELAY_CONFIG ?? getDefa
                 issueKeyPrefixes: project.issue_key_prefixes,
                 linearTeamIds: project.linear_team_ids,
                 allowLabels: project.allow_labels,
+                reviewChecks: project.review_checks,
+                gateChecks: project.gate_checks,
                 triggerEvents: normalizeTriggerEvents(parsed.linear.oauth.actor, repoSettings?.trigger_events ??
                     project.trigger_events),
                 branchPrefix: repoSettings?.branch_prefix ?? project.branch_prefix ?? defaultBranchPrefix(project.id),

package/dist/db.js

@@ -246,9 +246,13 @@ export class PatchRelayDatabase {
      * Issues idle in pr_open with no active run — candidates for state
      * advancement based on stored PR metadata (missed GitHub webhooks).
      */
-    listIdlePrOpenIssues() {
+    listIdleNonTerminalIssues() {
         const rows = this.connection
-            .prepare("SELECT * FROM issues WHERE factory_state = 'pr_open' AND active_run_id IS NULL AND pending_run_type IS NULL AND pr_number IS NOT NULL")
+            .prepare(`SELECT * FROM issues
+         WHERE factory_state NOT IN ('done', 'escalated', 'failed', 'awaiting_input')
+         AND active_run_id IS NULL
+         AND pending_run_type IS NULL
+         AND pr_number IS NOT NULL`)
             .all();
         return rows.map(mapIssueRow);
     }

package/dist/github-webhook-handler.js

@@ -182,10 +182,11 @@ export class GitHubWebhookHandler {
             detail: event.checkName ?? event.reviewBody?.slice(0, 200) ?? undefined,
         });
         if (!isMetadataOnlyCheckEvent(event)) {
-            this.maybeEnqueueReactiveRun(freshIssue, event);
+            const project = this.config.projects.find((p) => p.id === freshIssue.projectId);
+            this.maybeEnqueueReactiveRun(freshIssue, event, project);
         }
     }
-    maybeEnqueueReactiveRun(issue, event) {
+    maybeEnqueueReactiveRun(issue, event, project) {
         // Don't trigger if there's already an active run
         if (issue.activeRunId !== undefined)
             return;
@@ -197,6 +198,7 @@ export class GitHubWebhookHandler {
                 pendingRunContextJson: JSON.stringify({
                     checkName: event.checkName,
                     checkUrl: event.checkUrl,
+                    checkClass: resolveCheckClass(event.checkName, project),
                 }),
             });
             this.enqueueIssue(issue.projectId, issue.linearIssueId);
@@ -281,3 +283,12 @@ export class GitHubWebhookHandler {
         }
     }
 }
+function resolveCheckClass(checkName, project) {
+    if (!checkName || !project)
+        return "code";
+    if (project.reviewChecks.some((name) => checkName.includes(name)))
+        return "review";
+    if (project.gateChecks.some((name) => checkName.includes(name)))
+        return "gate";
+    return "code";
+}

package/dist/run-orchestrator.js

@@ -410,53 +410,70 @@ export class RunOrchestrator {
         }
         // Advance issues stuck in pr_open whose stored PR metadata already
         // shows they should transition (e.g. approved PR, missed webhook).
-        await this.reconcileIdlePrOpenIssues();
+        await this.reconcileIdleIssues();
     }
-    async reconcileIdlePrOpenIssues() {
-        for (const issue of this.db.listIdlePrOpenIssues()) {
+    async reconcileIdleIssues() {
+        for (const issue of this.db.listIdleNonTerminalIssues()) {
+            // PR already merged — advance to done regardless of current state
             if (issue.prState === "merged") {
                 this.advanceIdleIssue(issue, "done");
                 continue;
             }
-            if (issue.prReviewState === "approved") {
+            // Review approved + checks not failed — advance to awaiting_queue
+            if (issue.prReviewState === "approved" && issue.prCheckStatus !== "failed") {
                 this.advanceIdleIssue(issue, "awaiting_queue");
                 continue;
             }
-            // Stored metadata may be stale (missed webhooks during downtime).
-            // Query GitHub for the actual PR review state.
-            const project = this.config.projects.find((p) => p.id === issue.projectId);
-            if (!project?.github?.repoFullName || !issue.prNumber)
+            // Checks failed + idle (not already in a repair state) — enqueue ci_repair
+            if (issue.prCheckStatus === "failed" && issue.factoryState !== "repairing_ci") {
+                this.advanceIdleIssue(issue, "repairing_ci", "ci_repair");
+                continue;
+            }
+            // Awaiting queue with stale pending merge prep — re-enqueue
+            if (issue.factoryState === "awaiting_queue" && issue.pendingMergePrep) {
+                this.enqueueIssue(issue.projectId, issue.linearIssueId);
                 continue;
-            try {
-                const { stdout } = await execCommand("gh", [
-                    "pr", "view", String(issue.prNumber),
-                    "--repo", project.github.repoFullName,
-                    "--json", "state,reviewDecision",
-                ], { 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");
-                }
-                else if (pr.reviewDecision === "APPROVED") {
-                    this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prReviewState: "approved" });
-                    this.advanceIdleIssue(issue, "awaiting_queue");
-                }
             }
-            catch (error) {
-                this.logger.debug({ issueKey: issue.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to query GitHub PR state during reconciliation");
+            // For pr_open issues with no review decision, check GitHub for stale metadata
+            if (issue.factoryState === "pr_open" && !issue.prReviewState) {
+                await this.reconcileFromGitHub(issue);
             }
         }
     }
-    advanceIdleIssue(issue, newState) {
-        this.logger.info({ issueKey: issue.issueKey, from: issue.factoryState, to: newState }, "Reconciliation: advancing idle issue from stored PR metadata");
+    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",
+            ], { 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");
+            }
+            else if (pr.reviewDecision === "APPROVED") {
+                this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prReviewState: "approved" });
+                this.advanceIdleIssue(issue, "awaiting_queue");
+            }
+        }
+        catch (error) {
+            this.logger.debug({ issueKey: issue.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to query GitHub PR state during reconciliation");
+        }
+    }
+    advanceIdleIssue(issue, newState, pendingRunType) {
+        this.logger.info({ issueKey: issue.issueKey, from: issue.factoryState, to: newState, pendingRunType }, "Reconciliation: advancing idle issue");
         this.db.upsertIssue({
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             factoryState: newState,
             ...(newState === "awaiting_queue" ? { pendingMergePrep: true } : {}),
+            ...(pendingRunType ? { pendingRunType: pendingRunType } : {}),
         });
-        if (newState === "awaiting_queue") {
+        if (newState === "awaiting_queue" || pendingRunType) {
             this.enqueueIssue(issue.projectId, issue.linearIssueId);
         }
     }

package/package.json

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