patchrelay 0.36.17 → 0.36.19

package/dist/linear-status-comment-sync.js

@@ -0,0 +1,152 @@
+import { extractCompletionCheck } from "./completion-check.js";
+import { deriveIssueStatusNote } from "./status-note.js";
+import { derivePatchRelayWaitingReason } from "./waiting-reason.js";
+export async function syncVisibleStatusComment(params) {
+    const { db, issue, linear, logger, trackedIssue, options } = params;
+    try {
+        const body = renderStatusComment(db, issue, trackedIssue, options);
+        const result = await linear.upsertIssueComment({
+            issueId: issue.linearIssueId,
+            ...(issue.statusCommentId ? { commentId: issue.statusCommentId } : {}),
+            body,
+        });
+        if (result.id !== issue.statusCommentId) {
+            db.issues.upsertIssue({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                statusCommentId: result.id,
+            });
+        }
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        logger.warn({ issueKey: issue.issueKey, error: msg }, "Failed to sync Linear status comment");
+    }
+}
+export function shouldSyncVisibleIssueComment(issue, hasAgentSession) {
+    if (!hasAgentSession) {
+        return true;
+    }
+    if (issue.sessionState === "waiting_input" || issue.sessionState === "failed"
+        || issue.factoryState === "awaiting_input" || issue.factoryState === "failed" || issue.factoryState === "escalated") {
+        return true;
+    }
+    if ((issue.sessionState === "done" || issue.factoryState === "done") && issue.prNumber === undefined && !issue.prUrl) {
+        return true;
+    }
+    return false;
+}
+function renderStatusComment(db, issue, trackedIssue, options) {
+    const activeRun = issue.activeRunId ? db.runs.getRunById(issue.activeRunId) : undefined;
+    const latestRun = db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
+    const latestEvent = db.issueSessions.listIssueSessionEvents(issue.projectId, issue.linearIssueId, { limit: 1 }).at(-1);
+    const activeRunType = issue.activeRunId !== undefined
+        ? (options?.activeRunType ?? activeRun?.runType)
+        : undefined;
+    const waitingReason = trackedIssue?.waitingReason ?? derivePatchRelayWaitingReason({
+        ...(activeRunType ? { activeRunType } : {}),
+        ...(issue.activeRunId !== undefined ? { activeRunId: issue.activeRunId } : {}),
+        factoryState: issue.factoryState,
+        pendingRunType: issue.pendingRunType,
+        ...(issue.prNumber !== undefined ? { prNumber: issue.prNumber } : {}),
+        prHeadSha: issue.prHeadSha,
+        prReviewState: issue.prReviewState,
+        prCheckStatus: issue.prCheckStatus,
+        lastBlockingReviewHeadSha: issue.lastBlockingReviewHeadSha,
+        latestFailureCheckName: issue.lastGitHubFailureCheckName,
+    });
+    const lines = [
+        "## PatchRelay status",
+        "",
+        statusHeadline(trackedIssue ?? issue, activeRunType),
+    ];
+    const statusNote = trackedIssue?.statusNote ?? deriveIssueStatusNote({ issue, latestRun, latestEvent, waitingReason });
+    if (waitingReason) {
+        lines.push("", `Waiting: ${waitingReason}`);
+    }
+    if (statusNote && statusNote !== waitingReason) {
+        const label = trackedIssue?.sessionState === "waiting_input" || issue.factoryState === "awaiting_input" ? "Input needed"
+            : trackedIssue?.sessionState === "failed" || issue.factoryState === "failed" || issue.factoryState === "escalated" ? "Action needed"
+                : "Note";
+        lines.push("", `${label}: ${statusNote}`);
+    }
+    const completionCheck = extractCompletionCheck(latestRun);
+    if (completionCheck?.outcome === "needs_input") {
+        if (completionCheck.why) {
+            lines.push("", `Why: ${completionCheck.why}`);
+        }
+        if (completionCheck.recommendedReply) {
+            lines.push("", `Suggested reply: ${completionCheck.recommendedReply}`);
+        }
+        const issueRef = issue.issueKey ?? issue.linearIssueId;
+        lines.push("", `Reply in a Linear comment to continue, or run \`patchrelay issue prompt ${issueRef} "..."\`.`);
+    }
+    if (issue.prNumber !== undefined || issue.prUrl) {
+        const prLabel = issue.prNumber !== undefined ? `#${issue.prNumber}` : "open";
+        lines.push("", `PR: ${issue.prUrl ? `[${prLabel}](${issue.prUrl})` : prLabel}`);
+    }
+    if (latestRun) {
+        lines.push("", `Latest run: ${formatLatestRun(latestRun)}`);
+        if (latestRun.failureReason) {
+            lines.push("", `Failure: ${latestRun.failureReason}`);
+        }
+        if (completionCheck && completionCheck.outcome !== "needs_input" && completionCheck.summary !== statusNote) {
+            lines.push("", `Completion check: ${completionCheck.summary}`);
+        }
+    }
+    if (issue.lastGitHubFailureCheckName && (issue.factoryState === "repairing_ci" || issue.prCheckStatus === "failed" || issue.prCheckStatus === "failure")) {
+        lines.push("", `Latest failing check: ${issue.lastGitHubFailureCheckName}`);
+    }
+    lines.push("", "_PatchRelay updates this comment as it works. Review and merge remain downstream._");
+    return lines.join("\n");
+}
+function statusHeadline(issue, activeRunType) {
+    if (activeRunType) {
+        return `Running ${humanize(activeRunType)}`;
+    }
+    switch (issue.sessionState) {
+        case "waiting_input":
+            return issue.waitingReason ?? "Waiting for more input";
+        case "running":
+            return issue.prNumber !== undefined ? `PR #${issue.prNumber} is actively running` : "Actively running";
+        case "done":
+            return issue.prNumber !== undefined ? `Completed with PR #${issue.prNumber}` : "Completed";
+        case "failed":
+            return "Needs operator intervention";
+        default:
+            break;
+    }
+    switch (issue.factoryState) {
+        case "delegated":
+            return "Queued to start work";
+        case "implementing":
+            return "Implementing requested change";
+        case "pr_open":
+            return issue.prNumber !== undefined ? `PR #${issue.prNumber} opened` : "PR opened";
+        case "changes_requested":
+            return "Addressing requested review changes";
+        case "repairing_ci":
+            return "Repairing failing CI";
+        case "awaiting_queue":
+            return "Handed off downstream for merge";
+        case "repairing_queue":
+            return "Repairing merge handoff";
+        case "awaiting_input":
+            return "Waiting for more input";
+        case "failed":
+            return "Needs operator intervention";
+        case "escalated":
+            return "Needs operator intervention";
+        case "done":
+            return issue.prNumber !== undefined ? `Completed with PR #${issue.prNumber}` : "Completed";
+        default:
+            return humanize(issue.factoryState);
+    }
+}
+function formatLatestRun(run) {
+    const at = run.endedAt ?? run.startedAt;
+    return `${humanize(run.runType)} ${run.status} at ${at}`;
+}
+function humanize(value) {
+    return value.replaceAll("_", " ");
+}

