patchrelay 0.35.11 → 0.35.12

package/dist/issue-query-service.js

@@ -1,115 +1,225 @@
-import { parseGitHubFailureContext, summarizeGitHubFailureContext } from "./github-failure-context.js";
-import { parseStoredQueueRepairContext } from "./merge-queue-incident.js";
-import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
+import { parseGitHubFailureContext } from "./github-failure-context.js";
+import { isIssueSessionReadyForExecution } from "./issue-session.js";
 import { extractStageSummary, summarizeCurrentThread } from "./run-reporting.js";
-import { safeJsonParse } from "./utils.js";
+import { deriveIssueStatusNote } from "./status-note.js";
+import { derivePatchRelayWaitingReason } from "./waiting-reason.js";
+function parseStageReport(reportJson, runStatus) {
+    if (!reportJson)
+        return undefined;
+    try {
+        const parsed = JSON.parse(reportJson);
+        return { ...parsed, status: runStatus };
+    }
+    catch {
+        return undefined;
+    }
+}
 export class IssueQueryService {
-    config;
     db;
     codex;
     runStatusProvider;
-    constructor(config, db, codex, runStatusProvider) {
-        this.config = config;
+    constructor(db, codex, runStatusProvider) {
         this.db = db;
         this.codex = codex;
         this.runStatusProvider = runStatusProvider;
     }
-    async getIssueOverview(issueKey) {
-        const result = this.db.getIssueOverview(issueKey);
-        if (!result)
+    async readLiveThread(run) {
+        if (!run?.threadId)
             return undefined;
-        const issueRecord = this.db.getIssueByKey(issueKey);
-        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 (activeRun?.threadId) {
-            liveThread = await this.codex.readThread(activeRun.threadId, true).then(summarizeCurrentThread).catch(() => undefined);
-        }
-        return {
-            ...result,
-            issue: issueRecord ? { ...result.issue, queueProtocol: this.buildQueueProtocol(issueRecord.projectId, issueRecord) } : result.issue,
-            ...(activeRun ? { activeRun } : {}),
-            ...(latestRun ? { latestRun } : {}),
-            ...(liveThread ? { liveThread } : {}),
-        };
-    }
-    async getIssueReport(issueKey) {
-        const issue = this.db.getTrackedIssueByKey(issueKey);
-        if (!issue)
-            return undefined;
-        return {
-            issue,
-            runs: this.db.listRunsForIssue(issue.projectId, issue.linearIssueId).map((run) => ({
-                run,
-                ...(run.reportJson ? { report: JSON.parse(run.reportJson) } : {}),
-            })),
-        };
-    }
-    async getRunEvents(issueKey, runId) {
-        const issue = this.db.getTrackedIssueByKey(issueKey);
-        if (!issue)
-            return undefined;
-        const run = this.db.getRun(runId);
-        if (!run || run.projectId !== issue.projectId || run.linearIssueId !== issue.linearIssueId)
-            return undefined;
-        return {
-            issue,
-            run,
-            events: this.db.listThreadEvents(runId).map((event) => ({
-                ...event,
-                parsedEvent: safeJsonParse(event.eventJson),
-            })),
-        };
+        return await this.codex.readThread(run.threadId, true).catch(() => undefined);
     }
-    async getIssueTimeline(issueKey) {
-        const issue = this.db.getTrackedIssueByKey(issueKey);
-        if (!issue)
-            return undefined;
-        const fullIssue = this.db.getIssueByKey(issueKey);
-        const runs = this.db.listRunsForIssue(issue.projectId, issue.linearIssueId).map((run) => ({
+    buildRuns(projectId, linearIssueId) {
+        return this.db.listRunsForIssue(projectId, linearIssueId).map((run) => ({
             id: run.id,
             runType: run.runType,
             status: run.status,
             startedAt: run.startedAt,
-            endedAt: run.endedAt,
-            threadId: run.threadId,
-            events: this.db.listThreadEvents(run.id).map((event) => ({
-                id: event.id,
-                method: event.method,
-                createdAt: event.createdAt,
-                parsedEvent: safeJsonParse(event.eventJson),
-            })),
-            ...(run.reportJson ? { report: JSON.parse(run.reportJson) } : {}),
+            ...(run.endedAt ? { endedAt: run.endedAt } : {}),
+            ...(run.threadId ? { threadId: run.threadId } : {}),
+            ...(() => {
+                const report = parseStageReport(run.reportJson, run.status);
+                return report ? { report } : {};
+            })(),
+            ...(() => {
+                const events = this.db.listThreadEvents(run.id).flatMap((event) => {
+                    try {
+                        const parsed = JSON.parse(event.eventJson);
+                        return [{
+                                id: event.id,
+                                method: event.method,
+                                createdAt: event.createdAt,
+                                ...(parsed && typeof parsed === "object" && !Array.isArray(parsed)
+                                    ? { parsedEvent: parsed }
+                                    : {}),
+                            }];
+                    }
+                    catch {
+                        return [{
+                                id: event.id,
+                                method: event.method,
+                                createdAt: event.createdAt,
+                            }];
+                    }
+                });
+                return events.length > 0 ? { events } : {};
+            })(),
         }));
-        const feedEvents = this.db.operatorFeed.list({ issueKey, limit: 500 });
-        let liveThread = undefined;
-        const activeRunId = fullIssue?.activeRunId;
-        const activeRun = activeRunId !== undefined ? runs.find((r) => r.id === activeRunId) : undefined;
-        if (activeRun?.threadId) {
-            liveThread = await this.codex.readThread(activeRun.threadId, true).catch(() => undefined);
+    }
+    async getIssueOverview(issueKey) {
+        const session = this.db.getIssueSessionByKey(issueKey);
+        if (!session) {
+            const legacy = this.db.getIssueOverview(issueKey);
+            if (!legacy)
+                return undefined;
+            const issueRecord = this.db.getIssueByKey(issueKey);
+            const activeStatus = await this.runStatusProvider.getActiveRunStatus(issueKey);
+            const activeRun = activeStatus?.run ?? legacy.activeRun;
+            const latestRun = this.db.getLatestRunForIssue(legacy.issue.projectId, legacy.issue.linearIssueId);
+            const latestEvent = this.db.listIssueSessionEvents(legacy.issue.projectId, legacy.issue.linearIssueId, { limit: 1 }).at(-1);
+            const runs = this.buildRuns(legacy.issue.projectId, legacy.issue.linearIssueId);
+            const runCount = runs.length;
+            const liveThread = await this.readLiveThread(activeRun);
+            const statusNote = issueRecord
+                ? deriveIssueStatusNote({
+                    issue: issueRecord,
+                    latestRun,
+                    latestEvent,
+                    failureSummary: legacy.issue.latestFailureSummary,
+                    blockedByKeys: legacy.issue.blockedByKeys,
+                    waitingReason: legacy.issue.waitingReason,
+                })
+                : legacy.issue.statusNote;
+            return {
+                issue: {
+                    ...legacy.issue,
+                    ...(statusNote ? { statusNote } : {}),
+                },
+                ...(activeRun ? { activeRun } : {}),
+                ...(latestRun ? { latestRun } : {}),
+                ...(liveThread ? { liveThread } : {}),
+                ...(runs.length > 0 ? { runs } : {}),
+                ...(issueRecord
+                    ? {
+                        issueContext: {
+                            ...(issueRecord.description ? { description: issueRecord.description } : {}),
+                            ...(issueRecord.currentLinearState ? { currentLinearState: issueRecord.currentLinearState } : {}),
+                            ...(issueRecord.url ? { issueUrl: issueRecord.url } : {}),
+                            ...(issueRecord.worktreePath ? { worktreePath: issueRecord.worktreePath } : {}),
+                            ...(issueRecord.branchName ? { branchName: issueRecord.branchName } : {}),
+                            ...(issueRecord.prUrl ? { prUrl: issueRecord.prUrl } : {}),
+                            ...(issueRecord.priority != null ? { priority: issueRecord.priority } : {}),
+                            ...(issueRecord.estimate != null ? { estimate: issueRecord.estimate } : {}),
+                            ciRepairAttempts: issueRecord.ciRepairAttempts,
+                            queueRepairAttempts: issueRecord.queueRepairAttempts,
+                            reviewFixAttempts: issueRecord.reviewFixAttempts,
+                            ...(legacy.issue.latestFailureSource ? { latestFailureSource: legacy.issue.latestFailureSource } : {}),
+                            ...(legacy.issue.latestFailureHeadSha ? { latestFailureHeadSha: legacy.issue.latestFailureHeadSha } : {}),
+                            ...(legacy.issue.latestFailureCheckName ? { latestFailureCheckName: legacy.issue.latestFailureCheckName } : {}),
+                            ...(legacy.issue.latestFailureStepName ? { latestFailureStepName: legacy.issue.latestFailureStepName } : {}),
+                            ...(legacy.issue.latestFailureSummary ? { latestFailureSummary: legacy.issue.latestFailureSummary } : {}),
+                            runCount,
+                        },
+                    }
+                    : {}),
+            };
         }
+        const issueRecord = this.db.getIssueByKey(issueKey);
+        const blockedBy = this.db.listIssueDependencies(session.projectId, session.linearIssueId);
+        const unresolvedBlockedBy = blockedBy.filter((entry) => (entry.blockerCurrentLinearStateType !== "completed"
+            && entry.blockerCurrentLinearState?.trim().toLowerCase() !== "done"));
+        const blockedByKeys = unresolvedBlockedBy.map((entry) => entry.blockerIssueKey ?? entry.blockerLinearIssueId);
+        const activeStatus = await this.runStatusProvider.getActiveRunStatus(issueKey);
+        const activeRun = activeStatus?.run
+            ?? (session.activeRunId !== undefined ? this.db.getRun(session.activeRunId) : undefined);
+        const latestRun = this.db.getLatestRunForIssue(session.projectId, session.linearIssueId);
+        const latestEvent = this.db.listIssueSessionEvents(session.projectId, session.linearIssueId, { limit: 1 }).at(-1);
+        const runs = this.buildRuns(session.projectId, session.linearIssueId);
+        const runCount = runs.length;
+        const liveThread = await this.readLiveThread(activeRun);
+        const failureContext = parseGitHubFailureContext(issueRecord?.lastGitHubFailureContextJson);
+        const waitingReason = session.waitingReason ?? derivePatchRelayWaitingReason({
+            ...(activeRun ? { activeRunType: activeRun.runType } : {}),
+            blockedByKeys,
+            factoryState: issueRecord?.factoryState ?? "delegated",
+            pendingRunType: issueRecord?.pendingRunType,
+            prNumber: session.prNumber,
+            prReviewState: issueRecord?.prReviewState,
+            prCheckStatus: issueRecord?.prCheckStatus,
+            latestFailureCheckName: issueRecord?.lastGitHubFailureCheckName,
+        });
+        const issue = {
+            id: issueRecord?.id ?? session.id,
+            projectId: session.projectId,
+            linearIssueId: session.linearIssueId,
+            ...(session.issueKey ? { issueKey: session.issueKey } : {}),
+            ...(issueRecord?.title ? { title: issueRecord.title } : {}),
+            ...(issueRecord?.url ? { issueUrl: issueRecord.url } : {}),
+            ...(issueRecord?.currentLinearState ? { currentLinearState: issueRecord.currentLinearState } : {}),
+            sessionState: session.sessionState,
+            factoryState: issueRecord?.factoryState ?? "delegated",
+            blockedByCount: unresolvedBlockedBy.length,
+            blockedByKeys,
+            readyForExecution: isIssueSessionReadyForExecution({
+                sessionState: session.sessionState,
+                factoryState: issueRecord?.factoryState ?? "delegated",
+                ...(activeRun ? { activeRunId: activeRun.id } : {}),
+                blockedByCount: unresolvedBlockedBy.length,
+                hasPendingWake: this.db.peekIssueSessionWake(session.projectId, session.linearIssueId) !== undefined,
+                hasLegacyPendingRun: issueRecord?.pendingRunType !== undefined,
+                ...(session.prNumber !== undefined ? { prNumber: session.prNumber } : {}),
+                ...(issueRecord?.prState ? { prState: issueRecord.prState } : {}),
+                ...(issueRecord?.prReviewState ? { prReviewState: issueRecord.prReviewState } : {}),
+                ...(issueRecord?.prCheckStatus ? { prCheckStatus: issueRecord.prCheckStatus } : {}),
+                ...(issueRecord?.lastGitHubFailureSource ? { latestFailureSource: issueRecord.lastGitHubFailureSource } : {}),
+            }),
+            ...(issueRecord?.lastGitHubFailureSource ? { latestFailureSource: issueRecord.lastGitHubFailureSource } : {}),
+            ...(issueRecord?.lastGitHubFailureHeadSha ? { latestFailureHeadSha: issueRecord.lastGitHubFailureHeadSha } : {}),
+            ...(issueRecord?.lastGitHubFailureCheckName ? { latestFailureCheckName: issueRecord.lastGitHubFailureCheckName } : {}),
+            ...(() => {
+                const statusNote = issueRecord
+                    ? deriveIssueStatusNote({
+                        issue: issueRecord,
+                        sessionSummary: session.summaryText,
+                        latestRun,
+                        latestEvent,
+                        failureSummary: failureContext?.summary,
+                        blockedByKeys,
+                        waitingReason,
+                    })
+                    : undefined;
+                return statusNote ? { statusNote } : {};
+            })(),
+            ...(waitingReason ? { waitingReason } : {}),
+            ...(activeRun ? { activeRunId: activeRun.id } : {}),
+            ...(issueRecord?.agentSessionId ? { activeAgentSessionId: issueRecord.agentSessionId } : {}),
+            updatedAt: session.updatedAt,
+        };
         return {
-            issue: {
-                ...issue,
-                ...(fullIssue?.description ? { description: fullIssue.description } : {}),
-                ...(fullIssue?.branchName ? { branchName: fullIssue.branchName } : {}),
-                ...(fullIssue?.worktreePath ? { worktreePath: fullIssue.worktreePath } : {}),
-                ...(fullIssue?.prUrl ? { prUrl: fullIssue.prUrl } : {}),
-                ...(fullIssue?.priority != null ? { priority: fullIssue.priority } : {}),
-                ...(fullIssue?.estimate != null ? { estimate: fullIssue.estimate } : {}),
-                ciRepairAttempts: fullIssue?.ciRepairAttempts ?? 0,
-                queueRepairAttempts: fullIssue?.queueRepairAttempts ?? 0,
-                reviewFixAttempts: fullIssue?.reviewFixAttempts ?? 0,
-                ...(fullIssue ? { queueProtocol: this.buildQueueProtocol(fullIssue.projectId, fullIssue) } : {}),
+            issue,
+            session,
+            ...(activeRun ? { activeRun } : {}),
+            ...(latestRun ? { latestRun } : {}),
+            ...(liveThread ? { liveThread } : {}),
+            ...(runs.length > 0 ? { runs } : {}),
+            issueContext: {
+                ...(issueRecord?.description ? { description: issueRecord.description } : {}),
+                ...(issueRecord?.currentLinearState ? { currentLinearState: issueRecord.currentLinearState } : {}),
+                ...(issueRecord?.url ? { issueUrl: issueRecord.url } : {}),
+                ...(session.worktreePath ? { worktreePath: session.worktreePath } : {}),
+                ...(session.branchName ? { branchName: session.branchName } : {}),
+                ...(issueRecord?.prUrl ? { prUrl: issueRecord.prUrl } : {}),
+                ...(issueRecord?.priority != null ? { priority: issueRecord.priority } : {}),
+                ...(issueRecord?.estimate != null ? { estimate: issueRecord.estimate } : {}),
+                ciRepairAttempts: issueRecord?.ciRepairAttempts ?? session.ciRepairAttempts,
+                queueRepairAttempts: issueRecord?.queueRepairAttempts ?? session.queueRepairAttempts,
+                reviewFixAttempts: issueRecord?.reviewFixAttempts ?? session.reviewFixAttempts,
+                ...(issue.latestFailureSource ? { latestFailureSource: issue.latestFailureSource } : {}),
+                ...(issue.latestFailureHeadSha ? { latestFailureHeadSha: issue.latestFailureHeadSha } : {}),
+                ...(issue.latestFailureCheckName ? { latestFailureCheckName: issue.latestFailureCheckName } : {}),
+                ...(issue.latestFailureStepName ? { latestFailureStepName: issue.latestFailureStepName } : {}),
+                ...(issue.latestFailureSummary ? { latestFailureSummary: issue.latestFailureSummary } : {}),
+                runCount,
             },
-            runs,
-            feedEvents,
-            liveThread,
-            activeRunId,
         };
     }
     async getActiveRunStatus(issueKey) {
@@ -120,59 +230,41 @@ export class IssueQueryService {
         if (!overview)
             return undefined;
         const issueRecord = this.db.getIssueByKey(issueKey);
-        const report = await this.getIssueReport(issueKey);
-        const latestRunReport = report?.runs.at(-1)?.report;
+        const latestRunReport = parseStageReport(overview.latestRun?.reportJson, overview.latestRun?.status ?? "unknown");
+        const runs = (overview.runs ?? this.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,
-                ...(issueRecord?.prNumber !== undefined ? { prNumber: issueRecord.prNumber } : {}),
+                ...(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 } : {}),
-                ...(issueRecord ? { queueProtocol: this.buildQueueProtocol(issueRecord.projectId, issueRecord) } : {}),
+                ...(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: overview.liveThread } : {}),
+            ...(overview.liveThread ? { liveThread: summarizeCurrentThread(overview.liveThread) } : {}),
             ...(latestRunReport ? { latestReportSummary: extractStageSummary(latestRunReport) } : {}),
-            feedEvents: this.db.operatorFeed.list({ issueKey, limit: 500 }),
-            activeRunId: issueRecord?.activeRunId ?? null,
-            runs: report?.runs ?? [],
+            runs,
             generatedAt: new Date().toISOString(),
         };
     }
-    buildQueueProtocol(projectId, issue) {
-        const project = this.config.projects.find((entry) => entry.id === projectId);
-        const protocol = resolveMergeQueueProtocol(project);
-        const failureContext = parseGitHubFailureContext(issue.lastGitHubFailureContextJson);
-        const queueIncident = issue.lastQueueIncidentJson
-            ? parseStoredQueueRepairContext(issue.lastQueueIncidentJson)
-            : undefined;
-        return {
-            repoFullName: protocol.repoFullName,
-            baseBranch: protocol.baseBranch,
-            admissionLabel: protocol.admissionLabel,
-            evictionCheckName: protocol.evictionCheckName,
-            prNumber: issue.prNumber ?? null,
-            lastFailureSource: issue.lastGitHubFailureSource ?? null,
-            lastFailureHeadSha: issue.lastGitHubFailureHeadSha ?? failureContext?.headSha ?? null,
-            lastFailureSignature: issue.lastGitHubFailureSignature ?? failureContext?.failureSignature ?? null,
-            lastFailureCheckName: issue.lastGitHubFailureCheckName ?? null,
-            lastFailureCheckUrl: issue.lastGitHubFailureCheckUrl ?? null,
-            lastFailureStepName: failureContext?.stepName ?? null,
-            lastFailureSummary: summarizeGitHubFailureContext(failureContext) ?? null,
-            lastFailureAt: issue.lastGitHubFailureAt ?? null,
-            lastQueueSignalAt: issue.lastQueueSignalAt ?? null,
-            lastIncidentId: queueIncident?.incidentId ?? null,
-            lastIncidentUrl: queueIncident?.incidentUrl ?? null,
-            lastIncidentFailureClass: queueIncident?.incidentContext?.failureClass ?? null,
-            lastIncidentSummary: queueIncident?.incidentSummary ?? null,
-        };
-    }
 }

package/dist/issue-session-events.js

@@ -0,0 +1,151 @@
+const TERMINAL_SESSION_EVENTS = new Set([
+    "stop_requested",
+    "undelegated",
+    "issue_removed",
+    "pr_closed",
+    "pr_merged",
+]);
+export function deriveSessionWakePlan(issue, events) {
+    if (events.length === 0)
+        return undefined;
+    if (events.some((event) => TERMINAL_SESSION_EVENTS.has(event.eventType))) {
+        return undefined;
+    }
+    const context = {};
+    const followUps = [];
+    let wakeReason;
+    let runType;
+    let resumeThread = false;
+    for (const event of events) {
+        const payload = parseEventJson(event.eventJson);
+        switch (event.eventType) {
+            case "merge_steward_incident":
+                runType = "queue_repair";
+                wakeReason = "merge_steward_incident";
+                Object.assign(context, payload ?? {});
+                break;
+            case "settled_red_ci":
+                if (runType !== "queue_repair") {
+                    runType = "ci_repair";
+                    wakeReason = "settled_red_ci";
+                    Object.assign(context, payload ?? {});
+                }
+                break;
+            case "review_changes_requested":
+                if (runType !== "queue_repair" && runType !== "ci_repair") {
+                    runType = "review_fix";
+                    wakeReason = "review_changes_requested";
+                    Object.assign(context, payload ?? {});
+                }
+                break;
+            case "delegated":
+                if (!runType) {
+                    runType = "implementation";
+                    wakeReason = "delegated";
+                }
+                if (payload?.promptContext !== undefined) {
+                    context.promptContext = payload.promptContext;
+                }
+                if (payload?.promptBody !== undefined) {
+                    context.promptBody = payload.promptBody;
+                }
+                break;
+            case "direct_reply": {
+                if (!runType) {
+                    runType = issue.prReviewState === "changes_requested" ? "review_fix" : "implementation";
+                    wakeReason = "direct_reply";
+                }
+                const text = typeof payload?.text === "string"
+                    ? payload.text
+                    : typeof payload?.body === "string" ? payload.body : undefined;
+                if (text) {
+                    followUps.push({
+                        type: event.eventType,
+                        text,
+                        ...(typeof payload?.author === "string" ? { author: payload.author } : {}),
+                    });
+                }
+                context.directReplyMode = true;
+                resumeThread = true;
+                break;
+            }
+            case "followup_prompt":
+            case "followup_comment":
+            case "operator_prompt": {
+                if (!runType) {
+                    runType = issue.prReviewState === "changes_requested" ? "review_fix" : "implementation";
+                    wakeReason = event.eventType;
+                }
+                const text = typeof payload?.text === "string"
+                    ? payload.text
+                    : typeof payload?.body === "string" ? payload.body : undefined;
+                if (text) {
+                    followUps.push({
+                        type: event.eventType,
+                        text,
+                        ...(typeof payload?.author === "string" ? { author: payload.author } : {}),
+                    });
+                }
+                if (event.eventType === "followup_prompt"
+                    || event.eventType === "followup_comment"
+                    || event.eventType === "operator_prompt") {
+                    resumeThread = true;
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    if (!runType)
+        return undefined;
+    if (followUps.length > 0) {
+        context.followUps = followUps;
+        context.followUpMode = true;
+        context.followUpCount = followUps.length;
+    }
+    if (wakeReason) {
+        context.wakeReason = wakeReason;
+    }
+    return { runType, wakeReason, resumeThread, context };
+}
+export function extractLatestAssistantSummary(run) {
+    if (!run)
+        return undefined;
+    if (run.summaryJson) {
+        try {
+            const parsed = JSON.parse(run.summaryJson);
+            if (typeof parsed.latestAssistantMessage === "string" && parsed.latestAssistantMessage.trim()) {
+                return parsed.latestAssistantMessage;
+            }
+        }
+        catch {
+            // ignore malformed summary json
+        }
+    }
+    if (run.reportJson) {
+        try {
+            const parsed = JSON.parse(run.reportJson);
+            if (Array.isArray(parsed.assistantMessages)) {
+                const latest = parsed.assistantMessages.findLast((value) => typeof value === "string" && value.trim());
+                if (typeof latest === "string")
+                    return latest;
+            }
+        }
+        catch {
+            // ignore malformed report json
+        }
+    }
+    return run.failureReason;
+}
+function parseEventJson(raw) {
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/issue-session.js

@@ -0,0 +1,99 @@
+import { derivePatchRelayWaitingReason } from "./waiting-reason.js";
+export function deriveIssueSessionState(params) {
+    if (params.factoryState === "done")
+        return "done";
+    if (params.factoryState === "failed" || params.factoryState === "escalated")
+        return "failed";
+    if (params.factoryState === "awaiting_input")
+        return "waiting_input";
+    if (params.activeRunId !== undefined)
+        return "running";
+    return "idle";
+}
+export function deriveIssueSessionWaitingReason(params) {
+    return derivePatchRelayWaitingReason(params);
+}
+export function deriveIssueSessionWakeReason(params) {
+    if (params.pendingRunType === "implementation")
+        return "delegated";
+    if (params.pendingRunType === "review_fix")
+        return "review_changes_requested";
+    if (params.pendingRunType === "ci_repair")
+        return "settled_red_ci";
+    if (params.pendingRunType === "queue_repair")
+        return "merge_steward_incident";
+    if (params.factoryState === "awaiting_input")
+        return "waiting_for_human_reply";
+    const reactiveIntent = deriveIssueSessionReactiveIntent({
+        prNumber: params.prNumber,
+        prState: params.prState,
+        prReviewState: params.prReviewState,
+        prCheckStatus: params.prCheckStatus,
+        latestFailureSource: params.latestFailureSource,
+    });
+    if (reactiveIntent)
+        return reactiveIntent.wakeReason;
+    return undefined;
+}
+export function deriveIssueSessionReactiveIntent(params) {
+    if (params.activeRunId !== undefined)
+        return undefined;
+    if (params.prNumber === undefined)
+        return undefined;
+    if (params.prState && params.prState !== "open")
+        return undefined;
+    if (params.latestFailureSource === "queue_eviction" || (params.mergeConflictDetected && params.downstreamOwned)) {
+        return {
+            runType: "queue_repair",
+            wakeReason: "merge_steward_incident",
+            compatibilityFactoryState: "repairing_queue",
+        };
+    }
+    if (params.prCheckStatus === "failed" || params.prCheckStatus === "failure" || params.latestFailureSource === "branch_ci") {
+        return {
+            runType: "ci_repair",
+            wakeReason: "settled_red_ci",
+            compatibilityFactoryState: "repairing_ci",
+        };
+    }
+    if (params.prReviewState === "changes_requested") {
+        return {
+            runType: "review_fix",
+            wakeReason: "review_changes_requested",
+            compatibilityFactoryState: "changes_requested",
+        };
+    }
+    return undefined;
+}
+export function isIssueSessionReadyForExecution(params) {
+    if (params.activeRunId !== undefined)
+        return false;
+    if (params.blockedByCount > 0)
+        return false;
+    if (params.sessionState === "done" || params.sessionState === "failed" || params.sessionState === "waiting_input") {
+        return false;
+    }
+    if (params.hasPendingWake) {
+        return true;
+    }
+    if (!params.hasLegacyPendingRun) {
+        return false;
+    }
+    if (deriveIssueSessionReactiveIntent({
+        prNumber: params.prNumber,
+        prState: params.prState,
+        prReviewState: params.prReviewState,
+        prCheckStatus: params.prCheckStatus,
+        latestFailureSource: params.latestFailureSource,
+    }) === undefined) {
+        return false;
+    }
+    if (params.factoryState === "awaiting_queue"
+        || params.factoryState === "awaiting_input"
+        || params.factoryState === "done"
+        || params.factoryState === "failed"
+        || params.factoryState === "escalated") {
+        return false;
+    }
+    return true;
+}