patchrelay 0.26.0 → 0.29.1

package/dist/github-webhook-handler.js

@@ -3,6 +3,8 @@ import { normalizeGitHubWebhook, verifyGitHubWebhookSignature } from "./github-w
 import { buildAgentSessionPlanForIssue } from "./agent-session-plan.js";
 import { buildAgentSessionExternalUrls } from "./agent-session-presentation.js";
 import { buildGitHubStateActivity } from "./linear-session-reporting.js";
+import { requestMergeQueueAdmission, resolveMergeQueueProtocol, } from "./merge-queue-protocol.js";
+import { buildQueueRepairContextFromEvent } from "./merge-queue-incident.js";
 import { resolveSecret } from "./resolve-secret.js";
 import { safeJsonParse } from "./utils.js";
 /**
@@ -23,16 +25,14 @@ export class GitHubWebhookHandler {
     db;
     linearProvider;
     enqueueIssue;
-    mergeQueue;
     logger;
     codex;
     feed;
-    constructor(config, db, linearProvider, enqueueIssue, mergeQueue, logger, codex, feed) {
+    constructor(config, db, linearProvider, enqueueIssue, logger, codex, feed) {
         this.config = config;
         this.db = db;
         this.linearProvider = linearProvider;
         this.enqueueIssue = enqueueIssue;
-        this.mergeQueue = mergeQueue;
         this.logger = logger;
         this.codex = codex;
         this.feed = feed;
@@ -92,13 +92,7 @@ export class GitHubWebhookHandler {
             const ref = pushPayload.ref;
             const repoFullName = pushPayload.repository?.full_name;
             if (ref && repoFullName) {
-                const branchName = ref.replace("refs/heads/", "");
-                for (const project of this.config.projects) {
-                    const baseBranch = project.github?.baseBranch ?? "main";
-                    if (project.github?.repoFullName === repoFullName && branchName === baseBranch) {
-                        this.mergeQueue.advanceQueue(project.id);
-                    }
-                }
+                // Push to base branch — external merge queue handles advancement.
             }
             return;
         }
@@ -130,6 +124,7 @@ export class GitHubWebhookHandler {
             ...(event.reviewState !== undefined ? { prReviewState: event.reviewState } : {}),
             ...(event.checkStatus !== undefined ? { prCheckStatus: event.checkStatus } : {}),
         });
+        this.updateFailureProvenance(issue, event);
         if (!isMetadataOnlyCheckEvent(event)) {
             // Re-read issue after PR metadata upsert so guards see fresh prReviewState
             const afterMetadata = this.db.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
@@ -151,24 +146,16 @@ export class GitHubWebhookHandler {
                 void this.syncLinearSession(transitionedIssue);
                 // Schedule merge prep when entering awaiting_queue
                 if (newState === "awaiting_queue") {
-                    this.db.upsertIssue({
-                        projectId: issue.projectId,
-                        linearIssueId: issue.linearIssueId,
-                        pendingMergePrep: true,
+                    const proj = this.config.projects.find((p) => p.id === issue.projectId);
+                    const protocol = resolveMergeQueueProtocol(proj);
+                    void requestMergeQueueAdmission({
+                        issue: transitionedIssue,
+                        protocol,
+                        logger: this.logger,
+                        feed: this.feed,
                     });
-                    this.enqueueIssue(issue.projectId, issue.linearIssueId);
-                }
-                // Advance the merge queue when a PR merges
-                if (newState === "done" && event.triggerEvent === "pr_merged") {
-                    this.mergeQueue.advanceQueue(issue.projectId);
                 }
             }
-            // Advance the merge queue even when the state transition was suppressed
-            // (e.g., pr_merged during an active run). The PR is factually merged —
-            // the next queued issue should not wait for the active run to finish.
-            if (!newState && event.triggerEvent === "pr_merged") {
-                this.mergeQueue.advanceQueue(issue.projectId);
-            }
         }
         // Re-read issue after all upserts so reactive run logic sees current state
         const freshIssue = this.db.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
@@ -180,6 +167,11 @@ export class GitHubWebhookHandler {
                 linearIssueId: issue.linearIssueId,
                 ciRepairAttempts: 0,
                 queueRepairAttempts: 0,
+                lastGitHubFailureSource: null,
+                lastGitHubFailureCheckName: null,
+                lastGitHubFailureCheckUrl: null,
+                lastGitHubFailureAt: null,
+                lastQueueIncidentJson: null,
             });
         }
         this.logger.info({ issueKey: issue.issueKey, branchName: event.branchName, triggerEvent: event.triggerEvent, prNumber: event.prNumber }, "GitHub webhook: updated issue PR state");
@@ -193,8 +185,15 @@ export class GitHubWebhookHandler {
             summary: `GitHub: ${event.triggerEvent}${event.prNumber ? ` on PR #${event.prNumber}` : ""}`,
             detail: event.checkName ?? event.reviewBody?.slice(0, 200) ?? undefined,
         });
-        if (!isMetadataOnlyCheckEvent(event)) {
-            const project = this.config.projects.find((p) => p.id === freshIssue.projectId);
+        // Queue eviction check runs bypass the metadata-only filter because
+        // they're individual check_run events (not check_suite), but they
+        // must drive state transitions.
+        const project = this.config.projects.find((p) => p.id === freshIssue.projectId);
+        const protocol = resolveMergeQueueProtocol(project);
+        if (event.eventSource === "check_run" && event.checkName === protocol.evictionCheckName) {
+            this.maybeEnqueueReactiveRun(freshIssue, event, project);
+        }
+        else if (!isMetadataOnlyCheckEvent(event)) {
             this.maybeEnqueueReactiveRun(freshIssue, event, project);
         }
     }
@@ -207,18 +206,57 @@ export class GitHubWebhookHandler {
         if (TERMINAL_STATES.has(issue.factoryState))
             return;
         if (event.triggerEvent === "check_failed" && issue.prState === "open") {
-            this.db.upsertIssue({
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                pendingRunType: "ci_repair",
-                pendingRunContextJson: JSON.stringify({
-                    checkName: event.checkName,
-                    checkUrl: event.checkUrl,
-                    checkClass: resolveCheckClass(event.checkName, project),
-                }),
-            });
-            this.enqueueIssue(issue.projectId, issue.linearIssueId);
-            this.logger.info({ issueKey: issue.issueKey, checkName: event.checkName }, "Enqueued CI repair run");
+            // External merge queue eviction: react only to the configured check
+            // name, not to any CI failure. Regular CI failures still get ci_repair.
+            const protocol = resolveMergeQueueProtocol(project);
+            const queueCheckName = protocol.evictionCheckName;
+            if (issue.factoryState === "awaiting_queue"
+                && event.checkName === queueCheckName) {
+                const queueRepairContext = buildQueueRepairContextFromEvent(event);
+                this.db.upsertIssue({
+                    projectId: issue.projectId,
+                    linearIssueId: issue.linearIssueId,
+                    pendingRunType: "queue_repair",
+                    pendingRunContextJson: JSON.stringify(queueRepairContext),
+                    lastGitHubFailureSource: "queue_eviction",
+                    lastGitHubFailureCheckName: event.checkName ?? null,
+                    lastGitHubFailureCheckUrl: event.checkUrl ?? null,
+                    lastGitHubFailureAt: new Date().toISOString(),
+                    lastQueueSignalAt: new Date().toISOString(),
+                    lastQueueIncidentJson: JSON.stringify(queueRepairContext),
+                });
+                this.enqueueIssue(issue.projectId, issue.linearIssueId);
+                this.logger.info({ issueKey: issue.issueKey, checkName: event.checkName }, "Queue eviction detected, enqueued queue repair");
+                this.feed?.publish({
+                    level: "warn",
+                    kind: "github",
+                    issueKey: issue.issueKey,
+                    projectId: issue.projectId,
+                    stage: "repairing_queue",
+                    status: "queue_repair_queued",
+                    summary: `Queue repair queued after external failure from ${event.checkName}`,
+                    detail: queueRepairContext.incidentSummary ?? queueRepairContext.incidentUrl ?? event.checkUrl,
+                });
+            }
+            else {
+                this.db.upsertIssue({
+                    projectId: issue.projectId,
+                    linearIssueId: issue.linearIssueId,
+                    pendingRunType: "ci_repair",
+                    pendingRunContextJson: JSON.stringify({
+                        checkName: event.checkName,
+                        checkUrl: event.checkUrl,
+                        checkClass: resolveCheckClass(event.checkName, project),
+                    }),
+                    lastGitHubFailureSource: "branch_ci",
+                    lastGitHubFailureCheckName: event.checkName ?? null,
+                    lastGitHubFailureCheckUrl: event.checkUrl ?? null,
+                    lastGitHubFailureAt: new Date().toISOString(),
+                    lastQueueIncidentJson: null,
+                });
+                this.enqueueIssue(issue.projectId, issue.linearIssueId);
+                this.logger.info({ issueKey: issue.issueKey, checkName: event.checkName }, "Enqueued CI repair run");
+            }
         }
         if (event.triggerEvent === "review_changes_requested") {
             this.db.upsertIssue({
@@ -233,17 +271,48 @@ export class GitHubWebhookHandler {
             this.enqueueIssue(issue.projectId, issue.linearIssueId);
             this.logger.info({ issueKey: issue.issueKey, reviewerName: event.reviewerName }, "Enqueued review fix run");
         }
-        if (event.triggerEvent === "merge_group_failed") {
+    }
+    updateFailureProvenance(issue, event) {
+        const project = this.config.projects.find((p) => p.id === issue.projectId);
+        const protocol = resolveMergeQueueProtocol(project);
+        const isQueueEvictionCheck = event.eventSource === "check_run" && event.checkName === protocol.evictionCheckName;
+        if (event.triggerEvent === "check_failed" && issue.prState === "open") {
+            if (isMetadataOnlyCheckEvent(event) && !isQueueEvictionCheck) {
+                return;
+            }
+            const source = issue.factoryState === "awaiting_queue" && isQueueEvictionCheck
+                ? "queue_eviction"
+                : "branch_ci";
+            this.db.upsertIssue({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                lastGitHubFailureSource: source,
+                lastGitHubFailureCheckName: event.checkName ?? null,
+                lastGitHubFailureCheckUrl: event.checkUrl ?? null,
+                lastGitHubFailureAt: new Date().toISOString(),
+                ...(source === "queue_eviction"
+                    ? {
+                        lastQueueSignalAt: new Date().toISOString(),
+                        lastQueueIncidentJson: JSON.stringify(buildQueueRepairContextFromEvent(event)),
+                    }
+                    : {
+                        lastQueueIncidentJson: null,
+                    }),
+            });
+            return;
+        }
+        if ((event.triggerEvent === "check_passed" && (!isMetadataOnlyCheckEvent(event) || isQueueEvictionCheck))
+            || event.triggerEvent === "pr_synchronize"
+            || event.triggerEvent === "pr_merged") {
             this.db.upsertIssue({
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
-                pendingRunType: "queue_repair",
-                pendingRunContextJson: JSON.stringify({
-                    failureReason: event.mergeGroupFailureReason,
-                }),
+                lastGitHubFailureSource: null,
+                lastGitHubFailureCheckName: null,
+                lastGitHubFailureCheckUrl: null,
+                lastGitHubFailureAt: null,
+                lastQueueIncidentJson: null,
             });
-            this.enqueueIssue(issue.projectId, issue.linearIssueId);
-            this.logger.info({ issueKey: issue.issueKey }, "Enqueued merge queue repair run");
         }
     }
     async emitLinearActivity(issue, newState, event) {

package/dist/github-webhooks.js

@@ -141,6 +141,10 @@ function normalizeCheckRunEvent(payload, repoFullName) {
         checkStatus: passed ? "success" : "failure",
         checkName: run.name,
         checkUrl: run.html_url,
+        checkDetailsUrl: run.details_url,
+        checkOutputTitle: run.output?.title,
+        checkOutputSummary: run.output?.summary,
+        checkOutputText: run.output?.text,
         eventSource: "check_run",
     };
 }

package/dist/http.js

@@ -2,6 +2,8 @@ import fastify from "fastify";
 import rawBody from "fastify-raw-body";
 import { getBuildInfo } from "./build-info.js";
 import { matchesOperatorFeedEvent } from "./operator-feed.js";
+import { buildStateHistory } from "./cli/watch/history-builder.js";
+import { buildPatchRelayQueueObservations, buildPatchRelayStateGraph } from "./cli/watch/state-visualization.js";
 export async function buildHttpServer(config, service, logger) {
     const buildInfo = getBuildInfo();
     const loopbackBind = isLoopbackBind(config.server.bind);
@@ -422,6 +424,19 @@ export async function buildHttpServer(config, service, logger) {
         app.get("/api/installations", async (_request, reply) => {
             return reply.send({ ok: true, installations: service.listLinearInstallations() });
         });
+        app.get("/api/linear/workspaces", async (_request, reply) => {
+            return reply.send({ ok: true, workspaces: service.listLinearWorkspaces() });
+        });
+        app.post("/api/linear/workspaces/sync", async (request, reply) => {
+            const workspace = getQueryParam(request, "workspace");
+            const result = await service.syncLinearWorkspace(workspace ?? undefined);
+            return reply.send({ ok: true, ...result });
+        });
+        app.delete("/api/linear/workspaces/:workspace", async (request, reply) => {
+            const { workspace } = request.params;
+            const result = service.disconnectLinearWorkspace(workspace);
+            return reply.send({ ok: true, ...result });
+        });
         app.get("/api/oauth/linear/start", async (request, reply) => {
             const projectId = getQueryParam(request, "projectId");
             const result = await service.createLinearOAuthStart(projectId ? { projectId } : undefined);
@@ -585,6 +600,23 @@ function renderAgentSessionStatusPage(params) {
     const checkState = params.sessionStatus.issue.prCheckStatus ?? "unknown";
     const ciAttempts = params.sessionStatus.issue.ciRepairAttempts ?? 0;
     const queueAttempts = params.sessionStatus.issue.queueRepairAttempts ?? 0;
+    const queueProtocol = params.sessionStatus.issue.queueProtocol;
+    const history = buildPublicStateHistory({
+        currentFactoryState: factoryState,
+        activeRunId: params.sessionStatus.activeRunId ?? null,
+        ...(params.sessionStatus.feedEvents ? { feedEvents: params.sessionStatus.feedEvents } : {}),
+        runs: params.sessionStatus.runs,
+    });
+    const graph = buildPatchRelayStateGraph(history, factoryState);
+    const queueObservations = buildPatchRelayQueueObservations({
+        factoryState,
+        ...(params.sessionStatus.activeRun?.runType ? { activeRunType: params.sessionStatus.activeRun.runType } : {}),
+        ...(params.sessionStatus.issue.prNumber !== undefined ? { prNumber: params.sessionStatus.issue.prNumber } : {}),
+        ...(params.sessionStatus.issue.prReviewState ? { prReviewState: params.sessionStatus.issue.prReviewState } : {}),
+    }, normalizeFeedEvents(params.sessionStatus.feedEvents));
+    const pathHtml = renderStatePath(history, factoryState);
+    const graphHtml = renderStateGraph(graph.main, graph.prLoops, graph.queueLoop, graph.exits);
+    const observationsHtml = renderObservationList(queueObservations);
     return `<!doctype html>
 <html lang="en">
   <head>
@@ -630,6 +662,20 @@ function renderAgentSessionStatusPage(params) {
       .chip { border: 1px solid var(--line); border-radius: 999px; padding: 9px 14px; background: rgba(255,255,255,0.74); font-size: 14px; }
       .section { margin-top: 24px; padding-top: 18px; border-top: 1px solid var(--line); }
       .section h2 { margin: 0; font-size: 22px; }
+      .grid { display: grid; gap: 18px; grid-template-columns: repeat(auto-fit, minmax(260px, 1fr)); margin-top: 14px; }
+      .card { border: 1px solid var(--line); border-radius: 18px; background: rgba(255,255,255,0.56); padding: 16px; }
+      .card h3 { margin: 0 0 10px; font-size: 16px; }
+      .graph-row { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; margin-top: 8px; }
+      .graph-connector { color: var(--muted); }
+      .node { display: inline-flex; border-radius: 999px; padding: 6px 10px; font-size: 13px; border: 1px solid var(--line); background: rgba(255,255,255,0.72); }
+      .node.current { border-color: rgba(31,109,87,0.45); background: rgba(31,109,87,0.12); color: #164c3d; }
+      .node.visited { border-color: rgba(31,109,87,0.28); color: #275546; }
+      .node.upcoming { color: #6f695f; }
+      .path-list, .observation-list { margin: 0; padding-left: 18px; color: var(--muted); }
+      .path-list li, .observation-list li { margin-top: 8px; }
+      .tone-warn { color: #8d5c10; }
+      .tone-success { color: #1f6d57; }
+      .tone-info { color: var(--muted); }
       table { width: 100%; border-collapse: collapse; margin-top: 14px; }
       th, td { text-align: left; border-bottom: 1px solid var(--line); padding: 10px 8px; vertical-align: top; }
       th { font-size: 12px; text-transform: uppercase; letter-spacing: 0.08em; color: #5f594e; }
@@ -657,6 +703,14 @@ function renderAgentSessionStatusPage(params) {
             <tr><th>Pull request</th><td>${escapeHtml(prLabel ?? "none")} (${escapeHtml(prState)})</td></tr>
             <tr><th>Review</th><td>${escapeHtml(reviewState)}</td></tr>
             <tr><th>Checks</th><td>${escapeHtml(checkState)}</td></tr>
+            <tr><th>Queue label</th><td><code>${escapeHtml(queueProtocol?.admissionLabel ?? "queue")}</code></td></tr>
+            <tr><th>Queue check</th><td><code>${escapeHtml(queueProtocol?.evictionCheckName ?? "merge-steward/queue")}</code></td></tr>
+            <tr><th>Last queue signal</th><td><code>${escapeHtml(queueProtocol?.lastQueueSignalAt ?? queueProtocol?.lastFailureAt ?? "none")}</code></td></tr>
+            <tr><th>Last queue incident</th><td>${queueProtocol?.lastIncidentUrl
+        ? `<a href="${escapeHtml(queueProtocol.lastIncidentUrl)}" target="_blank" rel="noopener noreferrer">${escapeHtml(queueProtocol.lastIncidentId ?? queueProtocol.lastIncidentUrl)}</a>`
+        : escapeHtml(queueProtocol?.lastIncidentId ?? "none")}</td></tr>
+            <tr><th>Queue failure class</th><td><code>${escapeHtml(queueProtocol?.lastIncidentFailureClass ?? "unknown")}</code></td></tr>
+            <tr><th>Queue incident summary</th><td>${escapeHtml(queueProtocol?.lastIncidentSummary ?? "none")}</td></tr>
             <tr><th>Latest plan</th><td>${escapeHtml(latestPlan)}</td></tr>
             <tr><th>Active command</th><td><code>${escapeHtml(activeCommand)}</code></td></tr>
             <tr><th>Latest summary</th><td>${escapeHtml(latestAgentMessage)}</td></tr>
@@ -670,6 +724,23 @@ function renderAgentSessionStatusPage(params) {
         <span class="chip"><strong>CI repairs:</strong> ${escapeHtml(String(ciAttempts))}</span>
         <span class="chip"><strong>Queue repairs:</strong> ${escapeHtml(String(queueAttempts))}</span>
       </div>
+      <div class="section">
+        <h2>State Path</h2>
+        <div class="grid">
+          <div class="card">
+            <h3>Native Graph</h3>
+            ${graphHtml}
+          </div>
+          <div class="card">
+            <h3>Queue Observation</h3>
+            ${observationsHtml}
+          </div>
+        </div>
+        <div class="card" style="margin-top: 18px;">
+          <h3>Observed Path</h3>
+          ${pathHtml}
+        </div>
+      </div>
       <div class="section">
         <h2>Recent Stages</h2>
         <table>
@@ -717,3 +788,94 @@ function formatStageRow(run) {
     const endedAt = run.endedAt ?? "-";
     return `<tr><td><code>${escapeHtml(runType)}</code></td><td>${escapeHtml(status)}</td><td><code>${escapeHtml(startedAt)}</code></td><td><code>${escapeHtml(endedAt)}</code></td></tr>`;
 }
+function normalizeFeedEvents(feedEvents) {
+    return (feedEvents ?? []).map((event, index) => ({
+        id: event.id ?? -(index + 1),
+        at: event.at,
+        level: event.level === "warn" || event.level === "error" ? event.level : "info",
+        kind: event.kind === "service"
+            || event.kind === "webhook"
+            || event.kind === "agent"
+            || event.kind === "comment"
+            || event.kind === "stage"
+            || event.kind === "turn"
+            || event.kind === "workflow"
+            || event.kind === "hook"
+            || event.kind === "github"
+            || event.kind === "linear"
+            ? event.kind
+            : "service",
+        summary: event.summary ?? "",
+        ...(event.detail ? { detail: event.detail } : {}),
+        ...(event.issueKey ? { issueKey: event.issueKey } : {}),
+        ...(event.projectId ? { projectId: event.projectId } : {}),
+        ...(event.stage ? { stage: event.stage } : {}),
+        ...(event.status ? { status: event.status } : {}),
+        ...(event.workflowId ? { workflowId: event.workflowId } : {}),
+        ...(event.nextStage ? { nextStage: event.nextStage } : {}),
+    }));
+}
+function buildPublicStateHistory(params) {
+    const runs = params.runs.flatMap((entry, index) => {
+        if (!entry.run?.runType || !entry.run?.status || !entry.run?.startedAt) {
+            return [];
+        }
+        return [{
+                id: entry.run.id ?? index + 1,
+                runType: entry.run.runType,
+                status: entry.run.status,
+                startedAt: entry.run.startedAt,
+                endedAt: entry.run.endedAt,
+                ...(entry.report ? {
+                    report: {
+                        runType: entry.run.runType,
+                        status: entry.run.status,
+                        prompt: "",
+                        assistantMessages: entry.report.assistantMessages ?? [],
+                        plans: [],
+                        reasoning: [],
+                        commands: (entry.report.commands ?? []),
+                        fileChanges: (entry.report.fileChanges ?? []),
+                        toolCalls: [],
+                        eventCounts: {},
+                    },
+                } : {}),
+            }];
+    });
+    return buildStateHistory(runs, normalizeFeedEvents(params.feedEvents), params.currentFactoryState, params.activeRunId);
+}
+function renderStateGraph(main, prLoops, queueLoop, exits) {
+    return [
+        renderGraphRow("main", main, true),
+        renderGraphRow("pr loops", prLoops, false),
+        renderGraphRow("queue loop", queueLoop, false),
+        renderGraphRow("exits", exits, false),
+    ].join("");
+}
+function renderGraphRow(label, nodes, withConnectors) {
+    const items = nodes.map((node, index) => {
+        const connector = withConnectors && index > 0 ? '<span class="graph-connector">→</span>' : "";
+        return `${connector}<span class="node ${escapeHtml(node.status)}">${escapeHtml(node.label)}</span>`;
+    }).join("");
+    return `<div class="graph-row"><strong>${escapeHtml(label)}:</strong> ${items}</div>`;
+}
+function renderObservationList(observations) {
+    if (observations.length === 0) {
+        return '<p>No queue observation is available yet.</p>';
+    }
+    return `<ul class="observation-list">${observations.map((observation) => `<li class="tone-${escapeHtml(observation.tone)}">${escapeHtml(observation.text)}</li>`).join("")}</ul>`;
+}
+function renderStatePath(history, currentFactoryState) {
+    if (history.length === 0) {
+        return `<p>Current native state: <code>${escapeHtml(currentFactoryState)}</code>.</p>`;
+    }
+    const items = [];
+    for (const node of history) {
+        items.push(`<li><code>${escapeHtml(node.state)}</code>${node.reason ? ` — ${escapeHtml(node.reason)}` : ""}${node.isCurrent ? " (current)" : ""}</li>`);
+        for (const trip of node.sideTrips) {
+            const returnText = trip.returnState ? ` → ${trip.returnedAt ? escapeHtml(trip.returnState) : escapeHtml(trip.returnState)}` : "";
+            items.push(`<li><code>${escapeHtml(trip.state)}</code> side trip${trip.reason ? ` — ${escapeHtml(trip.reason)}` : ""}${returnText ? ` ${returnText}` : ""}</li>`);
+        }
+    }
+    return `<ul class="path-list">${items.join("")}</ul>`;
+}

package/dist/install.js

@@ -3,7 +3,7 @@ import { basename, dirname } from "node:path";
 import { existsSync } from "node:fs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { getDefaultConfigPath, getDefaultDatabasePath, getDefaultRuntimeEnvPath, getDefaultServiceEnvPath, getDefaultLogPath, getDefaultWebhookArchiveDir, getPatchRelayConfigDir, getPatchRelayDataDir, getPatchRelayStateDir, getSystemdPathUnitPath, getSystemdReloadUnitPath, getSystemdUnitPath, readBundledAsset, } from "./runtime-paths.js";
+import { getDefaultConfigPath, getDefaultDatabasePath, getDefaultRuntimeEnvPath, getDefaultServiceEnvPath, getDefaultLogPath, getDefaultWebhookArchiveDir, getPatchRelayConfigDir, getPatchRelayDataDir, getPatchRelayStateDir, getSystemdUnitPath, readBundledAsset, } from "./runtime-paths.js";
 import { loadConfig } from "./config.js";
 import { enforceArbitraryFilePermissions } from "./file-permissions.js";
 import { ensureAbsolutePath } from "./utils.js";
@@ -178,21 +178,13 @@ export async function initializePatchRelayHome(options) {
 export async function installServiceUnits(options) {
     const force = options?.force ?? false;
     const unitPath = getSystemdUnitPath();
-    const reloadUnitPath = getSystemdReloadUnitPath();
-    const pathUnitPath = getSystemdPathUnitPath();
     const serviceStatus = await writeTemplateFile(unitPath, renderTemplate(readBundledAsset("infra/patchrelay.service")), force);
-    const reloadStatus = await writeTemplateFile(reloadUnitPath, renderTemplate(readBundledAsset("infra/patchrelay-reload.service")), force);
-    const pathStatus = await writeTemplateFile(pathUnitPath, renderTemplate(readBundledAsset("infra/patchrelay.path")), force);
     return {
         unitPath,
-        reloadUnitPath,
-        pathUnitPath,
         runtimeEnvPath: getDefaultRuntimeEnvPath(),
         serviceEnvPath: getDefaultServiceEnvPath(),
         configPath: getDefaultConfigPath(),
         serviceStatus,
-        reloadStatus,
-        pathStatus,
     };
 }
 export async function upsertProjectInConfig(options) {
@@ -231,7 +223,7 @@ export async function upsertProjectInConfig(options) {
         delete nextProject.linear_team_ids;
     }
     if (existingProjects.length - (existingProject ? 1 : 0) > 0 && issueKeyPrefixes.length === 0 && linearTeamIds.length === 0) {
-        throw new Error("Adding or updating a project in a multi-project config requires routing. Use --issue-prefix or --team-id.");
+        throw new Error("Adding or updating a repo in a multi-repo config requires routing. Use --prefix or --team.");
     }
     if (existingProjects.length - (existingProject ? 1 : 0) > 0) {
         const unscoped = existingProjects.find((project, index) => {
@@ -244,7 +236,7 @@ export async function upsertProjectInConfig(options) {
             return prefixes.length === 0 && teamIds.length === 0 && labels.length === 0;
         });
         if (unscoped) {
-            throw new Error(`Existing project ${String(unscoped.id ?? "unknown")} has no routing configured. Add routing before configuring multiple projects.`);
+            throw new Error(`Existing repo ${String(unscoped.id ?? "unknown")} has no routing configured. Add routing before configuring multiple repos.`);
         }
     }
     for (const prefix of issueKeyPrefixes) {
@@ -252,7 +244,7 @@ export async function upsertProjectInConfig(options) {
             Array.isArray(project.issue_key_prefixes) &&
             project.issue_key_prefixes.map(String).includes(prefix));
         if (owner) {
-            throw new Error(`Issue key prefix "${prefix}" is already configured for project ${String(owner.id ?? "unknown")}`);
+            throw new Error(`Issue key prefix "${prefix}" is already configured for repo ${String(owner.id ?? "unknown")}`);
         }
     }
     for (const teamId of linearTeamIds) {
@@ -260,7 +252,7 @@ export async function upsertProjectInConfig(options) {
             Array.isArray(project.linear_team_ids) &&
             project.linear_team_ids.map(String).includes(teamId));
         if (owner) {
-            throw new Error(`Linear team id "${teamId}" is already configured for project ${String(owner.id ?? "unknown")}`);
+            throw new Error(`Linear team id "${teamId}" is already configured for repo ${String(owner.id ?? "unknown")}`);
         }
     }
     const normalizedExistingProject = existingProject &&
@@ -316,3 +308,91 @@ export async function upsertProjectInConfig(options) {
         },
     };
 }
+export async function upsertRepositoryInConfig(options) {
+    const configPath = options.configPath ?? getDefaultConfigPath();
+    if (!existsSync(configPath)) {
+        throw new Error(`Config file not found: ${configPath}. Run "patchrelay init" first.`);
+    }
+    const githubRepo = options.githubRepo.trim();
+    if (!githubRepo) {
+        throw new Error("githubRepo is required.");
+    }
+    const localPath = ensureAbsolutePath(options.localPath);
+    const workspace = options.workspace?.trim() || undefined;
+    const linearTeamIds = [...new Set(options.linearTeamIds.map((value) => value.trim()).filter(Boolean))];
+    const linearProjectIds = [...new Set((options.linearProjectIds ?? []).map((value) => value.trim()).filter(Boolean))];
+    const issueKeyPrefixes = [...new Set((options.issueKeyPrefixes ?? []).map((value) => value.trim()).filter(Boolean))];
+    const original = await readFile(configPath, "utf8");
+    const parsed = parseConfigObject(original, configPath);
+    const existingRepositories = Array.isArray(parsed.repositories) ? parsed.repositories : [];
+    const existingIndex = existingRepositories.findIndex((repository) => String(repository.github_repo ?? "") === githubRepo);
+    const existing = existingIndex >= 0 ? existingRepositories[existingIndex] : undefined;
+    const nextRepository = {
+        ...(existing ?? {}),
+        github_repo: githubRepo,
+        local_path: localPath,
+        ...(workspace ? { workspace } : {}),
+        linear_team_ids: linearTeamIds,
+        linear_project_ids: linearProjectIds,
+        issue_key_prefixes: issueKeyPrefixes,
+    };
+    const normalizedExisting = existing && JSON.stringify(existing);
+    const normalizedNext = JSON.stringify(nextRepository);
+    const status = existing === undefined ? "created" : normalizedExisting === normalizedNext ? "unchanged" : "updated";
+    const document = parseConfigObject(original, configPath);
+    if ("repositories" in document && document.repositories !== undefined && !Array.isArray(document.repositories)) {
+        throw new Error(`Config file field "repositories" must be a JSON array: ${configPath}`);
+    }
+    if (status !== "unchanged") {
+        const nextRepositories = [...existingRepositories];
+        if (existingIndex >= 0) {
+            nextRepositories[existingIndex] = nextRepository;
+        }
+        else {
+            nextRepositories.push(nextRepository);
+        }
+        document.repositories = nextRepositories;
+        const next = stringifyConfig(document);
+        await writeFile(configPath, next, "utf8");
+    }
+    try {
+        loadConfig(configPath, { profile: "write_config" });
+    }
+    catch (error) {
+        if (status !== "unchanged") {
+            await writeFile(configPath, original, "utf8");
+        }
+        throw error;
+    }
+    return {
+        configPath,
+        status,
+        repository: {
+            githubRepo,
+            localPath,
+            ...(workspace ? { workspace } : {}),
+            linearTeamIds,
+            linearProjectIds,
+            issueKeyPrefixes,
+        },
+    };
+}
+export async function removeRepositoryFromConfig(options) {
+    const configPath = options.configPath ?? getDefaultConfigPath();
+    if (!existsSync(configPath)) {
+        throw new Error(`Config file not found: ${configPath}. Run "patchrelay init" first.`);
+    }
+    const original = await readFile(configPath, "utf8");
+    const document = parseConfigObject(original, configPath);
+    const existingRepositories = Array.isArray(document.repositories) ? document.repositories : [];
+    const nextRepositories = existingRepositories.filter((repository) => String(repository.github_repo ?? "") !== options.githubRepo);
+    if (nextRepositories.length === existingRepositories.length) {
+        return { configPath, removed: false };
+    }
+    document.repositories = nextRepositories;
+    await writeFile(configPath, stringifyConfig(document), "utf8");
+    return { configPath, removed: true };
+}
+export async function ensureRepositoryProjectSettings(repoPath) {
+    await writeTemplateFile(getRepoProjectSettingsPath(ensureAbsolutePath(repoPath)), stringifyConfig(defaultRepoProjectSettings()), false);
+}