package/dist/linear-workflow-state-sync.js

@@ -0,0 +1,103 @@
+import { resolvePreferredDeployingLinearState, resolvePreferredHumanNeededLinearState, resolvePreferredImplementingLinearState, resolvePreferredReviewLinearState, resolvePreferredReviewingLinearState, } from "./linear-workflow.js";
+export async function syncActiveWorkflowState(params) {
+    const { db, issue, linear, trackedIssue, options } = params;
+    if (!shouldAutoAdvanceLinearState(issue)) {
+        return;
+    }
+    const liveIssue = await linear.getIssue(issue.linearIssueId).catch(() => undefined);
+    if (!liveIssue)
+        return;
+    if (!shouldAutoAdvanceLinearState({
+        currentLinearState: liveIssue.stateName,
+        currentLinearStateType: liveIssue.stateType,
+    })) {
+        db.issues.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
+            ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
+        });
+        return;
+    }
+    const targetState = resolveDesiredActiveWorkflowState(issue, trackedIssue, options, liveIssue);
+    if (!targetState)
+        return;
+    const normalizedCurrent = liveIssue.stateName?.trim().toLowerCase();
+    if (normalizedCurrent === targetState.trim().toLowerCase()) {
+        db.issues.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
+            ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
+        });
+        return;
+    }
+    const updated = await linear.setIssueState(issue.linearIssueId, targetState);
+    db.issues.upsertIssue({
+        projectId: issue.projectId,
+        linearIssueId: issue.linearIssueId,
+        ...(updated.stateName ? { currentLinearState: updated.stateName } : {}),
+        ...(updated.stateType ? { currentLinearStateType: updated.stateType } : {}),
+    });
+}
+function shouldAutoAdvanceLinearState(issue) {
+    const normalizedType = issue.currentLinearStateType?.trim().toLowerCase();
+    if (normalizedType === "completed" || normalizedType === "canceled" || normalizedType === "cancelled") {
+        return false;
+    }
+    const normalizedName = issue.currentLinearState?.trim().toLowerCase();
+    return normalizedName !== "done" && normalizedName !== "completed" && normalizedName !== "complete";
+}
+function resolveDesiredActiveWorkflowState(issue, trackedIssue, options, liveIssue) {
+    if (issue.factoryState === "awaiting_input" || issue.factoryState === "failed" || issue.factoryState === "escalated"
+        || trackedIssue?.sessionState === "waiting_input" || trackedIssue?.sessionState === "failed") {
+        return resolvePreferredHumanNeededLinearState(liveIssue);
+    }
+    const activelyWorking = issue.activeRunId !== undefined
+        || options?.activeRunType !== undefined
+        || trackedIssue?.sessionState === "running"
+        || issue.factoryState === "delegated"
+        || issue.factoryState === "implementing"
+        || issue.factoryState === "changes_requested"
+        || issue.factoryState === "repairing_ci"
+        || issue.factoryState === "repairing_queue";
+    if (activelyWorking) {
+        return resolvePreferredImplementingLinearState(liveIssue);
+    }
+    if (issue.factoryState === "awaiting_queue"
+        || issue.prReviewState === "approved"
+        || isApprovedAndGreen(issue.prReviewState, issue.prCheckStatus)) {
+        return resolvePreferredDeployingLinearState(liveIssue);
+    }
+    if (hasPendingReviewQuillVerdict(issue.lastGitHubCiSnapshotJson)) {
+        return resolvePreferredReviewingLinearState(liveIssue);
+    }
+    const reviewBound = issue.prNumber !== undefined
+        || Boolean(issue.prUrl)
+        || issue.factoryState === "pr_open"
+        || issue.prReviewState !== undefined
+        || issue.prCheckStatus !== undefined;
+    if (reviewBound) {
+        return resolvePreferredReviewLinearState(liveIssue);
+    }
+    return undefined;
+}
+function isApprovedAndGreen(prReviewState, prCheckStatus) {
+    const normalizedReview = prReviewState?.trim().toLowerCase();
+    const normalizedChecks = prCheckStatus?.trim().toLowerCase();
+    return normalizedReview === "approved" && (normalizedChecks === "success" || normalizedChecks === "passed");
+}
+function hasPendingReviewQuillVerdict(snapshotJson) {
+    if (!snapshotJson)
+        return false;
+    try {
+        const parsed = JSON.parse(snapshotJson);
+        return Array.isArray(parsed.checks) && parsed.checks.some((check) => typeof check.name === "string"
+            && check.name === "review-quill/verdict"
+            && typeof check.status === "string"
+            && check.status.toLowerCase() === "pending");
+    }
+    catch {
+        return false;
+    }
+}

