patchrelay 0.8.8 → 0.9.0

package/dist/github-webhook-handler.js

@@ -0,0 +1,199 @@
+import { resolveFactoryStateFromGitHub } from "./factory-state.js";
+import { normalizeGitHubWebhook, verifyGitHubWebhookSignature } from "./github-webhooks.js";
+import { safeJsonParse } from "./utils.js";
+export class GitHubWebhookHandler {
+    config;
+    db;
+    linearProvider;
+    enqueueIssue;
+    logger;
+    feed;
+    constructor(config, db, linearProvider, enqueueIssue, logger, feed) {
+        this.config = config;
+        this.db = db;
+        this.linearProvider = linearProvider;
+        this.enqueueIssue = enqueueIssue;
+        this.logger = logger;
+        this.feed = feed;
+    }
+    async acceptGitHubWebhook(params) {
+        // Deduplicate
+        if (this.db.isWebhookDuplicate(params.deliveryId)) {
+            return { status: 200, body: { ok: true, duplicate: true } };
+        }
+        // Store the event
+        const stored = this.db.insertWebhookEvent(params.deliveryId, new Date().toISOString());
+        // Parse payload
+        const payload = safeJsonParse(params.rawBody.toString("utf8"));
+        if (!payload) {
+            return { status: 400, body: { ok: false, reason: "invalid_json" } };
+        }
+        // Find matching project by repo
+        const repoFullName = typeof payload === "object" && payload !== null && "repository" in payload
+            ? payload.repository
+            : undefined;
+        const repoName = typeof repoFullName === "object" && repoFullName !== null && "full_name" in repoFullName
+            ? String(repoFullName.full_name)
+            : undefined;
+        const project = repoName
+            ? this.config.projects.find((p) => p.github?.repoFullName === repoName)
+            : undefined;
+        // Verify signature using global GitHub App webhook secret
+        const webhookSecret = process.env.GITHUB_APP_WEBHOOK_SECRET;
+        if (webhookSecret) {
+            if (!verifyGitHubWebhookSignature(params.rawBody, webhookSecret, params.signature)) {
+                return { status: 401, body: { ok: false, reason: "invalid_signature" } };
+            }
+        }
+        if (stored.duplicate) {
+            return { status: 200, body: { ok: true, duplicate: true } };
+        }
+        return {
+            status: 200,
+            body: {
+                ok: true,
+                accepted: true,
+                webhookEventId: stored.id,
+                eventType: params.eventType,
+                projectId: project?.id,
+            },
+        };
+    }
+    async processGitHubWebhookEvent(params) {
+        const payload = safeJsonParse(params.rawBody);
+        if (!payload || typeof payload !== "object")
+            return;
+        const event = normalizeGitHubWebhook({
+            eventType: params.eventType,
+            payload: payload,
+        });
+        if (!event) {
+            this.logger.debug({ eventType: params.eventType }, "GitHub webhook: unrecognized event type or action");
+            return;
+        }
+        // Route to issue via branch name
+        const issue = this.db.getIssueByBranch(event.branchName);
+        if (!issue) {
+            this.logger.debug({ branchName: event.branchName, triggerEvent: event.triggerEvent }, "GitHub webhook: no matching issue for branch");
+            return;
+        }
+        // Update PR state on the issue
+        this.db.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            ...(event.prNumber !== undefined ? { prNumber: event.prNumber } : {}),
+            ...(event.prUrl !== undefined ? { prUrl: event.prUrl } : {}),
+            ...(event.prState !== undefined ? { prState: event.prState } : {}),
+            ...(event.reviewState !== undefined ? { prReviewState: event.reviewState } : {}),
+            ...(event.checkStatus !== undefined ? { prCheckStatus: event.checkStatus } : {}),
+        });
+        // Drive factory state transitions from GitHub events
+        const newState = resolveFactoryStateFromGitHub(event.triggerEvent, issue.factoryState);
+        if (newState) {
+            this.db.upsertIssue({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                factoryState: newState,
+            });
+            this.logger.info({ issueKey: issue.issueKey, from: issue.factoryState, to: newState, trigger: event.triggerEvent }, "Factory state transition from GitHub event");
+            // Emit Linear activity for significant state changes
+            void this.emitLinearActivity(issue, newState, event);
+        }
+        // Reset repair counters on new push
+        if (event.triggerEvent === "pr_synchronize") {
+            this.db.upsertIssue({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                ciRepairAttempts: 0,
+                queueRepairAttempts: 0,
+            });
+        }
+        this.logger.info({ issueKey: issue.issueKey, branchName: event.branchName, triggerEvent: event.triggerEvent, prNumber: event.prNumber }, "GitHub webhook: updated issue PR state");
+        this.feed?.publish({
+            level: event.triggerEvent.includes("failed") ? "warn" : "info",
+            kind: "github",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: issue.factoryState,
+            status: event.triggerEvent,
+            summary: `GitHub: ${event.triggerEvent}${event.prNumber ? ` on PR #${event.prNumber}` : ""}`,
+            detail: event.checkName ?? event.reviewBody?.slice(0, 200) ?? undefined,
+        });
+        // Trigger reactive runs if applicable
+        this.maybeEnqueueReactiveRun(issue, event);
+    }
+    maybeEnqueueReactiveRun(issue, event) {
+        // Don't trigger if there's already an active run
+        if (issue.activeRunId !== undefined)
+            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,
+                }),
+            });
+            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({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                pendingRunType: "review_fix",
+                pendingRunContextJson: JSON.stringify({
+                    reviewBody: event.reviewBody,
+                    reviewerName: event.reviewerName,
+                }),
+            });
+            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") {
+            this.db.upsertIssue({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                pendingRunType: "queue_repair",
+                pendingRunContextJson: JSON.stringify({
+                    failureReason: event.mergeGroupFailureReason,
+                }),
+            });
+            this.enqueueIssue(issue.projectId, issue.linearIssueId);
+            this.logger.info({ issueKey: issue.issueKey }, "Enqueued merge queue repair run");
+        }
+    }
+    async emitLinearActivity(issue, newState, event) {
+        if (!issue.agentSessionId)
+            return;
+        const linear = await this.linearProvider.forProject(issue.projectId);
+        if (!linear?.createAgentActivity)
+            return;
+        const messages = {
+            pr_open: `PR #${event.prNumber ?? ""} opened.${event.prUrl ? ` ${event.prUrl}` : ""}`,
+            awaiting_queue: "PR approved. Awaiting merge queue.",
+            changes_requested: `Review requested changes.${event.reviewerName ? ` Reviewer: ${event.reviewerName}` : ""}`,
+            repairing_ci: `CI check failed${event.checkName ? `: ${event.checkName}` : ""}. Starting repair.`,
+            repairing_queue: "Merge queue failed. Starting repair.",
+            done: `PR merged and deployed.${event.prNumber ? ` PR #${event.prNumber}` : ""}`,
+            failed: "PR was closed without merging.",
+        };
+        const body = messages[newState];
+        if (!body)
+            return;
+        const type = newState === "failed" || newState === "repairing_ci" || newState === "repairing_queue"
+            ? "error"
+            : "response";
+        try {
+            await linear.createAgentActivity({
+                agentSessionId: issue.agentSessionId,
+                content: { type, body },
+            });
+        }
+        catch {
+            // Non-blocking — don't fail the webhook for a Linear activity error
+        }
+    }
+}

