patchrelay 0.26.0 → 0.29.1

package/dist/run-orchestrator.js

@@ -5,6 +5,8 @@ import { buildHookEnv, runProjectHook } from "./hook-runner.js";
 import { buildAgentSessionPlanForIssue, } from "./agent-session-plan.js";
 import { buildStageReport, countEventMethods, extractTurnId, resolveRunCompletionStatus, summarizeCurrentThread, } from "./run-reporting.js";
 import { buildRunCompletedActivity, buildRunFailureActivity, buildRunStartedActivity, } from "./linear-session-reporting.js";
+import { requestMergeQueueAdmission, resolveMergeQueueProtocol, } from "./merge-queue-protocol.js";
+import { parseStoredQueueRepairContext } from "./merge-queue-incident.js";
 import { buildAgentSessionExternalUrls } from "./agent-session-presentation.js";
 import { WorktreeManager } from "./worktree-manager.js";
 import { resolveAuthoritativeLinearStopState } from "./linear-workflow.js";
@@ -61,6 +63,7 @@ function buildRunPrompt(issue, runType, repoPath, context) {
             lines.push("## Review Changes Requested", "", "A reviewer has requested changes on your PR. Address the feedback and push.", context?.reviewerName ? `Reviewer: ${String(context.reviewerName)}` : "", context?.reviewBody ? `\n## Review comment\n\n${String(context.reviewBody)}` : "", "", "Steps:", "1. Read the review feedback and PR comments (`gh pr view --comments`).", "2. Check the current diff (`git diff origin/main`) — a prior rebase may have already resolved some concerns (e.g., scope-bundling from stale commits).", "3. For each review point: if already resolved, note why. If not, fix it.", "4. Run verification, commit and push.", "5. If you believe all concerns are resolved, request a re-review: `gh pr edit <PR#> --add-reviewer <reviewer>`.", "   Do NOT just post a comment saying \"resolved\" — the reviewer must re-review to dismiss the CHANGES_REQUESTED state.", "");
             break;
         case "queue_repair":
+            appendQueueRepairContext(lines, context);
             lines.push("## Merge Queue Failure", "", "The merge queue rejected this PR. Rebase onto latest main and fix conflicts.", context?.failureReason ? `Failure reason: ${String(context.failureReason)}` : "", "", "Fetch and rebase onto latest main, resolve conflicts, run verification, push.", "If the conflict is a semantic contradiction, explain and stop.", "");
             break;
     }