package/dist/merged-linear-completion-reconciler.js

@@ -0,0 +1,48 @@
+import { resolvePreferredCompletedLinearState } from "./linear-workflow.js";
+export class MergedLinearCompletionReconciler {
+    db;
+    linearProvider;
+    logger;
+    constructor(db, linearProvider, logger) {
+        this.db = db;
+        this.linearProvider = linearProvider;
+        this.logger = logger;
+    }
+    async reconcile() {
+        for (const issue of this.db.issues.listIssues()) {
+            if (issue.prState !== "merged")
+                continue;
+            if (issue.currentLinearStateType?.trim().toLowerCase() === "completed")
+                continue;
+            const linear = await this.linearProvider.forProject(issue.projectId).catch(() => undefined);
+            if (!linear)
+                continue;
+            try {
+                const liveIssue = await linear.getIssue(issue.linearIssueId);
+                const targetState = resolvePreferredCompletedLinearState(liveIssue);
+                if (!targetState)
+                    continue;
+                const normalizedCurrent = liveIssue.stateName?.trim().toLowerCase();
+                if (normalizedCurrent === targetState.trim().toLowerCase()) {
+                    this.db.issues.upsertIssue({
+                        projectId: issue.projectId,
+                        linearIssueId: issue.linearIssueId,
+                        ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
+                        ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
+                    });
+                    continue;
+                }
+                const updated = await linear.setIssueState(issue.linearIssueId, targetState);
+                this.db.issues.upsertIssue({
+                    projectId: issue.projectId,
+                    linearIssueId: issue.linearIssueId,
+                    ...(updated.stateName ? { currentLinearState: updated.stateName } : {}),
+                    ...(updated.stateType ? { currentLinearStateType: updated.stateType } : {}),
+                });
+            }
+            catch (error) {
+                this.logger.warn({ issueKey: issue.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to reconcile merged issue to a completed Linear state");
+            }
+        }
+    }
+}

package/dist/no-pr-completion-check.js

@@ -0,0 +1,199 @@
+import { buildCompletionCheckActivity } from "./linear-session-reporting.js";
+export async function handleNoPrCompletionCheck(params) {
+    const completedRunUpdate = buildCompletedRunUpdate({
+        threadId: params.threadId,
+        ...(params.completedTurnId ? { completedTurnId: params.completedTurnId } : {}),
+        report: params.report,
+    });
+    params.publishTurnEvent({
+        level: "info",
+        run: params.run,
+        issueKey: params.issue.issueKey,
+        status: "completion_check_started",
+        summary: "No PR found; checking next step",
+        detail: params.publishedOutcomeError,
+    });
+    void params.emitActivity(params.issue, buildCompletionCheckActivity("started"), { ephemeral: true });
+    let completionCheck;
+    try {
+        completionCheck = await params.completionCheck.run({
+            issue: params.issue,
+            run: params.run,
+            noPrSummary: params.publishedOutcomeError,
+            onStarted: ({ threadId: completionCheckThreadId, turnId: completionCheckTurnId }) => {
+                params.db.runs.markCompletionCheckStarted(params.run.id, {
+                    threadId: completionCheckThreadId,
+                    turnId: completionCheckTurnId,
+                });
+            },
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const failureMessage = `No PR observed and the completion check failed: ${message}`;
+        params.failRunAndClear(params.run, failureMessage, "failed");
+        params.syncFailureOutcome({
+            run: params.run,
+            fallbackIssue: params.issue,
+            message: failureMessage,
+            level: "error",
+            status: "completion_check_failed",
+            summary: "No PR found; completion check failed",
+            detail: message,
+        });
+        return;
+    }
+    if (completionCheck.outcome === "continue") {
+        const continued = params.withHeldLease(params.run.projectId, params.run.linearIssueId, (lease) => {
+            params.db.runs.finishRun(params.run.id, completedRunUpdate);
+            params.db.runs.saveCompletionCheck(params.run.id, completionCheck);
+            params.db.issues.upsertIssue({
+                projectId: params.run.projectId,
+                linearIssueId: params.run.linearIssueId,
+                activeRunId: null,
+                factoryState: "delegated",
+                pendingRunType: null,
+                pendingRunContextJson: null,
+            });
+            return Boolean(params.db.issueSessions.appendIssueSessionEventWithLease(lease, {
+                projectId: params.run.projectId,
+                linearIssueId: params.run.linearIssueId,
+                eventType: "completion_check_continue",
+                eventJson: JSON.stringify({
+                    runType: params.run.runType,
+                    summary: completionCheck.summary,
+                }),
+                dedupeKey: `completion_check_continue:${params.run.id}`,
+            }));
+        });
+        if (!continued) {
+            params.logger.warn({ runId: params.run.id, issueId: params.run.linearIssueId }, "Skipping completion-check continue writes after losing issue-session lease");
+            params.clearProgressAndRelease(params.run);
+            return;
+        }
+        params.syncCompletionCheckOutcome({
+            run: params.run,
+            fallbackIssue: params.issue,
+            level: "info",
+            status: "completion_check_continue",
+            summary: "No PR found; continuing automatically",
+            detail: completionCheck.summary,
+            activity: buildCompletionCheckActivity("continue"),
+            enqueue: true,
+        });
+        return;
+    }
+    if (completionCheck.outcome === "needs_input") {
+        const completed = params.withHeldLease(params.run.projectId, params.run.linearIssueId, (lease) => {
+            params.db.runs.finishRun(params.run.id, completedRunUpdate);
+            params.db.runs.saveCompletionCheck(params.run.id, completionCheck);
+            params.db.issueSessions.clearPendingIssueSessionEventsWithLease(lease);
+            params.db.issues.upsertIssue({
+                projectId: params.run.projectId,
+                linearIssueId: params.run.linearIssueId,
+                activeRunId: null,
+                factoryState: "awaiting_input",
+                pendingRunType: null,
+                pendingRunContextJson: null,
+            });
+            return true;
+        });
+        if (!completed) {
+            params.logger.warn({ runId: params.run.id, issueId: params.run.linearIssueId }, "Skipping completion-check needs-input writes after losing issue-session lease");
+            params.clearProgressAndRelease(params.run);
+            return;
+        }
+        params.syncCompletionCheckOutcome({
+            run: params.run,
+            fallbackIssue: params.issue,
+            level: "warn",
+            status: "completion_check_needs_input",
+            summary: "No PR found; waiting for answer",
+            detail: completionCheck.question ?? completionCheck.summary,
+            activity: buildCompletionCheckActivity("needs_input", completionCheck),
+        });
+        return;
+    }
+    if (completionCheck.outcome === "done") {
+        const completed = params.withHeldLease(params.run.projectId, params.run.linearIssueId, (lease) => {
+            params.db.runs.finishRun(params.run.id, completedRunUpdate);
+            params.db.runs.saveCompletionCheck(params.run.id, completionCheck);
+            params.db.issueSessions.clearPendingIssueSessionEventsWithLease(lease);
+            params.db.issues.upsertIssue({
+                projectId: params.run.projectId,
+                linearIssueId: params.run.linearIssueId,
+                activeRunId: null,
+                factoryState: "done",
+                pendingRunType: null,
+                pendingRunContextJson: null,
+                lastGitHubFailureSource: null,
+                lastGitHubFailureHeadSha: null,
+                lastGitHubFailureSignature: null,
+                lastGitHubFailureCheckName: null,
+                lastGitHubFailureCheckUrl: null,
+                lastGitHubFailureContextJson: null,
+                lastGitHubFailureAt: null,
+                lastQueueIncidentJson: null,
+                lastAttemptedFailureHeadSha: null,
+                lastAttemptedFailureSignature: null,
+            });
+            return true;
+        });
+        if (!completed) {
+            params.logger.warn({ runId: params.run.id, issueId: params.run.linearIssueId }, "Skipping completion-check done writes after losing issue-session lease");
+            params.clearProgressAndRelease(params.run);
+            return;
+        }
+        params.syncCompletionCheckOutcome({
+            run: params.run,
+            fallbackIssue: params.issue,
+            level: "info",
+            status: "completion_check_done",
+            summary: "No PR found; confirmed done",
+            detail: completionCheck.summary,
+            activity: buildCompletionCheckActivity("done", completionCheck),
+        });
+        return;
+    }
+    const failureReason = `No PR observed and the completion check failed this run: ${completionCheck.summary}`;
+    const failed = params.withHeldLease(params.run.projectId, params.run.linearIssueId, () => {
+        params.db.runs.finishRun(params.run.id, {
+            ...completedRunUpdate,
+            status: "failed",
+            failureReason,
+        });
+        params.db.runs.saveCompletionCheck(params.run.id, completionCheck);
+        params.db.issues.upsertIssue({
+            projectId: params.run.projectId,
+            linearIssueId: params.run.linearIssueId,
+            activeRunId: null,
+            factoryState: "failed",
+            pendingRunType: null,
+            pendingRunContextJson: null,
+        });
+        return true;
+    });
+    if (!failed) {
+        params.logger.warn({ runId: params.run.id, issueId: params.run.linearIssueId }, "Skipping completion-check failed writes after losing issue-session lease");
+        params.clearProgressAndRelease(params.run);
+        return;
+    }
+    params.syncFailureOutcome({
+        run: params.run,
+        fallbackIssue: params.issue,
+        message: failureReason,
+        level: "warn",
+        status: "completion_check_failed",
+        summary: "No PR found; completion check failed",
+        detail: completionCheck.summary,
+    });
+}
+function buildCompletedRunUpdate(params) {
+    return {
+        status: "completed",
+        threadId: params.threadId,
+        ...(params.completedTurnId ? { turnId: params.completedTurnId } : {}),
+        summaryJson: JSON.stringify({ latestAssistantMessage: params.report.assistantMessages.at(-1) ?? null }),
+        reportJson: JSON.stringify(params.report),
+    };
+}

package/dist/operator-retry-event.js

@@ -0,0 +1,58 @@
+function parseObjectJson(value) {
+    if (!value)
+        return undefined;
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function buildOperatorRetryEvent(issue, runType) {
+    if (runType === "queue_repair") {
+        const queueIncident = parseObjectJson(issue.lastQueueIncidentJson);
+        const failureContext = parseObjectJson(issue.lastGitHubFailureContextJson);
+        return {
+            eventType: "merge_steward_incident",
+            eventJson: JSON.stringify({
+                ...(queueIncident ?? {}),
+                ...(failureContext ?? {}),
+                source: "operator_retry",
+            }),
+            dedupeKey: `operator_retry:queue_repair:${issue.linearIssueId}:${issue.prHeadSha ?? issue.lastGitHubFailureHeadSha ?? "unknown-sha"}`,
+        };
+    }
+    if (runType === "ci_repair") {
+        const failureContext = parseObjectJson(issue.lastGitHubFailureContextJson);
+        return {
+            eventType: "settled_red_ci",
+            eventJson: JSON.stringify({
+                ...(failureContext ?? {}),
+                source: "operator_retry",
+            }),
+            dedupeKey: `operator_retry:ci_repair:${issue.linearIssueId}:${issue.lastGitHubFailureSignature ?? issue.prHeadSha ?? "unknown-sha"}`,
+        };
+    }
+    if (runType === "review_fix" || runType === "branch_upkeep") {
+        return {
+            eventType: "review_changes_requested",
+            eventJson: JSON.stringify({
+                reviewBody: runType === "branch_upkeep"
+                    ? "Operator requested retry of branch upkeep after requested changes."
+                    : "Operator requested retry of review-fix work.",
+                ...(runType === "branch_upkeep" ? { branchUpkeepRequired: true, wakeReason: "branch_upkeep" } : {}),
+                source: "operator_retry",
+            }),
+            dedupeKey: `operator_retry:${runType}:${issue.linearIssueId}:${issue.prHeadSha ?? "unknown-sha"}`,
+        };
+    }
+    return {
+        eventType: "delegated",
+        eventJson: JSON.stringify({
+            promptContext: "Operator requested retry of PatchRelay work.",
+            source: "operator_retry",
+        }),
+        dedupeKey: `operator_retry:implementation:${issue.linearIssueId}`,
+    };
+}

package/dist/public-agent-session-status-query.js

@@ -0,0 +1,52 @@
+import { extractStageSummary, summarizeCurrentThread } from "./run-reporting.js";
+import { parseStageReport } from "./issue-overview-query.js";
+export class PublicAgentSessionStatusQuery {
+    db;
+    overviewQuery;
+    constructor(db, overviewQuery) {
+        this.db = db;
+        this.overviewQuery = overviewQuery;
+    }
+    async getStatus(issueKey) {
+        const overview = await this.overviewQuery.getIssueOverview(issueKey);
+        if (!overview)
+            return undefined;
+        const issueRecord = this.db.issues.getIssueByKey(issueKey);
+        const latestRunReport = parseStageReport(overview.latestRun?.reportJson, overview.latestRun?.status ?? "unknown");
+        const runs = (overview.runs ?? this.overviewQuery.buildRuns(overview.issue.projectId, overview.issue.linearIssueId)).map((run) => ({
+            run: {
+                id: run.id,
+                runType: run.runType,
+                status: run.status,
+                startedAt: run.startedAt,
+                ...(run.endedAt ? { endedAt: run.endedAt } : {}),
+            },
+            ...(run.report ? { report: run.report } : {}),
+        }));
+        return {
+            issue: {
+                issueKey: overview.issue.issueKey,
+                title: overview.issue.title,
+                issueUrl: overview.issue.issueUrl,
+                currentLinearState: overview.issue.currentLinearState,
+                ...(overview.session?.sessionState ? { sessionState: overview.session.sessionState } : {}),
+                factoryState: overview.issue.factoryState,
+                ...(overview.session?.prNumber !== undefined ? { prNumber: overview.session.prNumber } : {}),
+                ...(issueRecord?.prUrl ? { prUrl: issueRecord.prUrl } : {}),
+                ...(issueRecord?.prState ? { prState: issueRecord.prState } : {}),
+                ...(issueRecord?.prReviewState ? { prReviewState: issueRecord.prReviewState } : {}),
+                ...(issueRecord?.prCheckStatus ? { prCheckStatus: issueRecord.prCheckStatus } : {}),
+                ...(issueRecord ? { ciRepairAttempts: issueRecord.ciRepairAttempts, queueRepairAttempts: issueRecord.queueRepairAttempts } : {}),
+                ...(overview.issue.waitingReason ? { waitingReason: overview.issue.waitingReason } : {}),
+                ...(overview.issue.statusNote ? { statusNote: overview.issue.statusNote } : {}),
+                ...(overview.session?.lastWakeReason ? { lastWakeReason: overview.session.lastWakeReason } : {}),
+            },
+            ...(overview.activeRun ? { activeRun: overview.activeRun } : {}),
+            ...(overview.latestRun ? { latestRun: overview.latestRun } : {}),
+            ...(overview.liveThread ? { liveThread: summarizeCurrentThread(overview.liveThread) } : {}),
+            ...(latestRunReport ? { latestReportSummary: extractStageSummary(latestRunReport) } : {}),
+            runs,
+            generatedAt: new Date().toISOString(),
+        };
+    }
+}