package/dist/github-webhooks.js

@@ -0,0 +1,166 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+export function verifyGitHubWebhookSignature(rawBody, secret, signature) {
+    if (!signature.startsWith("sha256=")) {
+        return false;
+    }
+    const expected = createHmac("sha256", secret).update(rawBody).digest("hex");
+    const provided = signature.slice("sha256=".length);
+    if (expected.length !== provided.length) {
+        return false;
+    }
+    return timingSafeEqual(Buffer.from(expected, "hex"), Buffer.from(provided, "hex"));
+}
+export function normalizeGitHubWebhook(params) {
+    const { eventType, payload } = params;
+    const repoFullName = payload.repository?.full_name ?? "";
+    if (eventType === "pull_request" && payload.pull_request) {
+        return normalizePullRequestEvent(payload, repoFullName);
+    }
+    if (eventType === "pull_request_review" && payload.pull_request && payload.review) {
+        return normalizePullRequestReviewEvent(payload, repoFullName);
+    }
+    if (eventType === "check_suite" && payload.check_suite) {
+        return normalizeCheckSuiteEvent(payload, repoFullName);
+    }
+    if (eventType === "check_run" && payload.check_run) {
+        return normalizeCheckRunEvent(payload, repoFullName);
+    }
+    if (eventType === "merge_group" && payload.merge_group) {
+        return normalizeMergeGroupEvent(payload, repoFullName);
+    }
+    return undefined;
+}
+function normalizePullRequestEvent(payload, repoFullName) {
+    const pr = payload.pull_request;
+    const action = payload.action;
+    let triggerEvent;
+    let prState;
+    if (action === "opened" || action === "reopened") {
+        triggerEvent = "pr_opened";
+        prState = "open";
+    }
+    else if (action === "synchronize") {
+        triggerEvent = "pr_synchronize";
+        prState = "open";
+    }
+    else if (action === "closed") {
+        if (pr.merged) {
+            triggerEvent = "pr_merged";
+            prState = "merged";
+        }
+        else {
+            triggerEvent = "pr_closed";
+            prState = "closed";
+        }
+    }
+    else {
+        return undefined;
+    }
+    return {
+        triggerEvent,
+        repoFullName,
+        branchName: pr.head.ref,
+        headSha: pr.head.sha,
+        prNumber: pr.number,
+        prUrl: pr.html_url,
+        prState,
+    };
+}
+function normalizePullRequestReviewEvent(payload, repoFullName) {
+    if (payload.action !== "submitted")
+        return undefined;
+    const pr = payload.pull_request;
+    const review = payload.review;
+    const state = review.state?.toLowerCase();
+    let triggerEvent;
+    let reviewState;
+    if (state === "approved") {
+        triggerEvent = "review_approved";
+        reviewState = "approved";
+    }
+    else if (state === "changes_requested") {
+        triggerEvent = "review_changes_requested";
+        reviewState = "changes_requested";
+    }
+    else if (state === "commented") {
+        triggerEvent = "review_commented";
+        reviewState = "commented";
+    }
+    else {
+        return undefined;
+    }
+    return {
+        triggerEvent,
+        repoFullName,
+        branchName: pr.head.ref,
+        headSha: pr.head.sha,
+        prNumber: pr.number,
+        prUrl: pr.html_url,
+        prState: "open",
+        reviewState,
+        reviewBody: review.body ?? undefined,
+        reviewerName: review.user?.login ?? undefined,
+    };
+}
+function normalizeCheckSuiteEvent(payload, repoFullName) {
+    if (payload.action !== "completed")
+        return undefined;
+    const suite = payload.check_suite;
+    const conclusion = suite.conclusion?.toLowerCase();
+    const pr = suite.pull_requests?.[0];
+    const branchName = pr?.head.ref ?? suite.head_branch ?? "";
+    if (!branchName)
+        return undefined;
+    const passed = conclusion === "success" || conclusion === "neutral" || conclusion === "skipped";
+    return {
+        triggerEvent: passed ? "check_passed" : "check_failed",
+        repoFullName,
+        branchName,
+        headSha: suite.head_sha,
+        prNumber: pr?.number,
+        checkStatus: passed ? "success" : "failure",
+    };
+}
+function normalizeCheckRunEvent(payload, repoFullName) {
+    if (payload.action !== "completed")
+        return undefined;
+    const run = payload.check_run;
+    const conclusion = run.conclusion?.toLowerCase();
+    const pr = run.check_suite?.pull_requests?.[0];
+    const branchName = pr?.head.ref ?? run.check_suite?.head_branch ?? "";
+    if (!branchName)
+        return undefined;
+    const passed = conclusion === "success" || conclusion === "neutral" || conclusion === "skipped";
+    return {
+        triggerEvent: passed ? "check_passed" : "check_failed",
+        repoFullName,
+        branchName,
+        headSha: run.head_sha,
+        prNumber: pr?.number,
+        checkStatus: passed ? "success" : "failure",
+        checkName: run.name,
+        checkUrl: run.html_url,
+    };
+}
+function normalizeMergeGroupEvent(payload, repoFullName) {
+    const group = payload.merge_group;
+    const action = payload.action;
+    if (action === "checks_passed") {
+        return {
+            triggerEvent: "merge_group_passed",
+            repoFullName,
+            branchName: group.head_ref,
+            headSha: group.head_sha,
+        };
+    }
+    if (action === "checks_failed" || action === "destroyed") {
+        return {
+            triggerEvent: "merge_group_failed",
+            repoFullName,
+            branchName: group.head_ref,
+            headSha: group.head_sha,
+            mergeGroupFailureReason: action,
+        };
+    }
+    return undefined;
+}