@@ -413,12 +416,20 @@ export class RunOrchestrator {
                 linearIssueId: run.linearIssueId,
                 activeRunId: null,
                 ...(postRunState ? { factoryState: postRunState } : {}),
-                ...(postRunState === "awaiting_queue" ? { pendingMergePrep: true } : {}),
+                ...(postRunState === "awaiting_queue" || postRunState === "done"
+                    ? {
+                        lastGitHubFailureSource: null,
+                        lastGitHubFailureCheckName: null,
+                        lastGitHubFailureCheckUrl: null,
+                        lastGitHubFailureAt: null,
+                        lastQueueIncidentJson: null,
+                    }
+                    : {}),
             });
         });
         // If we advanced to awaiting_queue, enqueue for merge prep
         if (postRunState === "awaiting_queue") {
-            this.enqueueIssue(run.projectId, run.linearIssueId);
+            this.requestMergeQueueAdmission(issue, run.projectId);
         }
         this.feed?.publish({
             level: "info",
@@ -510,22 +521,56 @@ export class RunOrchestrator {
         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");
+                this.advanceIdleIssue(issue, "done", { clearFailureProvenance: true });
                 continue;
             }
             // Review approved + checks not failed — advance to awaiting_queue
             if (issue.prReviewState === "approved" && issue.prCheckStatus !== "failed") {
-                this.advanceIdleIssue(issue, "awaiting_queue");
+                this.advanceIdleIssue(issue, "awaiting_queue", { clearFailureProvenance: true });
                 continue;
             }
-            // 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);
+            // Checks failed + idle — route based on durable GitHub failure provenance.
+            if (issue.prCheckStatus === "failed") {
+                if (issue.lastGitHubFailureSource === "queue_eviction") {
+                    if (issue.factoryState !== "repairing_queue") {
+                        const pendingRunContext = buildFailureContext(issue);
+                        this.advanceIdleIssue(issue, "repairing_queue", {
+                            pendingRunType: "queue_repair",
+                            ...(pendingRunContext ? { pendingRunContext } : {}),
+                        });
+                    }
+                    continue;
+                }
+                if (issue.lastGitHubFailureSource === "branch_ci") {
+                    if (issue.factoryState !== "repairing_ci") {
+                        const pendingRunContext = buildFailureContext(issue);
+                        this.advanceIdleIssue(issue, "repairing_ci", {
+                            pendingRunType: "ci_repair",
+                            ...(pendingRunContext ? { pendingRunContext } : {}),
+                        });
+                    }
+                    continue;
+                }
+                if (issue.factoryState === "awaiting_queue") {
+                    this.logger.warn({ issueKey: issue.issueKey, prNumber: issue.prNumber }, "Reconciliation skipped failed awaiting_queue issue with unknown failure provenance");
+                    this.feed?.publish({
+                        level: "warn",
+                        kind: "github",
+                        issueKey: issue.issueKey,
+                        projectId: issue.projectId,
+                        stage: issue.factoryState,
+                        status: "failure_source_unknown",
+                        summary: "Reconciliation saw failed checks but could not determine whether the failure came from CI or the merge queue",
+                    });
+                    continue;
+                }
+                if (issue.factoryState !== "repairing_ci") {
+                    const pendingRunContext = buildFailureContext(issue);
+                    this.advanceIdleIssue(issue, "repairing_ci", {
+                        pendingRunType: "ci_repair",
+                        ...(pendingRunContext ? { pendingRunContext } : {}),
+                    });
+                }
                 continue;
             }
             // For pr_open issues with no review decision, check GitHub for stale metadata
@@ -547,25 +592,38 @@ export class RunOrchestrator {
             const pr = JSON.parse(stdout);
             if (pr.state === "MERGED") {
                 this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "merged" });
-                this.advanceIdleIssue(issue, "done");
+                this.advanceIdleIssue(issue, "done", { clearFailureProvenance: true });
             }
             else if (pr.reviewDecision === "APPROVED") {
                 this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prReviewState: "approved" });
-                this.advanceIdleIssue(issue, "awaiting_queue");
+                this.advanceIdleIssue(issue, "awaiting_queue", { clearFailureProvenance: true });
             }
         }
         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");
+    advanceIdleIssue(issue, newState, options) {
+        this.logger.info({ issueKey: issue.issueKey, from: issue.factoryState, to: newState, pendingRunType: options?.pendingRunType }, "Reconciliation: advancing idle issue");
         this.db.upsertIssue({
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             factoryState: newState,
-            ...(newState === "awaiting_queue" ? { pendingMergePrep: true } : {}),
-            ...(pendingRunType ? { pendingRunType: pendingRunType } : {}),
+            ...(options?.pendingRunType ? { pendingRunType: options.pendingRunType } : {}),
+            ...(options?.pendingRunType
+                ? {
+                    pendingRunContextJson: options.pendingRunContext ? JSON.stringify(options.pendingRunContext) : null,
+                }
+                : {}),
+            ...(options?.clearFailureProvenance
+                ? {
+                    lastGitHubFailureSource: null,
+                    lastGitHubFailureCheckName: null,
+                    lastGitHubFailureCheckUrl: null,
+                    lastGitHubFailureAt: null,
+                    lastQueueIncidentJson: null,
+                }
+                : {}),
         });
         this.feed?.publish({
             level: "info",
@@ -576,7 +634,10 @@ export class RunOrchestrator {
             status: "reconciled",
             summary: `Reconciliation: ${issue.factoryState} \u2192 ${newState}`,
         });
-        if (newState === "awaiting_queue" || pendingRunType) {
+        if (newState === "awaiting_queue") {
+            this.requestMergeQueueAdmission(issue, issue.projectId);
+        }
+        if (options?.pendingRunType) {
             this.enqueueIssue(issue.projectId, issue.linearIssueId);
         }
     }
@@ -752,7 +813,15 @@ export class RunOrchestrator {
                     linearIssueId: run.linearIssueId,
                     activeRunId: null,
                     ...(postRunState ? { factoryState: postRunState } : {}),
-                    ...(postRunState === "awaiting_queue" ? { pendingMergePrep: true } : {}),
+                    ...(postRunState === "awaiting_queue" || postRunState === "done"
+                        ? {
+                            lastGitHubFailureSource: null,
+                            lastGitHubFailureCheckName: null,
+                            lastGitHubFailureCheckUrl: null,
+                            lastGitHubFailureAt: null,
+                            lastQueueIncidentJson: null,
+                        }
+                        : {}),
                 });
             });
             if (postRunState) {
@@ -767,7 +836,7 @@ export class RunOrchestrator {
                 });
             }
             if (postRunState === "awaiting_queue") {
-                this.enqueueIssue(run.projectId, run.linearIssueId);
+                this.requestMergeQueueAdmission(issue, run.projectId);
             }
         }
     }
