patchrelay 0.36.18 → 0.36.19

package/dist/service.js

@@ -1,87 +1,17 @@
 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 { ServiceIssueActions } from "./service-issue-actions.js";
+import { ServiceStartupRecovery } from "./service-startup-recovery.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;
-    try {
-        const parsed = JSON.parse(value);
-        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
-    }
-    catch {
-        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.startsWith("zombie: never started")
-        || note === "stale thread after restart"
-        || note === "patchrelay received your mention. delegate the issue to patchrelay to start work.";
-}
-export function parseCiSnapshotSummary(snapshotJson) {
-    if (!snapshotJson)
-        return undefined;
-    try {
-        const snapshot = JSON.parse(snapshotJson);
-        const rawChecks = Array.isArray(snapshot.checks) ? snapshot.checks : [];
-        const checks = collapseEffectiveChecks(rawChecks);
-        if (checks.length === 0)
-            return undefined;
-        let passed = 0;
-        let failed = 0;
-        let pending = 0;
-        const failedNames = [];
-        for (const check of checks) {
-            if (check.status === "success")
-                passed++;
-            else if (check.status === "failure") {
-                failed++;
-                failedNames.push(check.name);
-            }
-            else
-                pending++;
-        }
-        return {
-            total: checks.length,
-            completed: passed + failed,
-            passed,
-            failed,
-            pending,
-            overall: snapshot.gateCheckStatus,
-            ...(failedNames.length > 0 ? { failedNames } : {}),
-        };
-    }
-    catch {
-        return undefined;
-    }
-}
-function collapseEffectiveChecks(checks) {
-    const effective = new Map();
-    for (const check of checks) {
-        const name = typeof check?.name === "string" ? check.name.trim() : "";
-        if (!name || effective.has(name))
-            continue;
-        effective.set(name, check);
-    }
-    return [...effective.values()];
-}
+import { parseStringArray, TrackedIssueListQuery } from "./tracked-issue-list-query.js";
 export class PatchRelayService {
     config;
     db;
@@ -96,6 +26,9 @@ export class PatchRelayService {
     queryService;
     runtime;
     feed;
+    issueActions;
+    startupRecovery;
+    trackedIssueListQuery;
     constructor(config, db, codex, linearProvider, logger) {
         this.config = config;
         this.db = db;
@@ -118,6 +51,9 @@ export class PatchRelayService {
         this.oauthService = new LinearOAuthService(config, { linearInstallations: db.linearInstallations }, logger);
         this.queryService = new IssueQueryService(db, codex, this.orchestrator);
         this.runtime = runtime;
+        this.issueActions = new ServiceIssueActions(db, codex, runtime, this.feed, logger);
+        this.startupRecovery = new ServiceStartupRecovery(db, this.linearProvider, this.orchestrator.linearSync, (projectId, issueId) => runtime.enqueueIssue(projectId, issueId), logger);
+        this.trackedIssueListQuery = new TrackedIssueListQuery(db);
         // Optional GitHub App token management for bot identity
         const ghAppCredentials = resolveGitHubAppCredentials();
         if (ghAppCredentials) {
@@ -171,8 +107,8 @@ export class PatchRelayService {
             }
         }
         await this.runtime.start();
-        await this.recoverDelegatedIssueStateFromLinear();
-        void this.syncKnownAgentSessions().catch((error) => {
+        await this.startupRecovery.recoverDelegatedIssueStateFromLinear();
+        void this.startupRecovery.syncKnownAgentSessions().catch((error) => {
             const msg = error instanceof Error ? error.message : String(error);
             this.logger.warn({ error: msg }, "Background agent session sync failed");
         });
@@ -181,96 +117,6 @@ export class PatchRelayService {
         this.githubAppTokenManager?.stop();
         await this.runtime.stop();
     }
-    async syncKnownAgentSessions() {
-        for (const issue of this.db.issues.listIssues()) {
-            if (issue.factoryState === "done") {
-                continue;
-            }
-            const syncedIssue = issue.agentSessionId
-                ? issue
-                : (() => {
-                    const recoveredAgentSessionId = this.db.webhookEvents.findLatestAgentSessionIdForIssue(issue.linearIssueId);
-                    return recoveredAgentSessionId
-                        ? this.db.issues.upsertIssue({
-                            projectId: issue.projectId,
-                            linearIssueId: issue.linearIssueId,
-                            agentSessionId: recoveredAgentSessionId,
-                        })
-                        : issue;
-                })();
-            if (!syncedIssue.agentSessionId) {
-                continue;
-            }
-            const activeRun = syncedIssue.activeRunId ? this.db.runs.getRunById(syncedIssue.activeRunId) : undefined;
-            await this.orchestrator.linearSync.syncSession(syncedIssue, activeRun ? { activeRunType: activeRun.runType } : undefined);
-        }
-    }
-    async recoverDelegatedIssueStateFromLinear() {
-        for (const issue of this.db.issues.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.issues.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.issues.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
-            const shouldRecoverAwaitingInput = delegated
-                && issue.factoryState === "awaiting_input"
-                && this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId) === undefined;
-            const updated = this.db.issues.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.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-                    projectId: issue.projectId,
-                    linearIssueId: issue.linearIssueId,
-                    eventType: "delegated",
-                    dedupeKey: `delegated:${issue.linearIssueId}`,
-                });
-                if (this.db.issueSessions.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);
     }
@@ -359,392 +205,16 @@ export class PatchRelayService {
         return this.runtime.getReadiness();
     }
     listTrackedIssues() {
-        const rows = this.db.connection
-            .prepare(`SELECT
-          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_head_sha, i.pr_review_state, i.pr_check_status, i.last_blocking_review_head_sha,
-          i.last_github_ci_snapshot_json,
-          i.last_github_failure_source,
-          i.last_github_failure_head_sha,
-          i.last_github_failure_check_name,
-          i.last_github_failure_context_json,
-          active_run.run_type AS active_run_type,
-          active_run.completion_check_thread_id AS active_completion_check_thread_id,
-          active_run.completion_check_outcome AS active_completion_check_outcome,
-          latest_run.run_type AS latest_run_type,
-          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,
-          latest_run.completion_check_thread_id AS latest_run_completion_check_thread_id,
-          latest_run.completion_check_outcome AS latest_run_completion_check_outcome,
-          latest_run.completion_check_summary AS latest_run_completion_check_summary,
-          latest_run.completion_check_question AS latest_run_completion_check_question,
-          latest_run.completion_check_why AS latest_run_completion_check_why,
-          latest_run.completion_check_recommended_reply AS latest_run_completion_check_recommended_reply,
-          (
-            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 = 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_count,
-          (
-            SELECT json_group_array(COALESCE(blockers.issue_key, d.blocker_issue_key, d.blocker_linear_issue_id))
-            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 = 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 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 = s.project_id AND r.linear_issue_id = s.linear_issue_id
-          ORDER BY r.id DESC LIMIT 1
-        )
-        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 blockedByKeys = parseStringArray(typeof row.blocked_by_keys_json === "string" ? row.blocked_by_keys_json : undefined);
-            const blockedByCount = Number(row.blocked_by_count ?? 0);
-            const hasPendingSessionEvents = Number(row.pending_session_event_count ?? 0) > 0;
-            const hasPendingWake = hasPendingSessionEvents
-                || this.db.issueSessions.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 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_head_sha !== null ? { prHeadSha: String(row.pr_head_sha) } : {}),
-                ...(row.pr_review_state !== null ? { prReviewState: String(row.pr_review_state) } : {}),
-                ...(row.pr_check_status !== null ? { prCheckStatus: String(row.pr_check_status) } : {}),
-                ...(row.last_blocking_review_head_sha !== null ? { lastBlockingReviewHeadSha: String(row.last_blocking_review_head_sha) } : {}),
-                ...(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 } : {}),
-                    ...(typeof row.latest_run_completion_check_thread_id === "string" ? { completionCheckThreadId: row.latest_run_completion_check_thread_id } : {}),
-                    ...(typeof row.latest_run_completion_check_outcome === "string" ? { completionCheckOutcome: row.latest_run_completion_check_outcome } : {}),
-                    ...(typeof row.latest_run_completion_check_summary === "string" ? { completionCheckSummary: row.latest_run_completion_check_summary } : {}),
-                    ...(typeof row.latest_run_completion_check_question === "string" ? { completionCheckQuestion: row.latest_run_completion_check_question } : {}),
-                    ...(typeof row.latest_run_completion_check_why === "string" ? { completionCheckWhy: row.latest_run_completion_check_why } : {}),
-                    ...(typeof row.latest_run_completion_check_recommended_reply === "string" ? { completionCheckRecommendedReply: row.latest_run_completion_check_recommended_reply } : {}),
-                    startedAt: String(row.updated_at),
-                }
-                : undefined;
-            const latestEvent = this.db.issueSessions.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;
-            const completionCheckActive = typeof row.active_completion_check_thread_id === "string"
-                && row.active_completion_check_thread_id.length > 0
-                && row.active_completion_check_outcome === null
-                && row.active_run_type !== null;
-            return {
-                ...(row.issue_key !== null ? { issueKey: String(row.issue_key) } : {}),
-                ...(row.title !== null ? { title: String(row.title) } : {}),
-                ...(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,
-                readyForExecution,
-                ...(row.current_linear_state !== null ? { currentLinearState: String(row.current_linear_state) } : {}),
-                ...(row.active_run_type !== null ? { activeRunType: String(row.active_run_type) } : {}),
-                ...(row.pending_run_type !== null ? { pendingRunType: String(row.pending_run_type) } : {}),
-                ...(row.latest_run_type !== null ? { latestRunType: String(row.latest_run_type) } : {}),
-                ...(row.latest_run_status !== null ? { latestRunStatus: String(row.latest_run_status) } : {}),
-                ...(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) } : {}),
-                ...(prChecksSummary ? { prChecksSummary } : {}),
-                ...(row.last_github_failure_source !== null ? { latestFailureSource: String(row.last_github_failure_source) } : {}),
-                ...(row.last_github_failure_head_sha !== null ? { latestFailureHeadSha: String(row.last_github_failure_head_sha) } : {}),
-                ...(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 } : {}),
-                ...(completionCheckActive ? { completionCheckActive } : {}),
-                updatedAt: String(row.updated_at),
-            };
-        });
+        return this.trackedIssueListQuery.listTrackedIssues();
     }
     async promptIssue(issueKey, text, source = "watch") {
-        const issue = this.db.issues.getIssueByKey(issueKey);
-        if (!issue)
-            return undefined;
-        // Publish to operator feed so all clients see the prompt
-        this.feed.publish({
-            level: "info",
-            kind: "comment",
-            issueKey: issue.issueKey,
-            projectId: issue.projectId,
-            stage: issue.factoryState,
-            status: "operator_prompt",
-            summary: `Operator prompt (${source})`,
-            detail: text.slice(0, 200),
-        });
-        // If no active run, queue as pending context for the next run
-        if (!issue.activeRunId) {
-            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                eventType: "operator_prompt",
-                eventJson: JSON.stringify({ text, source }),
-            });
-            this.runtime.enqueueIssue(issue.projectId, issue.linearIssueId);
-            return { delivered: false, queued: true };
-        }
-        const run = this.db.runs.getRunById(issue.activeRunId);
-        if (!run?.threadId || !run.turnId) {
-            return { error: "Active run has no thread or turn yet" };
-        }
-        try {
-            await this.codex.steerTurn({
-                threadId: run.threadId,
-                turnId: run.turnId,
-                input: `Operator prompt (${source}):\n\n${text}`,
-            });
-            return { delivered: true };
-        }
-        catch (error) {
-            // 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");
-            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                eventType: "operator_prompt",
-                eventJson: JSON.stringify({ text, source }),
-            });
-            this.runtime.enqueueIssue(issue.projectId, issue.linearIssueId);
-            return { delivered: false, queued: true };
-        }
+        return await this.issueActions.promptIssue(issueKey, text, source);
     }
     async stopIssue(issueKey) {
-        const issue = this.db.issues.getIssueByKey(issueKey);
-        if (!issue)
-            return undefined;
-        if (!issue.activeRunId)
-            return { error: "No active run to stop" };
-        const run = this.db.runs.getRunById(issue.activeRunId);
-        if (run?.threadId && run.turnId) {
-            try {
-                await this.codex.steerTurn({
-                    threadId: run.threadId,
-                    turnId: run.turnId,
-                    input: "STOP: The operator has requested this run to halt immediately. Finish your current action, commit any partial progress, and stop.",
-                });
-            }
-            catch {
-                // Turn may already be done
-            }
-        }
-        this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            eventType: "stop_requested",
-            dedupeKey: `operator_stop:${issue.linearIssueId}`,
-        });
-        this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(issue.projectId, issue.linearIssueId);
-        this.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            factoryState: "awaiting_input",
-        });
-        this.feed.publish({
-            level: "warn",
-            kind: "workflow",
-            issueKey: issue.issueKey,
-            projectId: issue.projectId,
-            status: "stopped",
-            summary: "Operator stopped the run",
-        });
-        return { stopped: true };
+        return await this.issueActions.stopIssue(issueKey);
     }
     retryIssue(issueKey) {
-        const issue = this.db.issues.getIssueByKey(issueKey);
-        if (!issue)
-            return undefined;
-        if (issue.activeRunId)
-            return { error: "Issue already has an active run" };
-        const issueSession = this.db.issueSessions.getIssueSession(issue.projectId, issue.linearIssueId);
-        if (issue.prState === "merged") {
-            this.db.issueSessions.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.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";
-        }
-        else if (issue.prNumber && issue.prReviewState === "changes_requested") {
-            runType = issue.pendingRunType === "branch_upkeep" || issueSession?.lastRunType === "branch_upkeep"
-                ? "branch_upkeep"
-                : "review_fix";
-            factoryState = "changes_requested";
-        }
-        else if (issue.prNumber) {
-            // PR exists but no specific failure — re-run implementation
-            runType = "implementation";
-            factoryState = "implementing";
-        }
-        this.appendOperatorRetryEvent(issue, runType);
-        this.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            factoryState: factoryState,
-        });
-        this.feed.publish({
-            level: "info",
-            kind: "stage",
-            issueKey: issue.issueKey,
-            projectId: issue.projectId,
-            stage: factoryState,
-            status: "retry",
-            summary: `Retry queued: ${runType}`,
-        });
-        if (this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
-            this.runtime.enqueueIssue(issue.projectId, issue.linearIssueId);
-        }
-        return { issueKey, runType };
-    }
-    appendOperatorRetryEvent(issue, runType) {
-        if (runType === "queue_repair") {
-            const queueIncident = parseObjectJson(issue.lastQueueIncidentJson);
-            const failureContext = parseObjectJson(issue.lastGitHubFailureContextJson);
-            this.db.issueSessions.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.issueSessions.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" || runType === "branch_upkeep") {
-            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                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;
-        }
-        this.db.issueSessions.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}`,
-        });
+        return this.issueActions.retryIssue(issueKey);
     }
     async acceptWebhook(params) {
         const result = await acceptIncomingWebhook({
@@ -838,17 +308,6 @@ function toLinearClientProvider(linear) {
         },
     };
 }
-function parseStringArray(value) {
-    if (!value)
-        return [];
-    try {
-        const parsed = JSON.parse(value);
-        return Array.isArray(parsed) ? parsed.filter((entry) => typeof entry === "string") : [];
-    }
-    catch {
-        return [];
-    }
-}
 function workspaceMatches(workspace, installation) {
     const normalized = workspace.trim().toLowerCase();
     return [