package/dist/hook-runner.js

@@ -0,0 +1,28 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { execCommand } from "./utils.js";
+export async function runProjectHook(repoPath, hookName, options) {
+    const hookPath = path.join(repoPath, ".patchrelay", "hooks", hookName);
+    if (!existsSync(hookPath)) {
+        return { ran: false };
+    }
+    const result = await execCommand(hookPath, [], {
+        cwd: options.cwd,
+        env: { ...process.env, ...(options.env ?? {}) },
+        timeoutMs: options.timeoutMs ?? 120_000,
+    });
+    return {
+        ran: true,
+        exitCode: result.exitCode,
+        stdout: result.stdout,
+        stderr: result.stderr,
+    };
+}
+export function buildHookEnv(issueKey, branchName, stage, worktreePath) {
+    return {
+        PATCHRELAY_ISSUE_KEY: issueKey,
+        PATCHRELAY_BRANCH: branchName,
+        PATCHRELAY_STAGE: stage,
+        PATCHRELAY_WORKTREE: worktreePath,
+    };
+}

package/dist/http.js

@@ -178,6 +178,32 @@ export async function buildHttpServer(config, service, logger) {
         });
         return reply.code(result.status).send(result.body);
     });
+    app.post(config.ingress.githubWebhookPath, {
+        config: {
+            rawBody: true,
+        },
+    }, async (request, reply) => {
+        const rawBody = typeof request.rawBody === "string" ? Buffer.from(request.rawBody) : request.rawBody;
+        if (!rawBody) {
+            return reply.code(400).send({ ok: false, reason: "missing_raw_body" });
+        }
+        const deliveryId = getHeader(request, "x-github-delivery");
+        if (!deliveryId) {
+            return reply.code(400).send({ ok: false, reason: "missing_delivery_header" });
+        }
+        const eventType = getHeader(request, "x-github-event");
+        if (!eventType) {
+            return reply.code(400).send({ ok: false, reason: "missing_event_type" });
+        }
+        const signature = getHeader(request, "x-hub-signature-256") ?? "";
+        const result = await service.acceptGitHubWebhook({
+            deliveryId,
+            eventType,
+            signature,
+            rawBody,
+        });
+        return reply.code(result.status).send(result.body);
+    });
     app.get("/agent/session/:issueKey", async (request, reply) => {
         const issueKey = request.params.issueKey;
         const token = getQueryParam(request, "token");
@@ -235,17 +261,17 @@ export async function buildHttpServer(config, service, logger) {
         });
         app.get("/api/issues/:issueKey/live", async (request, reply) => {
             const issueKey = request.params.issueKey;
-            const result = await service.getActiveStageStatus(issueKey);
+            const result = await service.getActiveRunStatus(issueKey);
             if (!result) {
-                return reply.code(404).send({ ok: false, reason: "active_stage_not_found" });
+                return reply.code(404).send({ ok: false, reason: "active_run_not_found" });
             }
             return reply.send({ ok: true, ...result });
         });
-        app.get("/api/issues/:issueKey/stages/:stageRunId/events", async (request, reply) => {
-            const { issueKey, stageRunId } = request.params;
-            const result = await service.getStageEvents(issueKey, Number(stageRunId));
+        app.get("/api/issues/:issueKey/runs/:runId/events", async (request, reply) => {
+            const { issueKey, runId } = request.params;
+            const result = await service.getRunEvents(issueKey, Number(runId));
             if (!result) {
-                return reply.code(404).send({ ok: false, reason: "stage_run_not_found" });
+                return reply.code(404).send({ ok: false, reason: "run_not_found" });
             }
             return reply.send({ ok: true, ...result });
         });
@@ -448,10 +474,10 @@ function renderAgentSessionStatusErrorPage(message) {
 function renderAgentSessionStatusPage(params) {
     const issueTitle = params.sessionStatus.issue.title ?? params.sessionStatus.issue.issueKey ?? params.issueKey;
     const issueUrl = params.sessionStatus.issue.issueUrl;
-    const activeStage = formatStageChip(params.sessionStatus.activeStageRun);
-    const latestStage = formatStageChip(params.sessionStatus.latestStageRun);
+    const activeStage = formatStageChip(params.sessionStatus.activeRun);
+    const latestStage = formatStageChip(params.sessionStatus.latestRun);
     const threadInfo = formatThread(params.sessionStatus.liveThread);
-    const stagesRows = params.sessionStatus.stages.slice(-8).map((entry) => formatStageRow(entry.stageRun)).join("");
+    const stagesRows = params.sessionStatus.runs.slice(-8).map((entry) => formatStageRow(entry.run)).join("");
     return `<!doctype html>
 <html lang="en">
   <head>
@@ -535,13 +561,13 @@ function renderAgentSessionStatusPage(params) {
   </body>
 </html>`;
 }
-function formatStageChip(stageRun) {
-    if (!stageRun) {
+function formatStageChip(run) {
+    if (!run) {
         return "none";
     }
-    const stage = stageRun.stage ?? "unknown";
-    const status = stageRun.status ?? "unknown";
-    return `<code>${escapeHtml(stage)}</code> (${escapeHtml(status)})`;
+    const runType = run.runType ?? "unknown";
+    const status = run.status ?? "unknown";
+    return `<code>${escapeHtml(runType)}</code> (${escapeHtml(status)})`;
 }
 function formatThread(liveThread) {
     if (!liveThread) {
@@ -551,13 +577,13 @@ function formatThread(liveThread) {
     const status = liveThread.threadStatus ?? "unknown";
     return `<code>${escapeHtml(threadId)}</code> (${escapeHtml(status)})`;
 }
-function formatStageRow(stageRun) {
-    if (!stageRun) {
-        return '<tr><td colspan="4">Unknown stage record</td></tr>';
+function formatStageRow(run) {
+    if (!run) {
+        return '<tr><td colspan="4">Unknown run record</td></tr>';
     }
-    const stage = stageRun.stage ?? "unknown";
-    const status = stageRun.status ?? "unknown";
-    const startedAt = stageRun.startedAt ?? "-";
-    const endedAt = stageRun.endedAt ?? "-";
-    return `<tr><td><code>${escapeHtml(stage)}</code></td><td>${escapeHtml(status)}</td><td><code>${escapeHtml(startedAt)}</code></td><td><code>${escapeHtml(endedAt)}</code></td></tr>`;
+    const runType = run.runType ?? "unknown";
+    const status = run.status ?? "unknown";
+    const startedAt = run.startedAt ?? "-";
+    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>`;
 }

package/dist/issue-query-service.js

@@ -1,82 +1,77 @@
-import { summarizeCurrentThread } from "./stage-reporting.js";
+import { summarizeCurrentThread } from "./run-reporting.js";
 import { safeJsonParse } from "./utils.js";
 export class IssueQueryService {
-    stores;
+    db;
     codex;
-    stageFinalizer;
-    constructor(stores, codex, stageFinalizer) {
-        this.stores = stores;
+    runStatusProvider;
+    constructor(db, codex, runStatusProvider) {
+        this.db = db;
         this.codex = codex;
-        this.stageFinalizer = stageFinalizer;
+        this.runStatusProvider = runStatusProvider;
     }
     async getIssueOverview(issueKey) {
-        const result = this.stores.issueWorkflows.getIssueOverview(issueKey);
-        if (!result) {
+        const result = this.db.getIssueOverview(issueKey);
+        if (!result)
             return undefined;
-        }
-        const activeStatus = await this.stageFinalizer.getActiveStageStatus(issueKey);
-        const activeStageRun = activeStatus?.stageRun ?? result.activeStageRun;
-        const latestStageRun = this.stores.issueWorkflows.getLatestStageRunForIssue(result.issue.projectId, result.issue.linearIssueId);
+        const activeStatus = await this.runStatusProvider.getActiveRunStatus(issueKey);
+        const activeRun = activeStatus?.run ?? result.activeRun;
+        const latestRun = this.db.getLatestRunForIssue(result.issue.projectId, result.issue.linearIssueId);
         let liveThread;
         if (activeStatus?.liveThread) {
             liveThread = activeStatus.liveThread;
         }
-        else if (activeStageRun?.threadId) {
-            liveThread = await this.codex.readThread(activeStageRun.threadId, true).then(summarizeCurrentThread).catch(() => undefined);
+        else if (activeRun?.threadId) {
+            liveThread = await this.codex.readThread(activeRun.threadId, true).then(summarizeCurrentThread).catch(() => undefined);
         }
         return {
             ...result,
-            ...(activeStageRun ? { activeStageRun } : {}),
-            ...(latestStageRun ? { latestStageRun } : {}),
+            ...(activeRun ? { activeRun } : {}),
+            ...(latestRun ? { latestRun } : {}),
             ...(liveThread ? { liveThread } : {}),
         };
     }
     async getIssueReport(issueKey) {
-        const issue = this.stores.issueWorkflows.getTrackedIssueByKey(issueKey);
-        if (!issue) {
+        const issue = this.db.getTrackedIssueByKey(issueKey);
+        if (!issue)
             return undefined;
-        }
         return {
             issue,
-            stages: this.stores.issueWorkflows.listStageRunsForIssue(issue.projectId, issue.linearIssueId).map((stageRun) => ({
-                stageRun,
-                ...(stageRun.reportJson ? { report: JSON.parse(stageRun.reportJson) } : {}),
+            runs: this.db.listRunsForIssue(issue.projectId, issue.linearIssueId).map((run) => ({
+                run,
+                ...(run.reportJson ? { report: JSON.parse(run.reportJson) } : {}),
             })),
         };
     }
-    async getStageEvents(issueKey, stageRunId) {
-        const issue = this.stores.issueWorkflows.getTrackedIssueByKey(issueKey);
-        if (!issue) {
+    async getRunEvents(issueKey, runId) {
+        const issue = this.db.getTrackedIssueByKey(issueKey);
+        if (!issue)
             return undefined;
-        }
-        const stageRun = this.stores.issueWorkflows.getStageRun(stageRunId);
-        if (!stageRun || stageRun.projectId !== issue.projectId || stageRun.linearIssueId !== issue.linearIssueId) {
+        const run = this.db.getRun(runId);
+        if (!run || run.projectId !== issue.projectId || run.linearIssueId !== issue.linearIssueId)
             return undefined;
-        }
         return {
             issue,
-            stageRun,
-            events: this.stores.stageEvents.listThreadEvents(stageRunId).map((event) => ({
+            run,
+            events: this.db.listThreadEvents(runId).map((event) => ({
                 ...event,
                 parsedEvent: safeJsonParse(event.eventJson),
             })),
         };
     }
-    async getActiveStageStatus(issueKey) {
-        return await this.stageFinalizer.getActiveStageStatus(issueKey);
+    async getActiveRunStatus(issueKey) {
+        return await this.runStatusProvider.getActiveRunStatus(issueKey);
     }
     async getPublicAgentSessionStatus(issueKey) {
         const overview = await this.getIssueOverview(issueKey);
-        if (!overview) {
+        if (!overview)
             return undefined;
-        }
         const report = await this.getIssueReport(issueKey);
         return {
             issue: overview.issue,
-            ...(overview.activeStageRun ? { activeStageRun: overview.activeStageRun } : {}),
-            ...(overview.latestStageRun ? { latestStageRun: overview.latestStageRun } : {}),
+            ...(overview.activeRun ? { activeRun: overview.activeRun } : {}),
+            ...(overview.latestRun ? { latestRun: overview.latestRun } : {}),
             ...(overview.liveThread ? { liveThread: overview.liveThread } : {}),
-            stages: report?.stages ?? [],
+            runs: report?.runs ?? [],
             generatedAt: new Date().toISOString(),
         };
     }