@@ -801,6 +870,17 @@ export class RunOrchestrator {
         });
         void this.syncLinearSession(escalatedIssue);
     }
+    /** Add the merge queue admission label for external-queue projects (best-effort). */
+    requestMergeQueueAdmission(issue, projectId) {
+        const project = this.config.projects.find((p) => p.id === projectId);
+        const protocol = resolveMergeQueueProtocol(project);
+        void requestMergeQueueAdmission({
+            issue,
+            protocol,
+            logger: this.logger,
+            feed: this.feed,
+        });
+    }
     failRunAndClear(run, message) {
         this.db.transaction(() => {
             this.db.finishRun(run.id, { status: "failed", failureReason: message });
@@ -929,3 +1009,99 @@ function resolvePostRunState(issue) {
     }
     return undefined;
 }
+function buildFailureContext(issue) {
+    const queueRepairContext = issue.lastQueueIncidentJson
+        ? parseStoredQueueRepairContext(issue.lastQueueIncidentJson)
+        : undefined;
+    if (!queueRepairContext
+        && !issue.lastGitHubFailureSource
+        && !issue.lastGitHubFailureCheckName
+        && !issue.lastGitHubFailureCheckUrl) {
+        return undefined;
+    }
+    return {
+        ...(issue.lastGitHubFailureSource ? { failureReason: issue.lastGitHubFailureSource } : {}),
+        ...(issue.lastGitHubFailureCheckName ? { checkName: issue.lastGitHubFailureCheckName } : {}),
+        ...(issue.lastGitHubFailureCheckUrl ? { checkUrl: issue.lastGitHubFailureCheckUrl } : {}),
+        ...(queueRepairContext ? queueRepairContext : {}),
+    };
+}
+function appendQueueRepairContext(lines, context) {
+    const incidentTitle = typeof context?.incidentTitle === "string" ? context.incidentTitle.trim() : "";
+    const incidentSummary = typeof context?.incidentSummary === "string" ? context.incidentSummary.trim() : "";
+    const incidentId = typeof context?.incidentId === "string" ? context.incidentId.trim() : "";
+    const incidentUrl = typeof context?.incidentUrl === "string" ? context.incidentUrl.trim() : "";
+    const incidentContext = context?.incidentContext && typeof context.incidentContext === "object"
+        ? context.incidentContext
+        : undefined;
+    const failureClass = typeof incidentContext?.failureClass === "string" ? incidentContext.failureClass : "";
+    const baseSha = typeof incidentContext?.baseSha === "string" ? incidentContext.baseSha : "";
+    const prHeadSha = typeof incidentContext?.prHeadSha === "string" ? incidentContext.prHeadSha : "";
+    const baseBranch = typeof incidentContext?.baseBranch === "string" ? incidentContext.baseBranch : "";
+    const branch = typeof incidentContext?.branch === "string" ? incidentContext.branch : "";
+    const queuePosition = typeof incidentContext?.queuePosition === "number" ? String(incidentContext.queuePosition) : "";
+    const conflictFiles = Array.isArray(incidentContext?.conflictFiles)
+        ? incidentContext.conflictFiles.filter((entry) => typeof entry === "string")
+        : [];
+    const failedChecks = Array.isArray(incidentContext?.failedChecks)
+        ? incidentContext.failedChecks
+            .filter((entry) => Boolean(entry) && typeof entry === "object")
+            .map((entry) => ({
+            name: typeof entry.name === "string" ? entry.name : "unknown",
+            conclusion: typeof entry.conclusion === "string" ? entry.conclusion : "unknown",
+            ...(typeof entry.url === "string" ? { url: entry.url } : {}),
+        }))
+        : [];
+    const retryHistory = Array.isArray(incidentContext?.retryHistory)
+        ? incidentContext.retryHistory
+            .filter((entry) => Boolean(entry) && typeof entry === "object")
+            .map((entry) => ({
+            at: typeof entry.at === "string" ? entry.at : "unknown",
+            baseSha: typeof entry.baseSha === "string" ? entry.baseSha : "unknown",
+            outcome: typeof entry.outcome === "string" ? entry.outcome : "unknown",
+        }))
+        : [];
+    if (!incidentTitle && !incidentSummary && !incidentId && !incidentUrl && !failureClass && !baseSha && !prHeadSha
+        && !queuePosition && conflictFiles.length === 0 && failedChecks.length === 0 && retryHistory.length === 0) {
+        return;
+    }
+    lines.push("## Queue Incident Context", "");
+    if (incidentTitle)
+        lines.push(`Incident: ${incidentTitle}`);
+    if (incidentId)
+        lines.push(`Incident ID: ${incidentId}`);
+    if (incidentUrl)
+        lines.push(`Incident URL: ${incidentUrl}`);
+    if (incidentSummary)
+        lines.push("", incidentSummary, "");
+    if (failureClass)
+        lines.push(`Failure class: ${failureClass}`);
+    if (baseBranch)
+        lines.push(`Base branch: ${baseBranch}`);
+    if (baseSha)
+        lines.push(`Base SHA: ${baseSha}`);
+    if (branch)
+        lines.push(`Queue branch: ${branch}`);
+    if (prHeadSha)
+        lines.push(`Queue branch head SHA: ${prHeadSha}`);
+    if (queuePosition)
+        lines.push(`Queue position at eviction: ${queuePosition}`);
+    if (conflictFiles.length > 0) {
+        lines.push("", "Conflicting files:");
+        for (const file of conflictFiles)
+            lines.push(`- ${file}`);
+    }
+    if (failedChecks.length > 0) {
+        lines.push("", "Failed checks:");
+        for (const check of failedChecks) {
+            lines.push(`- ${check.name} (${check.conclusion})${check.url ? ` ${check.url}` : ""}`);
+        }
+    }
+    if (retryHistory.length > 0) {
+        lines.push("", "Retry history:");
+        for (const retry of retryHistory) {
+            lines.push(`- ${retry.at}: ${retry.outcome} on base ${retry.baseSha}`);
+        }
+    }
+    lines.push("");
+}

package/dist/runtime-paths.js

@@ -27,8 +27,6 @@ export function getPatchRelayPathLayout() {
         logFilePath: ensureAbsolutePath(process.env.PATCHRELAY_LOG_FILE ?? path.join(stateDir, "patchrelay.log")),
         systemdDir,
         systemdUnitPath: path.join(systemdDir, "patchrelay.service"),
-        systemdReloadUnitPath: path.join(systemdDir, "patchrelay-reload.service"),
-        systemdPathUnitPath: path.join(systemdDir, "patchrelay.path"),
     };
 }
 export function getPatchRelayConfigDir() {
@@ -61,12 +59,6 @@ export function getDefaultWebhookArchiveDir() {
 export function getSystemdUnitPath() {
     return getPatchRelayPathLayout().systemdUnitPath;
 }
-export function getSystemdReloadUnitPath() {
-    return getPatchRelayPathLayout().systemdReloadUnitPath;
-}
-export function getSystemdPathUnitPath() {
-    return getPatchRelayPathLayout().systemdPathUnitPath;
-}
 export function getPackageRoot() {
     return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 }

package/dist/service.js

@@ -1,8 +1,8 @@
 import { resolveGitHubAppCredentials, createGitHubAppTokenManager, ensureGhWrapper, } from "./github-app-token.js";
 import { GitHubWebhookHandler } from "./github-webhook-handler.js";
 import { IssueQueryService } from "./issue-query-service.js";
+import { DatabaseBackedLinearClientProvider } from "./linear-client.js";
 import { LinearOAuthService } from "./linear-oauth-service.js";
-import { MergeQueue } from "./merge-queue.js";
 import { RunOrchestrator } from "./run-orchestrator.js";
 import { OperatorEventFeed } from "./operator-feed.js";
 import { buildSessionStatusUrl, createSessionStatusToken, deriveSessionStatusSigningSecret, verifySessionStatusToken, } from "./public-agent-session-status.js";
@@ -41,7 +41,6 @@ export class PatchRelayService {
     logger;
     linearProvider;
     orchestrator;
-    mergeQueue;
     githubAppTokenManager;
     webhookHandler;
     githubWebhookHandler;
@@ -60,56 +59,16 @@ export class PatchRelayService {
             throw new Error("Service runtime enqueueIssue is not initialized");
         };
         this.orchestrator = new RunOrchestrator(config, db, codex, this.linearProvider, (projectId, issueId) => enqueueIssue(projectId, issueId), logger, this.feed);
-        this.mergeQueue = new MergeQueue(config, db, (projectId, issueId) => enqueueIssue(projectId, issueId), logger, this.feed, (issue, content, options) => {
-            if (!issue.agentSessionId)
-                return;
-            void (async () => {
-                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);
-                    logger.warn({ issueKey: issue.issueKey, type: content.type, error: msg }, "Failed to emit merge-prep Linear activity");
-                }
-            })();
-        });
         this.webhookHandler = new WebhookHandler(config, db, this.linearProvider, codex, (projectId, issueId) => enqueueIssue(projectId, issueId), logger, this.feed);
-        this.githubWebhookHandler = new GitHubWebhookHandler(config, db, this.linearProvider, (projectId, issueId) => enqueueIssue(projectId, issueId), this.mergeQueue, logger, codex, this.feed);
+        this.githubWebhookHandler = new GitHubWebhookHandler(config, db, this.linearProvider, (projectId, issueId) => enqueueIssue(projectId, issueId), logger, codex, this.feed);
         const runtime = new ServiceRuntime(codex, logger, this.orchestrator, { listIssuesReadyForExecution: () => db.listIssuesReadyForExecution() }, this.webhookHandler, {
             processIssue: async (item) => {
-                const issue = db.getIssue(item.projectId, item.issueId);
-                // Repairs take priority over merge prep — a check_failed or
-                // review_changes_requested that arrived while merge prep was
-                // queued must not be swallowed.
-                if (issue?.pendingRunType) {
-                    await this.orchestrator.run(item);
-                    return;
-                }
-                if (issue?.pendingMergePrep) {
-                    const project = config.projects.find((p) => p.id === item.projectId);
-                    if (project)
-                        await this.mergeQueue.prepareForMerge(issue, project);
-                    // Re-check: a repair run may have been enqueued during prep
-                    const after = db.getIssue(item.projectId, item.issueId);
-                    if (after?.pendingRunType) {
-                        runtime.enqueueIssue(item.projectId, item.issueId);
-                    }
-                    return;
-                }
                 await this.orchestrator.run(item);
             },
         });
         enqueueIssue = (projectId, issueId) => runtime.enqueueIssue(projectId, issueId);
         this.oauthService = new LinearOAuthService(config, { linearInstallations: db.linearInstallations }, logger);
-        this.queryService = new IssueQueryService(db, codex, this.orchestrator);
+        this.queryService = new IssueQueryService(config, db, codex, this.orchestrator);
         this.runtime = runtime;
         // Optional GitHub App token management for bot identity
         const ghAppCredentials = resolveGitHubAppCredentials();
@@ -127,7 +86,7 @@ export class PatchRelayService {
     async start() {
         // Verify Linear connectivity for all configured projects before starting.
         // Auth errors do not prevent startup (the OAuth callback must be reachable
-        // for `patchrelay connect`), but the service reports NOT READY until at
+        // for `patchrelay linear connect`), but the service reports NOT READY until at
         // least one project has a working Linear token.
         let anyLinearConnected = false;
         for (const project of this.config.projects) {
@@ -137,17 +96,17 @@ export class PatchRelayService {
                     anyLinearConnected = true;
                 }
                 else {
-                    this.logger.warn({ projectId: project.id }, "No Linear installation linked — run 'patchrelay connect' to authorize");
+                    this.logger.warn({ projectId: project.id }, "No Linear installation linked — run 'patchrelay linear connect' and then 'patchrelay repo link' to authorize");
                 }
             }
             catch (error) {
                 const msg = error instanceof Error ? error.message : String(error);
-                this.logger.error({ projectId: project.id, error: msg }, "Linear auth failed — run 'patchrelay connect' to refresh the token. Runs for this project will fail until re-authorized.");
+                this.logger.error({ projectId: project.id, error: msg }, "Linear auth failed — run 'patchrelay linear connect' to refresh the token. Runs for this project will fail until re-authorized.");
             }
         }
         this.runtime.setLinearConnected(anyLinearConnected);
         if (!anyLinearConnected && this.config.projects.length > 0) {
-            this.logger.error("No projects have working Linear auth — service is NOT READY. Run 'patchrelay connect' to authorize.");
+            this.logger.error("No projects have working Linear auth — service is NOT READY. Run 'patchrelay linear connect' to authorize.");
         }
         if (this.githubAppTokenManager) {
             await ensureGhWrapper(this.logger);
@@ -158,7 +117,6 @@ export class PatchRelayService {
             }
         }
         await this.runtime.start();
-        this.mergeQueue.seedOnStartup();
     }
     async stop() {
         this.githubAppTokenManager?.stop();
@@ -167,6 +125,9 @@ export class PatchRelayService {
     async createLinearOAuthStart(params) {
         return await this.oauthService.createStart(params);
     }
+    async createLinearWorkspaceOAuthStart() {
+        return await this.oauthService.createStart();
+    }
     async completeLinearOAuth(params) {
         const result = await this.oauthService.complete(params);
         // A successful OAuth completion means at least one project now has
@@ -180,6 +141,71 @@ export class PatchRelayService {
     listLinearInstallations() {
         return this.oauthService.listInstallations();
     }
+    listLinearWorkspaces() {
+        return this.db.linearInstallations.listLinearInstallations().map((installation) => {
+            const linkedRepos = this.config.repositories
+                .filter((repository) => repository.workspace && workspaceMatches(repository.workspace, installation))
+                .map((repository) => repository.githubRepo);
+            const teams = this.db.repositories.listCatalogTeams(installation.id).map((team) => ({
+                id: team.teamId,
+                ...(team.key ? { key: team.key } : {}),
+                ...(team.name ? { name: team.name } : {}),
+            }));
+            const projects = this.db.repositories.listCatalogProjects(installation.id).map((project) => ({
+                id: project.projectId,
+                ...(project.name ? { name: project.name } : {}),
+                teamIds: parseStringArray(project.teamIdsJson),
+            }));
+            return {
+                installation: this.oauthService.getInstallationSummary(installation),
+                linkedRepos,
+                teams,
+                projects,
+            };
+        });
+    }
+    async syncLinearWorkspace(workspace) {
+        const installation = workspace
+            ? this.db.linearInstallations.findLinearInstallationByWorkspace(workspace)
+            : this.db.linearInstallations.listLinearInstallations()[0];
+        if (!installation) {
+            throw new Error(workspace ? `Workspace not found: ${workspace}` : "No Linear workspace connected");
+        }
+        const provider = this.linearProvider instanceof DatabaseBackedLinearClientProvider ? this.linearProvider : undefined;
+        if (!provider) {
+            throw new Error("Linear provider does not support installation sync");
+        }
+        const client = await provider.forInstallationId(installation.id);
+        if (!client) {
+            throw new Error(`Linear installation ${installation.id} is unavailable`);
+        }
+        const catalog = await client.getWorkspaceCatalog();
+        this.db.repositories.replaceCatalog({
+            installationId: installation.id,
+            teams: catalog.teams,
+            projects: catalog.projects,
+        });
+        return {
+            installation: this.oauthService.getInstallationSummary(installation),
+            teams: catalog.teams,
+            projects: catalog.projects,
+        };
+    }
+    disconnectLinearWorkspace(workspace) {
+        const installation = this.db.linearInstallations.findLinearInstallationByWorkspace(workspace);
+        if (!installation) {
+            throw new Error(`Workspace not found: ${workspace}`);
+        }
+        this.db.transaction(() => {
+            this.db.linearInstallations.unlinkInstallationProjects(installation.id);
+            this.db.connection.prepare("DELETE FROM linear_catalog_teams WHERE installation_id = ?").run(installation.id);
+            this.db.connection.prepare("DELETE FROM linear_catalog_projects WHERE installation_id = ?").run(installation.id);
+            this.db.linearInstallations.deleteLinearInstallation(installation.id);
+        });
+        return {
+            installation: this.oauthService.getInstallationSummary(installation),
+        };
+    }
     getReadiness() {
         return this.runtime.getReadiness();
     }
@@ -492,3 +518,22 @@ function toLinearClientProvider(linear) {
         },
     };
 }
+function parseStringArray(value) {
+    if (!value)
+        return [];
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) ? parsed.filter((entry) => typeof entry === "string") : [];
+    }
+    catch {
+        return [];
+    }
+}
+function workspaceMatches(workspace, installation) {
+    const normalized = workspace.trim().toLowerCase();
+    return [
+        installation.workspaceKey,
+        installation.workspaceName,
+        installation.workspaceId,
+    ].some((value) => value?.trim().toLowerCase() === normalized);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchrelay",
-  "version": "0.26.0",
+  "version": "0.29.1",
   "license": "MIT",
   "type": "module",
   "repository": {
@@ -18,14 +18,15 @@
     "runtime.env.example",
     "service.env.example",
     "config/patchrelay.example.json",
-    "infra/patchrelay.service",
-    "infra/patchrelay-reload.service",
-    "infra/patchrelay.path"
+    "infra/patchrelay.service"
   ],
   "description": "Self-hosted harness for Linear-driven Codex work with durable issue worktrees, staged runs, and inspection.",
   "engines": {
     "node": ">=24.0.0"
   },
+  "workspaces": [
+    "packages/merge-steward"
+  ],
   "scripts": {
     "dev": "node --watch --experimental-transform-types src/index.ts",
     "build": "rm -rf dist && tsc -p tsconfig.json && chmod +x dist/index.js && node scripts/write-build-info.mjs",
@@ -51,10 +52,10 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@types/node": "^24.12.0",
+    "@types/node": "^25.5.0",
     "@types/react": "^19.2.14",
     "eslint": "^10.0.3",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.57.0"
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.58.0"
   }
 }

package/dist/cli/commands/connect.js

@@ -1,54 +0,0 @@
-import { runConnectFlow, parseTimeoutSeconds } from "../connect-flow.js";
-import { formatJson } from "../formatters/json.js";
-import { openExternalUrl } from "../interactive.js";
-import { writeOutput } from "../output.js";
-export async function handleConnectCommand(params) {
-    return await runConnectFlow({
-        config: params.config,
-        data: params.data,
-        stdout: params.stdout,
-        noOpen: params.parsed.flags.get("no-open") === true,
-        timeoutSeconds: parseTimeoutSeconds(params.parsed.flags.get("timeout"), "connect"),
-        json: params.json,
-        openExternal: params.options?.openExternal ?? openExternalUrl,
-        ...(params.options?.connectPollIntervalMs !== undefined ? { connectPollIntervalMs: params.options.connectPollIntervalMs } : {}),
-        ...(typeof params.parsed.flags.get("project") === "string" ? { projectId: String(params.parsed.flags.get("project")) } : {}),
-    });
-}
-export async function handleInstallationsCommand(params) {
-    const result = await params.data.listInstallations();
-    if (params.json) {
-        writeOutput(params.stdout, formatJson({
-            ...result,
-            installations: result.installations.map((item) => ({
-                ...item,
-                projects: item.linkedProjects.map((id) => {
-                    const p = params.config.projects.find((proj) => proj.id === id);
-                    return p ? { id: p.id, repoPath: p.repoPath, issueKeyPrefixes: p.issueKeyPrefixes, linearTeamIds: p.linearTeamIds } : { id };
-                }),
-            })),
-        }));
-        return 0;
-    }
-    if (result.installations.length === 0) {
-        writeOutput(params.stdout, "No installations found.\n");
-        return 0;
-    }
-    const lines = [];
-    for (const item of result.installations) {
-        const label = item.installation.workspaceName ?? item.installation.actorName ?? "-";
-        lines.push(`${item.installation.id}  ${label}  projects=${item.linkedProjects.join(",") || "-"}`);
-        for (const projectId of item.linkedProjects) {
-            const p = params.config.projects.find((proj) => proj.id === projectId);
-            if (!p)
-                continue;
-            const routing = [
-                ...(p.issueKeyPrefixes.length > 0 ? [`prefixes=${p.issueKeyPrefixes.join(",")}`] : []),
-                ...(p.linearTeamIds.length > 0 ? [`teams=${p.linearTeamIds.join(",")}`] : []),
-            ].join(" ") || "no routing";
-            lines.push(`     ${projectId}  ${p.repoPath}  ${routing}`);
-        }
-    }
-    writeOutput(params.stdout, `${lines.join("\n")}\n`);
-    return 0;
-}