patchrelay 0.26.0 → 0.29.1

package/dist/config.js

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import { isIP } from "node:net";
+import { homedir } from "node:os";
 import path from "node:path";
 import { z } from "zod";
 import { getDefaultConfigPath, getDefaultDatabasePath, getDefaultLogPath, getDefaultRuntimeEnvPath, getDefaultServiceEnvPath, getPatchRelayDataDir, } from "./runtime-paths.js";
@@ -40,6 +41,24 @@ const projectSchema = z.object({
         base_branch: z.string().min(1).optional(),
     }).optional(),
 });
+const repositorySchema = z.object({
+    github_repo: z.string().min(1),
+    local_path: z.string().min(1).optional(),
+    workspace: z.string().min(1).optional(),
+    linear_team_ids: z.array(z.string().min(1)).default([]),
+    linear_project_ids: z.array(z.string().min(1)).default([]),
+    issue_key_prefixes: z.array(z.string().min(1)).default([]),
+    review_checks: z.array(z.string().min(1)).default([]),
+    gate_checks: 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(),
+    github: z.object({
+        webhook_secret: z.string().min(1).optional(),
+        base_branch: z.string().min(1).optional(),
+        merge_queue_label: z.string().min(1).optional(),
+        merge_queue_check_name: z.string().min(1).optional(),
+    }).optional(),
+});
 const configSchema = z.object({
     server: z.object({
         bind: z.string().default("127.0.0.1"),
@@ -102,7 +121,11 @@ const configSchema = z.object({
             experimental_raw_events: z.boolean().default(true),
         }),
     }),
+    repos: z.object({
+        root: z.string().min(1).default(path.join(homedir(), "projects")),
+    }).default(() => ({ root: path.join(homedir(), "projects") })),
     projects: z.array(projectSchema).default([]),
+    repositories: z.array(repositorySchema).default([]),
 });
 function defaultTriggerEvents(actor) {
     if (actor === "app") {
@@ -141,7 +164,9 @@ function withSectionDefaults(input) {
         logging: {},
         database: {},
         operator_api: {},
+        repos: {},
         projects: [],
+        repositories: [],
         ...rest,
         linear: {
             ...linear,
@@ -250,6 +275,13 @@ function readRepoSettings(repoPath, env) {
 function defaultWorktreeRoot(projectId) {
     return path.join(getPatchRelayDataDir(), "worktrees", projectId);
 }
+function defaultRepositoryLocalPath(reposRoot, githubRepo) {
+    const repoName = githubRepo.split("/").pop()?.trim();
+    if (!repoName) {
+        throw new Error(`Invalid github_repo: ${githubRepo}`);
+    }
+    return path.join(ensureAbsolutePath(reposRoot), repoName);
+}
 function defaultBranchPrefix(projectId) {
     const sanitized = projectId
         .trim()
@@ -317,6 +349,84 @@ export function loadConfig(configPath = process.env.PATCHRELAY_CONFIG ?? getDefa
     }
     const logFilePath = env.PATCHRELAY_LOG_FILE ?? parsed.logging.file_path;
     const oauthRedirectUri = parsed.linear.oauth.redirect_uri ?? deriveLinearOAuthRedirectUri(parsed.server);
+    const reposRoot = ensureAbsolutePath(parsed.repos.root);
+    const repositories = parsed.repositories.map((repository) => {
+        const localPath = ensureAbsolutePath(repository.local_path ?? defaultRepositoryLocalPath(reposRoot, repository.github_repo));
+        return {
+            githubRepo: repository.github_repo,
+            localPath,
+            ...(repository.workspace ? { workspace: repository.workspace } : {}),
+            linearTeamIds: repository.linear_team_ids,
+            linearProjectIds: repository.linear_project_ids,
+            issueKeyPrefixes: repository.issue_key_prefixes,
+            reviewChecks: repository.review_checks,
+            gateChecks: repository.gate_checks,
+            triggerEvents: repository.trigger_events,
+            branchPrefix: repository.branch_prefix,
+            github: repository.github,
+        };
+    });
+    const repositoryProjects = repositories.map((repository) => {
+        const repoSettings = readRepoSettings(repository.localPath, env);
+        return {
+            id: repository.githubRepo,
+            repoPath: repository.localPath,
+            worktreeRoot: ensureAbsolutePath(defaultWorktreeRoot(repository.githubRepo)),
+            issueKeyPrefixes: repository.issueKeyPrefixes,
+            linearTeamIds: repository.linearTeamIds,
+            allowLabels: [],
+            reviewChecks: repository.reviewChecks,
+            gateChecks: repository.gateChecks,
+            triggerEvents: normalizeTriggerEvents(parsed.linear.oauth.actor, repoSettings?.trigger_events ?? repository.triggerEvents),
+            branchPrefix: repoSettings?.branch_prefix ?? repository.branchPrefix ?? defaultBranchPrefix(repository.githubRepo),
+            ...(repoSettings?.configPath ? { repoSettingsPath: repoSettings.configPath } : {}),
+            github: {
+                repoFullName: repository.githubRepo,
+                ...(repository.github?.base_branch ? { baseBranch: repository.github.base_branch } : {}),
+                ...(repository.github?.webhook_secret ? { webhookSecret: repository.github.webhook_secret } : {}),
+                ...(repository.github?.merge_queue_label ? { mergeQueueLabel: repository.github.merge_queue_label } : {}),
+                ...(repository.github?.merge_queue_check_name ? { mergeQueueCheckName: repository.github.merge_queue_check_name } : {}),
+            },
+        };
+    });
+    const legacyProjects = parsed.projects.map((project) => {
+        const repoPath = ensureAbsolutePath(project.repo_path);
+        const repoSettings = readRepoSettings(repoPath, env);
+        const trustedActors = project.trusted_actors;
+        return {
+            id: project.id,
+            repoPath,
+            worktreeRoot: ensureAbsolutePath(project.worktree_root ?? defaultWorktreeRoot(project.id)),
+            ...(trustedActors
+                ? {
+                    trustedActors: {
+                        ids: trustedActors.ids,
+                        names: trustedActors.names,
+                        emails: trustedActors.emails,
+                        emailDomains: trustedActors.email_domains,
+                    },
+                }
+                : {}),
+            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),
+            ...(repoSettings?.configPath ? { repoSettingsPath: repoSettings.configPath } : {}),
+            ...(project.github ? {
+                github: {
+                    ...(project.github.webhook_secret ? { webhookSecret: project.github.webhook_secret } : {}),
+                    ...(project.github.repo_full_name ? { repoFullName: project.github.repo_full_name } : {}),
+                    ...(project.github.base_branch ? { baseBranch: project.github.base_branch } : {}),
+                },
+            } : {}),
+        };
+    });
+    const repositoryPaths = new Set(repositoryProjects.map((project) => project.repoPath));
+    const derivedProjects = [...repositoryProjects, ...legacyProjects.filter((project) => !repositoryPaths.has(project.repoPath))];
     const config = {
         server: {
             bind: parsed.server.bind,
@@ -377,42 +487,18 @@ export function loadConfig(configPath = process.env.PATCHRELAY_CONFIG ?? getDefa
                 experimentalRawEvents: parsed.runner.codex.experimental_raw_events,
             },
         },
-        projects: parsed.projects.map((project) => {
-            const repoPath = ensureAbsolutePath(project.repo_path);
-            const repoSettings = readRepoSettings(repoPath, env);
-            const trustedActors = project.trusted_actors;
-            return {
-                id: project.id,
-                repoPath,
-                worktreeRoot: ensureAbsolutePath(project.worktree_root ?? defaultWorktreeRoot(project.id)),
-                ...(trustedActors
-                    ? {
-                        trustedActors: {
-                            ids: trustedActors.ids,
-                            names: trustedActors.names,
-                            emails: trustedActors.emails,
-                            emailDomains: trustedActors.email_domains,
-                        },
-                    }
-                    : {}),
-                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),
-                ...(repoSettings?.configPath ? { repoSettingsPath: repoSettings.configPath } : {}),
-                ...(project.github ? {
-                    github: {
-                        ...(project.github.webhook_secret ? { webhookSecret: project.github.webhook_secret } : {}),
-                        ...(project.github.repo_full_name ? { repoFullName: project.github.repo_full_name } : {}),
-                        ...(project.github.base_branch ? { baseBranch: project.github.base_branch } : {}),
-                    },
-                } : {}),
-            };
-        }),
+        repos: {
+            root: reposRoot,
+        },
+        repositories: repositories.map((repository) => ({
+            githubRepo: repository.githubRepo,
+            localPath: repository.localPath,
+            ...(repository.workspace ? { workspace: repository.workspace } : {}),
+            linearTeamIds: repository.linearTeamIds,
+            linearProjectIds: repository.linearProjectIds,
+            issueKeyPrefixes: repository.issueKeyPrefixes,
+        })),
+        projects: derivedProjects,
         secretSources: {
             "linear-webhook-secret": rWebhookSecret.source,
             "token-encryption-key": rTokenEncryptionKey.source,
@@ -462,8 +548,15 @@ function validateConfigSemantics(config, options) {
         throw new Error(`linear.oauth.redirect_uri must use the fixed "${LINEAR_OAUTH_CALLBACK_PATH}" path`);
     }
     const projectIds = new Set();
+    const githubRepos = new Set();
     const issuePrefixes = new Map();
     const linearTeamIds = new Map();
+    for (const repository of config.repositories) {
+        if (githubRepos.has(repository.githubRepo)) {
+            throw new Error(`Duplicate repository github_repo: ${repository.githubRepo}`);
+        }
+        githubRepos.add(repository.githubRepo);
+    }
     for (const project of config.projects) {
         if (projectIds.has(project.id)) {
             throw new Error(`Duplicate project id: ${project.id}`);

package/dist/db/linear-installation-store.js

@@ -79,6 +79,23 @@ export class LinearInstallationStore {
             .all();
         return rows.map((row) => mapLinearInstallation(row));
     }
+    findLinearInstallationByWorkspace(query) {
+        const normalized = query.trim().toLowerCase();
+        if (!normalized)
+            return undefined;
+        const row = this.connection
+            .prepare(`
+        SELECT *
+        FROM linear_installations
+        WHERE LOWER(COALESCE(workspace_key, '')) = ?
+           OR LOWER(COALESCE(workspace_name, '')) = ?
+           OR LOWER(COALESCE(workspace_id, '')) = ?
+        ORDER BY updated_at DESC, id DESC
+        LIMIT 1
+        `)
+            .get(normalized, normalized, normalized);
+        return row ? mapLinearInstallation(row) : undefined;
+    }
     linkProjectInstallation(projectId, installationId) {
         const now = isoNow();
         this.connection
@@ -108,6 +125,12 @@ export class LinearInstallationStore {
     unlinkProjectInstallation(projectId) {
         this.connection.prepare("DELETE FROM project_installations WHERE project_id = ?").run(projectId);
     }
+    unlinkInstallationProjects(installationId) {
+        this.connection.prepare("DELETE FROM project_installations WHERE installation_id = ?").run(installationId);
+    }
+    deleteLinearInstallation(installationId) {
+        this.connection.prepare("DELETE FROM linear_installations WHERE id = ?").run(installationId);
+    }
     getLinearInstallationForProject(projectId) {
         const row = this.connection
             .prepare(`

package/dist/db/migrations.js

@@ -87,6 +87,37 @@ CREATE TABLE IF NOT EXISTS project_installations (
   linked_at TEXT NOT NULL
 );
 
+CREATE TABLE IF NOT EXISTS repository_links (
+  github_repo TEXT PRIMARY KEY,
+  local_path TEXT NOT NULL,
+  installation_id INTEGER NOT NULL,
+  linear_team_ids_json TEXT NOT NULL DEFAULT '[]',
+  linear_project_ids_json TEXT NOT NULL DEFAULT '[]',
+  issue_key_prefixes_json TEXT NOT NULL DEFAULT '[]',
+  linked_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS linear_catalog_teams (
+  installation_id INTEGER NOT NULL,
+  team_id TEXT NOT NULL,
+  team_key TEXT,
+  team_name TEXT,
+  active INTEGER NOT NULL DEFAULT 1,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (installation_id, team_id)
+);
+
+CREATE TABLE IF NOT EXISTS linear_catalog_projects (
+  installation_id INTEGER NOT NULL,
+  project_id TEXT NOT NULL,
+  project_name TEXT,
+  team_ids_json TEXT NOT NULL DEFAULT '[]',
+  active INTEGER NOT NULL DEFAULT 1,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (installation_id, project_id)
+);
+
 CREATE TABLE IF NOT EXISTS oauth_states (
   id INTEGER PRIMARY KEY AUTOINCREMENT,
   provider TEXT NOT NULL,
@@ -124,6 +155,9 @@ CREATE INDEX IF NOT EXISTS idx_runs_thread ON runs(thread_id);
 CREATE INDEX IF NOT EXISTS idx_run_thread_events_run ON run_thread_events(run_id, id);
 CREATE INDEX IF NOT EXISTS idx_operator_feed_events_issue ON operator_feed_events(issue_key, id);
 CREATE INDEX IF NOT EXISTS idx_operator_feed_events_project ON operator_feed_events(project_id, id);
+CREATE INDEX IF NOT EXISTS idx_repository_links_installation ON repository_links(installation_id, github_repo);
+CREATE INDEX IF NOT EXISTS idx_linear_catalog_teams_installation ON linear_catalog_teams(installation_id, team_key, team_name);
+CREATE INDEX IF NOT EXISTS idx_linear_catalog_projects_installation ON linear_catalog_projects(installation_id, project_name);
 `;
 export function runPatchRelayMigrations(connection) {
     connection.exec(schema);
@@ -144,6 +178,14 @@ export function runPatchRelayMigrations(connection) {
     // Zombie/stale recovery backoff
     addColumnIfMissing(connection, "issues", "zombie_recovery_attempts", "INTEGER NOT NULL DEFAULT 0");
     addColumnIfMissing(connection, "issues", "last_zombie_recovery_at", "TEXT");
+    // Preserve GitHub failure provenance so reconciliation can distinguish
+    // branch CI failures from merge-queue evictions after webhook delivery.
+    addColumnIfMissing(connection, "issues", "last_github_failure_source", "TEXT");
+    addColumnIfMissing(connection, "issues", "last_github_failure_check_name", "TEXT");
+    addColumnIfMissing(connection, "issues", "last_github_failure_check_url", "TEXT");
+    addColumnIfMissing(connection, "issues", "last_github_failure_at", "TEXT");
+    addColumnIfMissing(connection, "issues", "last_queue_signal_at", "TEXT");
+    addColumnIfMissing(connection, "issues", "last_queue_incident_json", "TEXT");
 }
 function addColumnIfMissing(connection, table, column, definition) {
     const cols = connection.prepare(`PRAGMA table_info(${table})`).all();

package/dist/db/repository-link-store.js

@@ -0,0 +1,103 @@
+import { isoNow } from "./shared.js";
+export class RepositoryLinkStore {
+    connection;
+    constructor(connection) {
+        this.connection = connection;
+    }
+    upsertRepositoryLink(params) {
+        const now = isoNow();
+        this.connection
+            .prepare(`
+        INSERT INTO repository_links (
+          github_repo, local_path, installation_id, linear_team_ids_json, linear_project_ids_json, issue_key_prefixes_json, linked_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(github_repo) DO UPDATE SET
+          local_path = excluded.local_path,
+          installation_id = excluded.installation_id,
+          linear_team_ids_json = excluded.linear_team_ids_json,
+          linear_project_ids_json = excluded.linear_project_ids_json,
+          issue_key_prefixes_json = excluded.issue_key_prefixes_json,
+          updated_at = excluded.updated_at
+        `)
+            .run(params.githubRepo, params.localPath, params.installationId, JSON.stringify(params.linearTeamIds), JSON.stringify(params.linearProjectIds ?? []), JSON.stringify(params.issueKeyPrefixes ?? []), now, now);
+        return this.getRepositoryLink(params.githubRepo);
+    }
+    getRepositoryLink(githubRepo) {
+        const row = this.connection
+            .prepare("SELECT * FROM repository_links WHERE github_repo = ?")
+            .get(githubRepo);
+        return row ? mapRepositoryLink(row) : undefined;
+    }
+    listRepositoryLinks() {
+        const rows = this.connection
+            .prepare("SELECT * FROM repository_links ORDER BY github_repo")
+            .all();
+        return rows.map(mapRepositoryLink);
+    }
+    deleteRepositoryLink(githubRepo) {
+        this.connection.prepare("DELETE FROM repository_links WHERE github_repo = ?").run(githubRepo);
+    }
+    replaceCatalog(params) {
+        const now = isoNow();
+        this.connection.prepare("DELETE FROM linear_catalog_teams WHERE installation_id = ?").run(params.installationId);
+        this.connection.prepare("DELETE FROM linear_catalog_projects WHERE installation_id = ?").run(params.installationId);
+        const teamStmt = this.connection.prepare(`
+      INSERT INTO linear_catalog_teams (installation_id, team_id, team_key, team_name, active, updated_at)
+      VALUES (?, ?, ?, ?, 1, ?)
+      `);
+        for (const team of params.teams) {
+            teamStmt.run(params.installationId, team.id, team.key ?? null, team.name ?? null, now);
+        }
+        const projectStmt = this.connection.prepare(`
+      INSERT INTO linear_catalog_projects (installation_id, project_id, project_name, team_ids_json, active, updated_at)
+      VALUES (?, ?, ?, ?, 1, ?)
+      `);
+        for (const project of params.projects) {
+            projectStmt.run(params.installationId, project.id, project.name ?? null, JSON.stringify(project.teamIds), now);
+        }
+    }
+    listCatalogTeams(installationId) {
+        const rows = this.connection
+            .prepare("SELECT * FROM linear_catalog_teams WHERE installation_id = ? ORDER BY COALESCE(team_key, team_name, team_id)")
+            .all(installationId);
+        return rows.map(mapCatalogTeam);
+    }
+    listCatalogProjects(installationId) {
+        const rows = this.connection
+            .prepare("SELECT * FROM linear_catalog_projects WHERE installation_id = ? ORDER BY COALESCE(project_name, project_id)")
+            .all(installationId);
+        return rows.map(mapCatalogProject);
+    }
+}
+function mapRepositoryLink(row) {
+    return {
+        githubRepo: String(row.github_repo),
+        localPath: String(row.local_path),
+        installationId: Number(row.installation_id),
+        linearTeamIdsJson: String(row.linear_team_ids_json ?? "[]"),
+        linearProjectIdsJson: String(row.linear_project_ids_json ?? "[]"),
+        issueKeyPrefixesJson: String(row.issue_key_prefixes_json ?? "[]"),
+        linkedAt: String(row.linked_at),
+        updatedAt: String(row.updated_at),
+    };
+}
+function mapCatalogTeam(row) {
+    return {
+        installationId: Number(row.installation_id),
+        teamId: String(row.team_id),
+        ...(row.team_key === null ? {} : { key: String(row.team_key) }),
+        ...(row.team_name === null ? {} : { name: String(row.team_name) }),
+        active: Number(row.active ?? 0) !== 0,
+        updatedAt: String(row.updated_at),
+    };
+}
+function mapCatalogProject(row) {
+    return {
+        installationId: Number(row.installation_id),
+        projectId: String(row.project_id),
+        ...(row.project_name === null ? {} : { name: String(row.project_name) }),
+        teamIdsJson: String(row.team_ids_json ?? "[]"),
+        active: Number(row.active ?? 0) !== 0,
+        updatedAt: String(row.updated_at),
+    };
+}

package/dist/db.js

@@ -1,11 +1,13 @@
 import { LinearInstallationStore } from "./db/linear-installation-store.js";
 import { OperatorFeedStore } from "./db/operator-feed-store.js";
+import { RepositoryLinkStore } from "./db/repository-link-store.js";
 import { runPatchRelayMigrations } from "./db/migrations.js";
 import { SqliteConnection, isoNow } from "./db/shared.js";
 export class PatchRelayDatabase {
     connection;
     linearInstallations;
     operatorFeed;
+    repositories;
     constructor(databasePath, wal) {
         this.connection = new SqliteConnection(databasePath);
         this.connection.pragma("foreign_keys = ON");
@@ -14,6 +16,7 @@ export class PatchRelayDatabase {
         }
         this.linearInstallations = new LinearInstallationStore(this.connection);
         this.operatorFeed = new OperatorFeedStore(this.connection);
+        this.repositories = new RepositoryLinkStore(this.connection);
     }
     runMigrations() {
         runPatchRelayMigrations(this.connection);
@@ -153,6 +156,30 @@ export class PatchRelayDatabase {
                 sets.push("pr_check_status = @prCheckStatus");
                 values.prCheckStatus = params.prCheckStatus;
             }
+            if (params.lastGitHubFailureSource !== undefined) {
+                sets.push("last_github_failure_source = @lastGitHubFailureSource");
+                values.lastGitHubFailureSource = params.lastGitHubFailureSource;
+            }
+            if (params.lastGitHubFailureCheckName !== undefined) {
+                sets.push("last_github_failure_check_name = @lastGitHubFailureCheckName");
+                values.lastGitHubFailureCheckName = params.lastGitHubFailureCheckName;
+            }
+            if (params.lastGitHubFailureCheckUrl !== undefined) {
+                sets.push("last_github_failure_check_url = @lastGitHubFailureCheckUrl");
+                values.lastGitHubFailureCheckUrl = params.lastGitHubFailureCheckUrl;
+            }
+            if (params.lastGitHubFailureAt !== undefined) {
+                sets.push("last_github_failure_at = @lastGitHubFailureAt");
+                values.lastGitHubFailureAt = params.lastGitHubFailureAt;
+            }
+            if (params.lastQueueSignalAt !== undefined) {
+                sets.push("last_queue_signal_at = @lastQueueSignalAt");
+                values.lastQueueSignalAt = params.lastQueueSignalAt;
+            }
+            if (params.lastQueueIncidentJson !== undefined) {
+                sets.push("last_queue_incident_json = @lastQueueIncidentJson");
+                values.lastQueueIncidentJson = params.lastQueueIncidentJson;
+            }
             if (params.ciRepairAttempts !== undefined) {
                 sets.push("ci_repair_attempts = @ciRepairAttempts");
                 values.ciRepairAttempts = params.ciRepairAttempts;
@@ -165,14 +192,6 @@ export class PatchRelayDatabase {
                 sets.push("review_fix_attempts = @reviewFixAttempts");
                 values.reviewFixAttempts = params.reviewFixAttempts;
             }
-            if (params.mergePrepAttempts !== undefined) {
-                sets.push("merge_prep_attempts = @mergePrepAttempts");
-                values.mergePrepAttempts = params.mergePrepAttempts;
-            }
-            if (params.pendingMergePrep !== undefined) {
-                sets.push("pending_merge_prep = @pendingMergePrep");
-                values.pendingMergePrep = params.pendingMergePrep ? 1 : 0;
-            }
             if (params.zombieRecoveryAttempts !== undefined) {
                 sets.push("zombie_recovery_attempts = @zombieRecoveryAttempts");
                 values.zombieRecoveryAttempts = params.zombieRecoveryAttempts;
@@ -191,6 +210,8 @@ export class PatchRelayDatabase {
           current_linear_state, factory_state, pending_run_type, pending_run_context_json,
           branch_name, worktree_path, thread_id, active_run_id,
           agent_session_id,
+          pr_number, pr_url, pr_state, pr_review_state, pr_check_status,
+          last_github_failure_source, last_github_failure_check_name, last_github_failure_check_url, last_github_failure_at, last_queue_signal_at, last_queue_incident_json,
           updated_at
         ) VALUES (
           @projectId, @linearIssueId, @issueKey, @title, @description, @url,
@@ -198,6 +219,8 @@ export class PatchRelayDatabase {
           @currentLinearState, @factoryState, @pendingRunType, @pendingRunContextJson,
           @branchName, @worktreePath, @threadId, @activeRunId,
           @agentSessionId,
+          @prNumber, @prUrl, @prState, @prReviewState, @prCheckStatus,
+          @lastGitHubFailureSource, @lastGitHubFailureCheckName, @lastGitHubFailureCheckUrl, @lastGitHubFailureAt, @lastQueueSignalAt, @lastQueueIncidentJson,
           @now
         )
       `).run({
@@ -218,6 +241,17 @@ export class PatchRelayDatabase {
                 threadId: params.threadId ?? null,
                 activeRunId: params.activeRunId ?? null,
                 agentSessionId: params.agentSessionId ?? null,
+                prNumber: params.prNumber ?? null,
+                prUrl: params.prUrl ?? null,
+                prState: params.prState ?? null,
+                prReviewState: params.prReviewState ?? null,
+                prCheckStatus: params.prCheckStatus ?? null,
+                lastGitHubFailureSource: params.lastGitHubFailureSource ?? null,
+                lastGitHubFailureCheckName: params.lastGitHubFailureCheckName ?? null,
+                lastGitHubFailureCheckUrl: params.lastGitHubFailureCheckUrl ?? null,
+                lastGitHubFailureAt: params.lastGitHubFailureAt ?? null,
+                lastQueueSignalAt: params.lastQueueSignalAt ?? null,
+                lastQueueIncidentJson: params.lastQueueIncidentJson ?? null,
                 now,
             });
         }
@@ -247,7 +281,7 @@ export class PatchRelayDatabase {
     }
     listIssuesReadyForExecution() {
         const rows = this.connection
-            .prepare("SELECT project_id, linear_issue_id FROM issues WHERE (pending_run_type IS NOT NULL OR pending_merge_prep = 1) AND active_run_id IS NULL")
+            .prepare("SELECT project_id, linear_issue_id FROM issues WHERE pending_run_type IS NOT NULL AND active_run_id IS NULL")
             .all();
         return rows.map((row) => ({
             projectId: String(row.project_id),
@@ -427,11 +461,27 @@ function mapIssueRow(row) {
         ...(row.pr_state !== null && row.pr_state !== undefined ? { prState: String(row.pr_state) } : {}),
         ...(row.pr_review_state !== null && row.pr_review_state !== undefined ? { prReviewState: String(row.pr_review_state) } : {}),
         ...(row.pr_check_status !== null && row.pr_check_status !== undefined ? { prCheckStatus: String(row.pr_check_status) } : {}),
+        ...(row.last_github_failure_source !== null && row.last_github_failure_source !== undefined
+            ? { lastGitHubFailureSource: String(row.last_github_failure_source) }
+            : {}),
+        ...(row.last_github_failure_check_name !== null && row.last_github_failure_check_name !== undefined
+            ? { lastGitHubFailureCheckName: String(row.last_github_failure_check_name) }
+            : {}),
+        ...(row.last_github_failure_check_url !== null && row.last_github_failure_check_url !== undefined
+            ? { lastGitHubFailureCheckUrl: String(row.last_github_failure_check_url) }
+            : {}),
+        ...(row.last_github_failure_at !== null && row.last_github_failure_at !== undefined
+            ? { lastGitHubFailureAt: String(row.last_github_failure_at) }
+            : {}),
+        ...(row.last_queue_signal_at !== null && row.last_queue_signal_at !== undefined
+            ? { lastQueueSignalAt: String(row.last_queue_signal_at) }
+            : {}),
+        ...(row.last_queue_incident_json !== null && row.last_queue_incident_json !== undefined
+            ? { lastQueueIncidentJson: String(row.last_queue_incident_json) }
+            : {}),
         ciRepairAttempts: Number(row.ci_repair_attempts ?? 0),
         queueRepairAttempts: Number(row.queue_repair_attempts ?? 0),
         reviewFixAttempts: Number(row.review_fix_attempts ?? 0),
-        mergePrepAttempts: Number(row.merge_prep_attempts ?? 0),
-        pendingMergePrep: Boolean(row.pending_merge_prep),
         zombieRecoveryAttempts: Number(row.zombie_recovery_attempts ?? 0),
         ...(row.last_zombie_recovery_at !== null && row.last_zombie_recovery_at !== undefined ? { lastZombieRecoveryAt: String(row.last_zombie_recovery_at) } : {}),
     };

package/dist/factory-state.js

@@ -61,12 +61,8 @@ const TRANSITION_RULES = [
     { event: "check_failed",
         guard: (s, ctx) => isOpen(s) && ctx.activeRunId === undefined,
         to: "repairing_ci" },
-    // ── Merge queue events ─────────────────────────────────────────
-    { event: "merge_group_failed",
-        guard: (s) => s === "awaiting_queue",
-        to: "repairing_queue" },
-    // merge_group_passed: no rule → no transition (merge event follows)
     // pr_synchronize: no rule → no transition (resets counters only)
+    // merge_group events: not used — merge queue is handled by external steward
 ];
 /**
  * Resolve the next factory state from a GitHub webhook event.