patchrelay 0.35.11 → 0.35.12

package/dist/run-reporting.js

@@ -1,3 +1,4 @@
+import { getThreadTurns } from "./codex-thread-utils.js";
 export function extractStageSummary(report) {
     return {
         assistantMessageCount: report.assistantMessages.length,
@@ -8,7 +9,8 @@ export function extractStageSummary(report) {
     };
 }
 export function summarizeCurrentThread(thread) {
-    const latestTurn = thread.turns.at(-1);
+    const turns = getThreadTurns(thread);
+    const latestTurn = turns.at(-1);
     const latestAgentMessage = latestTurn?.items
         .filter((item) => item.type === "agentMessage")
         .at(-1)?.text;
@@ -25,7 +27,7 @@ export function summarizeCurrentThread(thread) {
     let commandCount = 0;
     let fileChangeCount = 0;
     let toolCallCount = 0;
-    for (const turn of thread.turns) {
+    for (const turn of turns) {
         for (const item of turn.items) {
             if (item.type === "commandExecution") {
                 commandCount += 1;
@@ -57,7 +59,7 @@ export function buildStageReport(run, issue, thread, eventCounts) {
     const commands = [];
     const fileChanges = [];
     const toolCalls = [];
-    for (const turn of thread.turns) {
+    for (const turn of getThreadTurns(thread)) {
         for (const rawItem of turn.items) {
             const item = rawItem;
             if (item.type === "agentMessage" && typeof item.text === "string") {

package/dist/service.js

@@ -1,15 +1,18 @@
 import { resolveGitHubAppCredentials, createGitHubAppTokenManager, ensureGhWrapper, } from "./github-app-token.js";
 import { parseGitHubFailureContext, summarizeGitHubFailureContext } from "./github-failure-context.js";
+import { isIssueSessionReadyForExecution } from "./issue-session.js";
 import { GitHubWebhookHandler } from "./github-webhook-handler.js";
 import { IssueQueryService } from "./issue-query-service.js";
 import { DatabaseBackedLinearClientProvider } from "./linear-client.js";
 import { LinearOAuthService } from "./linear-oauth-service.js";
 import { RunOrchestrator } from "./run-orchestrator.js";
 import { OperatorEventFeed } from "./operator-feed.js";
+import { derivePatchRelayWaitingReason } from "./waiting-reason.js";
 import { buildSessionStatusUrl, createSessionStatusToken, deriveSessionStatusSigningSecret, verifySessionStatusToken, } from "./public-agent-session-status.js";
 import { ServiceRuntime } from "./service-runtime.js";
 import { WebhookHandler } from "./webhook-handler.js";
 import { acceptIncomingWebhook } from "./service-webhooks.js";
+import { deriveIssueStatusNote } from "./status-note.js";
 function parseObjectJson(value) {
     if (!value)
         return undefined;
@@ -21,19 +24,14 @@ function parseObjectJson(value) {
         return undefined;
     }
 }
-function extractStatusNote(summaryJson, reportJson) {
-    const summary = parseObjectJson(summaryJson);
-    if (typeof summary?.latestAssistantMessage === "string" && summary.latestAssistantMessage.trim()) {
-        return summary.latestAssistantMessage;
-    }
-    const report = parseObjectJson(reportJson);
-    const assistantMessages = report?.assistantMessages;
-    if (Array.isArray(assistantMessages)) {
-        const latest = assistantMessages.findLast((value) => typeof value === "string" && value.trim().length > 0);
-        if (typeof latest === "string")
-            return latest;
-    }
-    return undefined;
+function shouldSuppressStatusNote(params) {
+    if (!params.activeRunType && params.sessionState !== "running")
+        return false;
+    const note = params.statusNote?.trim().toLowerCase();
+    if (!note)
+        return true;
+    return note === "codex turn was interrupted"
+        || note === "patchrelay received your mention. delegate the issue to patchrelay to start work.";
 }
 export function parseCiSnapshotSummary(snapshotJson) {
     if (!snapshotJson)
@@ -116,7 +114,7 @@ export class PatchRelayService {
         });
         enqueueIssue = (projectId, issueId) => runtime.enqueueIssue(projectId, issueId);
         this.oauthService = new LinearOAuthService(config, { linearInstallations: db.linearInstallations }, logger);
-        this.queryService = new IssueQueryService(config, db, codex, this.orchestrator);
+        this.queryService = new IssueQueryService(db, codex, this.orchestrator);
         this.runtime = runtime;
         // Optional GitHub App token management for bot identity
         const ghAppCredentials = resolveGitHubAppCredentials();
@@ -132,6 +130,7 @@ export class PatchRelayService {
         });
     }
     async start() {
+        this.db.releaseExpiredIssueSessionLeases();
         const repairedInstallations = this.db.linearInstallations.repairProjectInstallations(this.config.projects.map((project) => project.id));
         for (const repair of repairedInstallations) {
             this.logger.info({ projectId: repair.projectId, installationId: repair.installationId, reason: repair.reason }, "Repaired Linear project installation link");
@@ -166,14 +165,110 @@ export class PatchRelayService {
             const identity = this.githubAppTokenManager.botIdentity();
             if (identity) {
                 this.orchestrator.botIdentity = identity;
+                this.githubWebhookHandler.setPatchRelayAuthorLogins([identity.name]);
             }
         }
         await this.runtime.start();
+        await this.recoverDelegatedIssueStateFromLinear();
+        void this.syncKnownAgentSessions().catch((error) => {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger.warn({ error: msg }, "Background agent session sync failed");
+        });
     }
     async stop() {
         this.githubAppTokenManager?.stop();
         await this.runtime.stop();
     }
+    async syncKnownAgentSessions() {
+        for (const issue of this.db.listIssues()) {
+            if (issue.factoryState === "done") {
+                continue;
+            }
+            const syncedIssue = issue.agentSessionId
+                ? issue
+                : (() => {
+                    const recoveredAgentSessionId = this.db.findLatestAgentSessionIdForIssue(issue.linearIssueId);
+                    return recoveredAgentSessionId
+                        ? this.db.upsertIssue({
+                            projectId: issue.projectId,
+                            linearIssueId: issue.linearIssueId,
+                            agentSessionId: recoveredAgentSessionId,
+                        })
+                        : issue;
+                })();
+            if (!syncedIssue.agentSessionId) {
+                continue;
+            }
+            const activeRun = syncedIssue.activeRunId ? this.db.getRun(syncedIssue.activeRunId) : undefined;
+            await this.orchestrator.linearSync.syncSession(syncedIssue, activeRun ? { activeRunType: activeRun.runType } : undefined);
+        }
+    }
+    async recoverDelegatedIssueStateFromLinear() {
+        for (const issue of this.db.listIssuesWithAgentSessions()) {
+            if (issue.factoryState === "done" || issue.activeRunId !== undefined) {
+                continue;
+            }
+            const linear = await this.linearProvider.forProject(issue.projectId).catch(() => undefined);
+            if (!linear) {
+                continue;
+            }
+            const installation = this.db.linearInstallations.getLinearInstallationForProject(issue.projectId);
+            if (!installation?.actorId) {
+                continue;
+            }
+            const liveIssue = await linear.getIssue(issue.linearIssueId).catch(() => undefined);
+            if (!liveIssue) {
+                continue;
+            }
+            this.db.replaceIssueDependencies({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                blockers: liveIssue.blockedBy.map((blocker) => ({
+                    blockerLinearIssueId: blocker.id,
+                    ...(blocker.identifier ? { blockerIssueKey: blocker.identifier } : {}),
+                    ...(blocker.title ? { blockerTitle: blocker.title } : {}),
+                    ...(blocker.stateName ? { blockerCurrentLinearState: blocker.stateName } : {}),
+                    ...(blocker.stateType ? { blockerCurrentLinearStateType: blocker.stateType } : {}),
+                })),
+            });
+            const delegated = liveIssue.delegateId === installation.actorId;
+            const unresolvedBlockers = this.db.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
+            const shouldRecoverAwaitingInput = delegated
+                && issue.factoryState === "awaiting_input"
+                && this.db.peekIssueSessionWake(issue.projectId, issue.linearIssueId) === undefined;
+            const updated = this.db.upsertIssue({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                ...(liveIssue.identifier ? { issueKey: liveIssue.identifier } : {}),
+                ...(liveIssue.title ? { title: liveIssue.title } : {}),
+                ...(liveIssue.description ? { description: liveIssue.description } : {}),
+                ...(liveIssue.url ? { url: liveIssue.url } : {}),
+                ...(liveIssue.priority != null ? { priority: liveIssue.priority } : {}),
+                ...(liveIssue.estimate != null ? { estimate: liveIssue.estimate } : {}),
+                ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
+                ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
+                ...(shouldRecoverAwaitingInput ? { factoryState: "delegated" } : {}),
+            });
+            if (!shouldRecoverAwaitingInput) {
+                continue;
+            }
+            if (unresolvedBlockers === 0) {
+                this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+                    projectId: issue.projectId,
+                    linearIssueId: issue.linearIssueId,
+                    eventType: "delegated",
+                    dedupeKey: `delegated:${issue.linearIssueId}`,
+                });
+                if (this.db.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
+                    this.runtime.enqueueIssue(issue.projectId, issue.linearIssueId);
+                }
+                this.logger.info({ issueKey: updated.issueKey }, "Recovered delegated issue from stale awaiting_input state and re-queued implementation");
+            }
+            else {
+                this.logger.info({ issueKey: updated.issueKey, unresolvedBlockers }, "Recovered delegated blocked issue from stale awaiting_input state");
+            }
+        }
+    }
     async createLinearOAuthStart(params) {
         return await this.oauthService.createStart(params);
     }
@@ -264,8 +359,8 @@ export class PatchRelayService {
     listTrackedIssues() {
         const rows = this.db.connection
             .prepare(`SELECT
-          i.project_id, i.linear_issue_id, i.issue_key, i.title,
-          i.current_linear_state, i.factory_state, i.updated_at,
+          s.project_id, s.linear_issue_id, s.issue_key, i.title,
+          i.current_linear_state, i.factory_state, s.session_state, s.waiting_reason, s.summary_text, s.updated_at,
           i.pending_run_type,
           i.pr_number, i.pr_review_state, i.pr_check_status,
           i.last_github_ci_snapshot_json,
@@ -278,14 +373,21 @@ export class PatchRelayService {
           latest_run.status AS latest_run_status,
           latest_run.summary_json AS latest_run_summary_json,
           latest_run.report_json AS latest_run_report_json,
+          (
+            SELECT COUNT(*)
+            FROM issue_session_events e
+            WHERE e.project_id = s.project_id
+              AND e.linear_issue_id = s.linear_issue_id
+              AND e.processed_at IS NULL
+          ) AS pending_session_event_count,
           (
             SELECT COUNT(*)
             FROM issue_dependencies d
             LEFT JOIN issues blockers
               ON blockers.project_id = d.project_id
              AND blockers.linear_issue_id = d.blocker_linear_issue_id
-            WHERE d.project_id = i.project_id
-              AND d.linear_issue_id = i.linear_issue_id
+            WHERE d.project_id = s.project_id
+              AND d.linear_issue_id = s.linear_issue_id
               AND (
                 COALESCE(blockers.current_linear_state_type, d.blocker_current_linear_state_type, '') != 'completed'
                 AND LOWER(TRIM(COALESCE(blockers.current_linear_state, d.blocker_current_linear_state, ''))) != 'done'
@@ -297,45 +399,99 @@ export class PatchRelayService {
             LEFT JOIN issues blockers
               ON blockers.project_id = d.project_id
              AND blockers.linear_issue_id = d.blocker_linear_issue_id
-            WHERE d.project_id = i.project_id
-              AND d.linear_issue_id = i.linear_issue_id
+            WHERE d.project_id = s.project_id
+              AND d.linear_issue_id = s.linear_issue_id
               AND (
                 COALESCE(blockers.current_linear_state_type, d.blocker_current_linear_state_type, '') != 'completed'
                 AND LOWER(TRIM(COALESCE(blockers.current_linear_state, d.blocker_current_linear_state, ''))) != 'done'
               )
           ) AS blocked_by_keys_json
-        FROM issues i
-        LEFT JOIN runs active_run ON active_run.id = i.active_run_id
+        FROM issue_sessions s
+        LEFT JOIN issues i
+          ON i.project_id = s.project_id
+         AND i.linear_issue_id = s.linear_issue_id
+        LEFT JOIN runs active_run ON active_run.id = COALESCE(s.active_run_id, i.active_run_id)
         LEFT JOIN runs latest_run ON latest_run.id = (
           SELECT r.id FROM runs r
-          WHERE r.project_id = i.project_id AND r.linear_issue_id = i.linear_issue_id
+          WHERE r.project_id = s.project_id AND r.linear_issue_id = s.linear_issue_id
           ORDER BY r.id DESC LIMIT 1
         )
-        ORDER BY i.updated_at DESC, i.issue_key ASC`)
+        ORDER BY s.updated_at DESC, s.issue_key ASC`)
             .all();
         return rows.map((row) => {
             const failureContext = parseGitHubFailureContext(typeof row.last_github_failure_context_json === "string" ? row.last_github_failure_context_json : undefined);
             const prChecksSummary = parseCiSnapshotSummary(typeof row.last_github_ci_snapshot_json === "string" ? row.last_github_ci_snapshot_json : undefined);
-            const statusNote = extractStatusNote(typeof row.latest_run_summary_json === "string" ? row.latest_run_summary_json : undefined, typeof row.latest_run_report_json === "string" ? row.latest_run_report_json : undefined);
             const blockedByKeys = parseStringArray(typeof row.blocked_by_keys_json === "string" ? row.blocked_by_keys_json : undefined);
             const blockedByCount = Number(row.blocked_by_count ?? 0);
-            const readyForExecution = row.pending_run_type !== null && row.pending_run_type !== undefined && row.active_run_type === null && blockedByCount === 0;
+            const hasPendingSessionEvents = Number(row.pending_session_event_count ?? 0) > 0;
+            const hasPendingWake = hasPendingSessionEvents
+                || this.db.peekIssueSessionWake(String(row.project_id), String(row.linear_issue_id)) !== undefined;
+            const readyForExecution = isIssueSessionReadyForExecution({
+                ...(typeof row.session_state === "string" ? { sessionState: String(row.session_state) } : {}),
+                factoryState: String(row.factory_state ?? "delegated"),
+                ...(row.active_run_type !== null ? { activeRunId: 1 } : {}),
+                blockedByCount,
+                hasPendingWake,
+                hasLegacyPendingRun: row.pending_run_type !== null && row.pending_run_type !== undefined,
+                ...(row.pr_number !== null ? { prNumber: Number(row.pr_number) } : {}),
+                ...(row.pr_state !== null ? { prState: String(row.pr_state) } : {}),
+                ...(row.pr_review_state !== null ? { prReviewState: String(row.pr_review_state) } : {}),
+                ...(row.pr_check_status !== null ? { prCheckStatus: String(row.pr_check_status) } : {}),
+                ...(row.last_github_failure_source !== null ? { latestFailureSource: String(row.last_github_failure_source) } : {}),
+            });
             const failureSummary = summarizeGitHubFailureContext(failureContext);
-            const derivedStatusNote = blockedByCount > 0
-                ? `Blocked by ${blockedByKeys.join(", ")}`
-                : failureSummary && (row.factory_state === "repairing_ci"
-                    || row.factory_state === "repairing_queue"
-                    || row.factory_state === "failed")
-                    ? failureSummary
-                    : statusNote;
-            const statusNoteWithBlockers = blockedByCount > 0
-                ? `Blocked by ${blockedByKeys.join(", ")}`
-                : derivedStatusNote;
+            const sessionWaitingReason = typeof row.waiting_reason === "string" && row.waiting_reason.trim().length > 0
+                ? row.waiting_reason
+                : undefined;
+            const sessionSummary = typeof row.summary_text === "string" && row.summary_text.trim().length > 0
+                ? row.summary_text
+                : undefined;
+            const waitingReason = sessionWaitingReason ?? derivePatchRelayWaitingReason({
+                ...(row.active_run_type !== null ? { activeRunType: String(row.active_run_type) } : {}),
+                blockedByKeys,
+                factoryState: String(row.factory_state ?? "delegated"),
+                ...(row.pending_run_type !== null ? { pendingRunType: String(row.pending_run_type) } : {}),
+                ...(row.pr_number !== null ? { prNumber: Number(row.pr_number) } : {}),
+                ...(row.pr_review_state !== null ? { prReviewState: String(row.pr_review_state) } : {}),
+                ...(row.pr_check_status !== null ? { prCheckStatus: String(row.pr_check_status) } : {}),
+                ...(row.last_github_failure_check_name !== null ? { latestFailureCheckName: String(row.last_github_failure_check_name) } : {}),
+            });
+            const latestRun = row.latest_run_type !== null && row.latest_run_status !== null
+                ? {
+                    id: 0,
+                    issueId: 0,
+                    projectId: String(row.project_id),
+                    linearIssueId: String(row.linear_issue_id),
+                    runType: String(row.latest_run_type),
+                    status: String(row.latest_run_status),
+                    ...(typeof row.latest_run_summary_json === "string" ? { summaryJson: row.latest_run_summary_json } : {}),
+                    ...(typeof row.latest_run_report_json === "string" ? { reportJson: row.latest_run_report_json } : {}),
+                    startedAt: String(row.updated_at),
+                }
+                : undefined;
+            const latestEvent = this.db.listIssueSessionEvents(String(row.project_id), String(row.linear_issue_id), { limit: 1 }).at(-1);
+            const statusNoteCandidate = deriveIssueStatusNote({
+                issue: { factoryState: String(row.factory_state ?? "delegated") },
+                sessionSummary,
+                latestRun: latestRun,
+                latestEvent,
+                failureSummary,
+                blockedByKeys,
+                waitingReason,
+            }) ?? waitingReason;
+            const statusNoteForReturn = shouldSuppressStatusNote({
+                activeRunType: row.active_run_type,
+                sessionState: row.session_state,
+                statusNote: statusNoteCandidate,
+            })
+                ? undefined
+                : statusNoteCandidate;
             return {
                 ...(row.issue_key !== null ? { issueKey: String(row.issue_key) } : {}),
                 ...(row.title !== null ? { title: String(row.title) } : {}),
-                ...(statusNoteWithBlockers ? { statusNote: statusNoteWithBlockers } : {}),
+                ...(statusNoteForReturn ? { statusNote: statusNoteForReturn } : {}),
                 projectId: String(row.project_id),
+                ...(row.session_state !== null ? { sessionState: String(row.session_state) } : {}),
                 factoryState: String(row.factory_state ?? "delegated"),
                 blockedByCount,
                 blockedByKeys,
@@ -354,45 +510,11 @@ export class PatchRelayService {
                 ...(row.last_github_failure_check_name !== null ? { latestFailureCheckName: String(row.last_github_failure_check_name) } : {}),
                 ...(failureContext?.stepName ? { latestFailureStepName: failureContext.stepName } : {}),
                 ...(failureContext?.summary ? { latestFailureSummary: failureContext.summary } : {}),
+                ...(waitingReason ? { waitingReason } : {}),
                 updatedAt: String(row.updated_at),
             };
         });
     }
-    subscribeCodexNotifications(listener) {
-        let trackedThreadId;
-        const handler = (notification) => {
-            let threadId = typeof notification.params.threadId === "string"
-                ? notification.params.threadId
-                : typeof notification.params.thread === "object" && notification.params.thread !== null && "id" in notification.params.thread
-                    ? String(notification.params.thread.id)
-                    : undefined;
-            // Item-level notifications lack threadId — use the tracked one from turn/started
-            if (!threadId)
-                threadId = trackedThreadId;
-            if (notification.method === "turn/started" && threadId)
-                trackedThreadId = threadId;
-            if (notification.method === "turn/completed")
-                trackedThreadId = undefined;
-            let issueKey;
-            let runId;
-            if (threadId) {
-                const run = this.db.getRunByThreadId(threadId);
-                if (run) {
-                    runId = run.id;
-                    const issue = this.db.getIssue(run.projectId, run.linearIssueId);
-                    issueKey = issue?.issueKey ?? undefined;
-                }
-            }
-            listener({
-                method: notification.method,
-                params: notification.params,
-                ...(issueKey ? { issueKey } : {}),
-                ...(runId !== undefined ? { runId } : {}),
-            });
-        };
-        this.codex.on("notification", handler);
-        return () => { this.codex.off("notification", handler); };
-    }
     async promptIssue(issueKey, text, source = "watch") {
         const issue = this.db.getIssueByKey(issueKey);
         if (!issue)
@@ -410,14 +532,13 @@ export class PatchRelayService {
         });
         // If no active run, queue as pending context for the next run
         if (!issue.activeRunId) {
-            const existing = issue.pendingRunContextJson
-                ? JSON.parse(issue.pendingRunContextJson)
-                : {};
-            this.db.upsertIssue({
+            this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
-                pendingRunContextJson: JSON.stringify({ ...existing, operatorPrompt: text }),
+                eventType: "operator_prompt",
+                eventJson: JSON.stringify({ text, source }),
             });
+            this.runtime.enqueueIssue(issue.projectId, issue.linearIssueId);
             return { delivered: false, queued: true };
         }
         const run = this.db.getRun(issue.activeRunId);
@@ -436,14 +557,13 @@ export class PatchRelayService {
             // Turn may have completed between check and steer — queue for next run
             const msg = error instanceof Error ? error.message : String(error);
             this.logger.warn({ issueKey, error: msg }, "steerTurn failed, queuing prompt for next run");
-            const existing = issue.pendingRunContextJson
-                ? JSON.parse(issue.pendingRunContextJson)
-                : {};
-            this.db.upsertIssue({
+            this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
-                pendingRunContextJson: JSON.stringify({ ...existing, operatorPrompt: text }),
+                eventType: "operator_prompt",
+                eventJson: JSON.stringify({ text, source }),
             });
+            this.runtime.enqueueIssue(issue.projectId, issue.linearIssueId);
             return { delivered: false, queued: true };
         }
     }
@@ -466,7 +586,14 @@ export class PatchRelayService {
                 // Turn may already be done
             }
         }
-        this.db.upsertIssue({
+        this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            eventType: "stop_requested",
+            dedupeKey: `operator_stop:${issue.linearIssueId}`,
+        });
+        this.db.clearPendingIssueSessionEventsRespectingActiveLease(issue.projectId, issue.linearIssueId);
+        this.db.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             factoryState: "awaiting_input",
@@ -488,13 +615,21 @@ export class PatchRelayService {
         if (issue.activeRunId)
             return { error: "Issue already has an active run" };
         if (issue.prState === "merged") {
-            this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, factoryState: "done" });
+            this.db.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                factoryState: "done",
+            });
             return { issueKey, runType: "none" };
         }
         // Infer run type from current state instead of always resetting to implementation
         let runType = "implementation";
         let factoryState = "delegated";
-        if (issue.prNumber && (issue.prCheckStatus === "failed" || issue.prCheckStatus === "failure" || issue.lastGitHubFailureSource === "branch_ci")) {
+        if (issue.prNumber && issue.lastGitHubFailureSource === "queue_eviction") {
+            runType = "queue_repair";
+            factoryState = "repairing_queue";
+        }
+        else if (issue.prNumber && (issue.prCheckStatus === "failed" || issue.prCheckStatus === "failure" || issue.lastGitHubFailureSource === "branch_ci")) {
             runType = "ci_repair";
             factoryState = "repairing_ci";
         }
@@ -507,10 +642,10 @@ export class PatchRelayService {
             runType = "implementation";
             factoryState = "implementing";
         }
-        this.db.upsertIssue({
+        this.appendOperatorRetryEvent(issue, runType);
+        this.db.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
-            pendingRunType: runType,
             factoryState: factoryState,
         });
         this.feed.publish({
@@ -522,14 +657,65 @@ export class PatchRelayService {
             status: "retry",
             summary: `Retry queued: ${runType}`,
         });
-        this.runtime.enqueueIssue(issue.projectId, issue.linearIssueId);
+        if (this.db.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
+            this.runtime.enqueueIssue(issue.projectId, issue.linearIssueId);
+        }
         return { issueKey, runType };
     }
-    listOperatorFeed(options) {
-        return this.feed.list(options);
-    }
-    subscribeOperatorFeed(listener) {
-        return this.feed.subscribe(listener);
+    appendOperatorRetryEvent(issue, runType) {
+        if (runType === "queue_repair") {
+            const queueIncident = parseObjectJson(issue.lastQueueIncidentJson);
+            const failureContext = parseObjectJson(issue.lastGitHubFailureContextJson);
+            this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                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"}`,
+            });
+            return;
+        }
+        if (runType === "ci_repair") {
+            const failureContext = parseObjectJson(issue.lastGitHubFailureContextJson);
+            this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                eventType: "settled_red_ci",
+                eventJson: JSON.stringify({
+                    ...(failureContext ?? {}),
+                    source: "operator_retry",
+                }),
+                dedupeKey: `operator_retry:ci_repair:${issue.linearIssueId}:${issue.lastGitHubFailureSignature ?? issue.prHeadSha ?? "unknown-sha"}`,
+            });
+            return;
+        }
+        if (runType === "review_fix") {
+            this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                eventType: "review_changes_requested",
+                eventJson: JSON.stringify({
+                    reviewBody: "Operator requested retry of review-fix work.",
+                    source: "operator_retry",
+                }),
+                dedupeKey: `operator_retry:review_fix:${issue.linearIssueId}:${issue.prHeadSha ?? "unknown-sha"}`,
+            });
+            return;
+        }
+        this.db.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            eventType: "delegated",
+            eventJson: JSON.stringify({
+                promptContext: "Operator requested retry of PatchRelay work.",
+                source: "operator_retry",
+            }),
+            dedupeKey: `operator_retry:implementation:${issue.linearIssueId}`,
+        });
     }
     async acceptWebhook(params) {
         const result = await acceptIncomingWebhook({
@@ -577,15 +763,6 @@ export class PatchRelayService {
     async getIssueOverview(issueKey) {
         return await this.queryService.getIssueOverview(issueKey);
     }
-    async getIssueReport(issueKey) {
-        return await this.queryService.getIssueReport(issueKey);
-    }
-    async getIssueTimeline(issueKey) {
-        return await this.queryService.getIssueTimeline(issueKey);
-    }
-    async getRunEvents(issueKey, runId) {
-        return await this.queryService.getRunEvents(issueKey, runId);
-    }
     async getActiveRunStatus(issueKey) {
         return await this.orchestrator.getActiveRunStatus(issueKey);
     }

package/dist/status-note.js

@@ -0,0 +1,56 @@
+import { extractLatestAssistantSummary } from "./issue-session-events.js";
+function clean(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function eventStatusNote(event) {
+    if (!event)
+        return undefined;
+    switch (event.eventType) {
+        case "stop_requested":
+            return "Operator stopped the run. Use retry or delegate again to resume.";
+        case "undelegated":
+            return "Issue was un-delegated from PatchRelay. Delegate it again to resume.";
+        case "issue_removed":
+            return "Issue was removed from Linear.";
+        case "pr_closed":
+            return "Pull request was closed without merging.";
+        case "pr_merged":
+            return "Pull request merged successfully.";
+        default:
+            return undefined;
+    }
+}
+export function deriveIssueStatusNote(params) {
+    const blockedByKeys = (params.blockedByKeys ?? []).filter((value) => value.trim().length > 0);
+    if (blockedByKeys.length > 0) {
+        return `Blocked by ${blockedByKeys.join(", ")}`;
+    }
+    const sessionSummary = clean(params.sessionSummary);
+    const latestRunNote = clean(extractLatestAssistantSummary(params.latestRun));
+    const latestEventNote = clean(eventStatusNote(params.latestEvent));
+    const failureSummary = clean(params.failureSummary);
+    const waitingReason = clean(params.waitingReason);
+    let note;
+    switch (params.issue.factoryState) {
+        case "awaiting_input":
+            note = latestRunNote ?? latestEventNote ?? sessionSummary;
+            break;
+        case "failed":
+        case "escalated":
+            note = latestRunNote ?? latestEventNote ?? failureSummary ?? sessionSummary;
+            break;
+        case "repairing_ci":
+        case "repairing_queue":
+            note = failureSummary ?? sessionSummary ?? latestRunNote;
+            break;
+        default:
+            note = sessionSummary ?? latestRunNote ?? failureSummary;
+            break;
+    }
+    if (!note)
+        return undefined;
+    if (waitingReason && note === waitingReason)
+        return undefined;
+    return note;
+}