patchrelay 0.38.1 → 0.39.0

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

@@ -1,4 +1,7 @@
+import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
 import { resolvePreferredCompletedLinearState } from "./linear-workflow.js";
+import { isCompletedLinearState } from "./pr-state.js";
+import { hasTrustedNoPrCompletion } from "./trusted-no-pr-completion.js";
 export class MergedLinearCompletionReconciler {
     db;
     linearProvider;
@@ -10,39 +13,116 @@ export class MergedLinearCompletionReconciler {
     }
     async reconcile() {
         for (const issue of this.db.issues.listIssues()) {
-            if (issue.prState !== "merged")
-                continue;
-            if (issue.currentLinearStateType?.trim().toLowerCase() === "completed")
+            if (issue.factoryState !== "done" && issue.prState !== "merged") {
                 continue;
+            }
             const linear = await this.linearProvider.forProject(issue.projectId).catch(() => undefined);
-            if (!linear)
+            if (!linear) {
                 continue;
+            }
             try {
                 const liveIssue = await linear.getIssue(issue.linearIssueId);
-                const targetState = resolvePreferredCompletedLinearState(liveIssue);
-                if (!targetState)
-                    continue;
-                const normalizedCurrent = liveIssue.stateName?.trim().toLowerCase();
-                if (normalizedCurrent === targetState.trim().toLowerCase()) {
-                    this.db.issues.upsertIssue({
-                        projectId: issue.projectId,
-                        linearIssueId: issue.linearIssueId,
-                        ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
-                        ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
-                    });
-                    continue;
-                }
-                const updated = await linear.setIssueState(issue.linearIssueId, targetState);
-                this.db.issues.upsertIssue({
+                this.db.issues.replaceIssueDependencies({
                     projectId: issue.projectId,
                     linearIssueId: issue.linearIssueId,
-                    ...(updated.stateName ? { currentLinearState: updated.stateName } : {}),
-                    ...(updated.stateType ? { currentLinearStateType: updated.stateType } : {}),
+                    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 latestRun = this.db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
+                const trustedNoPrDone = hasTrustedNoPrCompletion(issue, latestRun);
+                if (issue.prState === "merged" || trustedNoPrDone) {
+                    await this.reconcileCompletedLinearState(issue, liveIssue, linear);
+                    continue;
+                }
+                if (issue.factoryState === "done" && !isCompletedLinearState(liveIssue.stateType, liveIssue.stateName)) {
+                    this.reopenStaleLocalDoneIssue(issue, liveIssue);
+                }
+                else {
+                    this.refreshCachedLinearState(issue, liveIssue);
+                }
             }
             catch (error) {
-                this.logger.warn({ issueKey: issue.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to reconcile merged issue to a completed Linear state");
+                this.logger.warn({ issueKey: issue.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to reconcile merged or stale completed issue state");
             }
         }
     }
+    async reconcileCompletedLinearState(issue, liveIssue, linear) {
+        if (isCompletedLinearState(liveIssue.stateType, liveIssue.stateName)) {
+            this.refreshCachedLinearState(issue, liveIssue);
+            return;
+        }
+        const targetState = resolvePreferredCompletedLinearState(liveIssue);
+        if (!targetState) {
+            this.refreshCachedLinearState(issue, liveIssue);
+            return;
+        }
+        const normalizedCurrent = liveIssue.stateName?.trim().toLowerCase();
+        if (normalizedCurrent === targetState.trim().toLowerCase()) {
+            this.refreshCachedLinearState(issue, liveIssue);
+            return;
+        }
+        const updated = await linear.setIssueState(issue.linearIssueId, targetState);
+        this.db.issues.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            ...(updated.stateName ? { currentLinearState: updated.stateName } : {}),
+            ...(updated.stateType ? { currentLinearStateType: updated.stateType } : {}),
+        });
+    }
+    reopenStaleLocalDoneIssue(issue, liveIssue) {
+        const restored = resolveOpenWorkflowState(issue);
+        this.db.issues.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
+            ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
+            ...(restored ? { factoryState: restored.factoryState } : {}),
+            ...(restored ? { pendingRunType: restored.pendingRunType } : {}),
+        });
+        this.logger.info({
+            issueKey: issue.issueKey,
+            previousFactoryState: issue.factoryState,
+            restoredFactoryState: restored?.factoryState,
+            liveLinearState: liveIssue.stateName,
+        }, "Reopened stale local done state from live Linear workflow");
+    }
+    refreshCachedLinearState(issue, liveIssue) {
+        this.db.issues.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
+            ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
+        });
+    }
+}
+function resolveOpenWorkflowState(issue) {
+    const reactiveIntent = deriveIssueSessionReactiveIntent({
+        delegatedToPatchRelay: issue.delegatedToPatchRelay,
+        prNumber: issue.prNumber,
+        prState: issue.prState,
+        prReviewState: issue.prReviewState,
+        prCheckStatus: issue.prCheckStatus,
+        latestFailureSource: issue.lastGitHubFailureSource,
+    });
+    if (reactiveIntent) {
+        return {
+            factoryState: reactiveIntent.compatibilityFactoryState,
+            pendingRunType: reactiveIntent.runType,
+        };
+    }
+    if (issue.prNumber !== undefined && (issue.prState === undefined || issue.prState === "open")) {
+        if (issue.prReviewState === "approved" && (issue.prCheckStatus === "success" || issue.prCheckStatus === "passed")) {
+            return { factoryState: "awaiting_queue", pendingRunType: null };
+        }
+        return { factoryState: "pr_open", pendingRunType: null };
+    }
+    if (issue.delegatedToPatchRelay) {
+        return { factoryState: "delegated", pendingRunType: null };
+    }
+    return undefined;
 }

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

@@ -1,4 +1,11 @@
 import { buildCompletionCheckActivity } from "./linear-session-reporting.js";
+function shouldContinueForUnpublishedLocalChanges(message) {
+    const normalized = message.trim().toLowerCase();
+    if (!normalized)
+        return false;
+    return normalized.includes("worktree still has")
+        || (normalized.includes("local commit") && normalized.includes("ahead of origin/"));
+}
 export async function handleNoPrCompletionCheck(params) {
     const completedRunUpdate = buildCompletedRunUpdate({
         threadId: params.threadId,
@@ -115,6 +122,51 @@ export async function handleNoPrCompletionCheck(params) {
         return;
     }
     if (completionCheck.outcome === "done") {
+        if (shouldContinueForUnpublishedLocalChanges(params.publishedOutcomeError)) {
+            const continued = params.withHeldLease(params.run.projectId, params.run.linearIssueId, (lease) => {
+                params.db.runs.finishRun(params.run.id, completedRunUpdate);
+                params.db.runs.saveCompletionCheck(params.run.id, {
+                    ...completionCheck,
+                    outcome: "continue",
+                    summary: "PatchRelay changed files locally but has not published them yet; continuing automatically to finish publication.",
+                    why: params.publishedOutcomeError,
+                });
+                params.db.issues.upsertIssue({
+                    projectId: params.run.projectId,
+                    linearIssueId: params.run.linearIssueId,
+                    activeRunId: null,
+                    factoryState: "delegated",
+                    pendingRunType: null,
+                    pendingRunContextJson: null,
+                });
+                return Boolean(params.db.issueSessions.appendIssueSessionEventWithLease(lease, {
+                    projectId: params.run.projectId,
+                    linearIssueId: params.run.linearIssueId,
+                    eventType: "completion_check_continue",
+                    eventJson: JSON.stringify({
+                        runType: params.run.runType,
+                        summary: params.publishedOutcomeError,
+                    }),
+                    dedupeKey: `completion_check_continue:${params.run.id}`,
+                }));
+            });
+            if (!continued) {
+                params.logger.warn({ runId: params.run.id, issueId: params.run.linearIssueId }, "Skipping completion-check continue writes after losing issue-session lease");
+                params.clearProgressAndRelease(params.run);
+                return;
+            }
+            params.syncCompletionCheckOutcome({
+                run: params.run,
+                fallbackIssue: params.issue,
+                level: "info",
+                status: "completion_check_continue",
+                summary: "No PR found; continuing automatically to finish publication",
+                detail: params.publishedOutcomeError,
+                activity: buildCompletionCheckActivity("continue"),
+                enqueue: true,
+            });
+            return;
+        }
         const completed = params.withHeldLease(params.run.projectId, params.run.linearIssueId, (lease) => {
             params.db.runs.finishRun(params.run.id, completedRunUpdate);
             params.db.runs.saveCompletionCheck(params.run.id, completionCheck);

package/dist/presentation-text.js

@@ -5,6 +5,16 @@ function unwrapShellWrappedCommand(text) {
         .replace(/^(?:\/bin\/bash|bash|\/bin\/sh|sh)\s+-lc\s+'([^`\n]+)'$/g, "$1")
         .replace(/^(?:\/bin\/bash|bash|\/bin\/sh|sh)\s+-lc\s+"([^`\n]+)"$/g, "$1");
 }
+function stripLocalMarkdownLinks(text) {
+    return text
+        .replace(/\[([^\]]+)\]\(<\/[^)>]+>\)/g, "`$1`")
+        .replace(/\[([^\]]+)\]\((\/[^)\s]+)\)/g, "`$1`");
+}
+function stripLocalAbsolutePaths(text) {
+    return text
+        .replace(/`\/(?:home|Users|private|tmp|var\/folders)\/[^`\n]+`/g, "`local path omitted`")
+        .replace(/(^|[\s(])\/(?:home|Users|private|tmp|var\/folders)\/[^\s)]+/g, "$1`local path omitted`");
+}
 export function sanitizeOperatorFacingCommand(command) {
     const trimmed = command?.trim();
     if (!trimmed) {
@@ -17,5 +27,5 @@ export function sanitizeOperatorFacingText(text) {
     if (!trimmed) {
         return undefined;
     }
-    return unwrapShellWrappedCommand(trimmed);
+    return stripLocalAbsolutePaths(stripLocalMarkdownLinks(unwrapShellWrappedCommand(trimmed)));
 }

package/dist/prompting/patchrelay.js

@@ -184,12 +184,12 @@ function buildRequestedChangesContext(runType, context) {
     const mode = resolveRequestedChangesMode(runType, context);
     const lines = [];
     if (mode === "branch_upkeep") {
-        lines.push("## Branch Upkeep After Requested Changes", "", "The requested review changes may already be addressed, but GitHub still shows the PR branch as behind or dirty against the base branch.", "Update the existing PR branch onto the latest base branch, resolve conflicts carefully, rerun the narrowest relevant verification, and push a newer head.", "Do not open a new PR.", "");
+        lines.push("## Branch Upkeep After Requested Changes", "", "Goal: restore merge readiness on the existing PR branch without regressing review or CI readiness.", "The requested review changes may already be addressed, but GitHub still shows the PR branch as behind or dirty against the base branch.", "Update the existing PR branch onto the latest base branch, resolve conflicts carefully, rerun the narrowest relevant verification, and push a newer head.", "Do not open a new PR.", "", "1. Refresh the latest remote branch and base branch state first.", "2. Rebase or merge onto the latest base branch and resolve conflicts in a way that preserves the branch's current intent and prior fixes.", "3. Audit the conflicted areas for semantic regressions, not just textual conflicts.", "4. Run focused verification for the touched areas and enough surrounding checks to regain confidence that the branch is still review-ready.", "5. Commit and push a newer head on the existing PR branch.", "6. Do not stop at 'conflicts resolved' if the resulting branch is no longer likely to pass review or CI.", "");
     }
     else {
         const reviewer = typeof context?.reviewerName === "string" ? context.reviewerName : undefined;
         const reviewBody = typeof context?.reviewBody === "string" ? context.reviewBody.trim() : "";
-        lines.push("## Review Changes Requested", "", reviewer ? `Reviewer: ${reviewer}` : "", reviewBody ? `Review summary:\n${reviewBody}` : "", "", "1. Start with the structured review context below. Treat the inline review comments as the primary repair checklist for this turn.", "2. Check the current diff (`git diff origin/main`) — a prior rebase may have already resolved some concerns.", "3. For each review point: if already resolved on the current head, note why. If not, fix it.", "4. If the structured review context looks incomplete, inspect the latest GitHub review threads directly before deciding you are done.", "5. Run verification, commit, and push a newer head on the existing PR branch.", "6. Do not try to hand the same head back to review. If you cannot produce a new pushed head, stop and surface the blocker clearly.", "7. GitHub review happens after the new head is pushed and CI is green. Do not use `gh pr edit --add-reviewer` as part of this workflow.", "");
+        lines.push("## Review Changes Requested", "", "Goal: restore review readiness on the existing PR branch, not merely patch the latest cited line.", "Treat the reviewer comments as evidence of what still makes the branch unready. Your job is to return the branch to a state that is likely to pass the next full review.", "", reviewer ? `Reviewer: ${reviewer}` : "", reviewBody ? `Review summary:\n${reviewBody}` : "", "", "1. Start with the structured review context below, then inspect the current diff (`git diff origin/main`) and current code before deciding what still needs work.", "2. Infer the underlying concern or invariant behind the review feedback. Do not assume each comment is an isolated chore.", "3. For each review point: if already resolved on the current head, note why. If not, fix it. Then inspect adjacent code paths and flows that could fail for the same reason.", "4. If the structured review context looks incomplete, inspect the latest GitHub review threads directly before deciding you are done.", "5. Verify the branch as a whole for the relevant concern class: current review issue, nearby regressions, relevant tests, and compatibility with the latest base branch.", "6. Only finish when you believe the branch is review-ready again. If you cannot get it there, stop and surface the blocker clearly.", "7. Commit and push a newer head on the existing PR branch. Do not try to hand the same head back to review.", "8. GitHub review happens after the new head is pushed and CI is green. Do not use `gh pr edit --add-reviewer` as part of this workflow.", "");
         appendStructuredReviewContext(lines, context);
     }
     return lines.join("\n").trim();
@@ -201,7 +201,8 @@ function buildCiRepairContext(context) {
     return [
         "## CI Repair",
         "",
-        "A full CI iteration has settled failed on your PR. Start from the specific failing check/job/step below on the latest remote PR branch tip, fix that concrete failure first, then push to the same PR branch.",
+        "Goal: restore CI readiness on the existing PR branch so the next full CI run is likely to pass.",
+        "A full CI iteration has settled failed on your PR. Start from the specific failing check/job/step below on the latest remote PR branch tip, but do not stop at a narrow patch if the same root cause is likely to fail other checks in the suite.",
         snapshot?.gateCheckName ? `Gate check: ${String(snapshot.gateCheckName)}` : "",
         snapshot?.gateCheckStatus ? `Gate status: ${String(snapshot.gateCheckStatus)}` : "",
         snapshot?.settledAt ? `Settled at: ${String(snapshot.settledAt)}` : "",
@@ -219,10 +220,11 @@ function buildCiRepairContext(context) {
             : "",
         "",
         "Fetch the latest remote branch state first. If the branch moved since this failure, restart from the new tip instead of pushing older work.",
-        "Read the latest logs for the named failing check, fix that root cause, and only broaden scope when the logs show direct fallout from the same issue.",
+        "Read the latest logs for the named failing check, identify the root cause, and check whether that same cause is likely to affect other jobs or checks.",
+        "Fix the root cause, not just the first visible symptom.",
         "Do not change workflows, dependency installation, or unrelated tests unless the failing logs clearly point there.",
-        "Run focused verification for the named failure, then commit and push.",
-        "Do not open a new PR. Keep working on the existing branch until CI goes green or the situation is clearly stuck.",
+        "Run the narrowest local verification that gives real confidence for the suite, then commit and push.",
+        "Do not open a new PR. Keep working on the existing branch until the branch is likely to pass CI again or the situation is clearly stuck.",
         "Do not change test expectations unless the test is genuinely wrong.",
     ].filter(Boolean).join("\n");
 }

package/dist/run-budgets.js

@@ -0,0 +1,12 @@
+export const DEFAULT_CI_REPAIR_BUDGET = 3;
+export const DEFAULT_QUEUE_REPAIR_BUDGET = 3;
+export const DEFAULT_REVIEW_FIX_BUDGET = 3;
+export function getCiRepairBudget(project) {
+    return project?.repairBudgets?.ciRepair ?? DEFAULT_CI_REPAIR_BUDGET;
+}
+export function getQueueRepairBudget(project) {
+    return project?.repairBudgets?.queueRepair ?? DEFAULT_QUEUE_REPAIR_BUDGET;
+}
+export function getReviewFixBudget(project) {
+    return project?.repairBudgets?.reviewFix ?? DEFAULT_REVIEW_FIX_BUDGET;
+}

package/dist/run-launcher.js

@@ -2,7 +2,7 @@ import { buildHookEnv, runProjectHook } from "./hook-runner.js";
 import { buildRunFailureActivity } from "./linear-session-reporting.js";
 import { loadPatchRelayRepoPrompting } from "./patchrelay-customization.js";
 import { buildRunPrompt as buildPatchRelayRunPrompt, findDisallowedPatchRelayPromptSectionIds, findUnknownPatchRelayPromptSectionIds, mergePromptCustomizationLayers, resolvePromptLayers, } from "./prompting/patchrelay.js";
-import { execCommand } from "./utils.js";
+import { configureGitHubBotAuthForWorktree } from "./github-worktree-auth.js";
 function slugify(value) {
     return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
 }
@@ -116,11 +116,11 @@ export class RunLauncher {
         try {
             await this.worktreeManager.ensureIssueWorktree(params.project.repoPath, params.project.worktreeRoot, params.worktreePath, params.branchName, { allowExistingOutsideRoot: params.issue.branchName !== undefined });
             if (params.botIdentity) {
-                const gitBin = this.config.runner.gitBin;
-                await execCommand(gitBin, ["-C", params.worktreePath, "config", "user.name", params.botIdentity.name], { timeoutMs: 5_000 });
-                await execCommand(gitBin, ["-C", params.worktreePath, "config", "user.email", params.botIdentity.email], { timeoutMs: 5_000 });
-                const credentialHelper = `!f() { echo "username=x-access-token"; echo "password=$(cat ${params.botIdentity.tokenFile})"; }; f`;
-                await execCommand(gitBin, ["-C", params.worktreePath, "config", "credential.helper", credentialHelper], { timeoutMs: 5_000 });
+                await configureGitHubBotAuthForWorktree({
+                    gitBin: this.config.runner.gitBin,
+                    worktreePath: params.worktreePath,
+                    botIdentity: params.botIdentity,
+                });
             }
             await this.worktreeManager.resetWorktreeToTrackedBranch(params.worktreePath, params.branchName, params.issue, this.logger);
             if (params.runType !== "queue_repair") {

package/dist/run-notification-handler.js

@@ -41,6 +41,10 @@ export class RunNotificationHandler {
         const run = this.db.runs.getRunByThreadId(threadId);
         if (!run)
             return;
+        if (run.status !== "running") {
+            this.logger.info({ runId: run.id, status: run.status, issueId: run.linearIssueId }, "Ignoring Codex notification for inactive run");
+            return;
+        }
         if (!this.heartbeatIssueSessionLease(run.projectId, run.linearIssueId)) {
             this.logger.warn({ runId: run.id, issueId: run.linearIssueId }, "Ignoring Codex notification after losing issue-session lease");
             return;

package/dist/run-orchestrator.js

@@ -138,6 +138,12 @@ export class RunOrchestrator {
             return;
         }
         const { runType, context, resumeThread } = wake;
+        if (runType === "implementation" && this.db.issues.countUnresolvedBlockers(item.projectId, item.issueId) > 0) {
+            this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(item.projectId, item.issueId);
+            this.releaseIssueSessionLease(item.projectId, item.issueId);
+            this.logger.info({ issueKey: issue.issueKey }, "Skipped implementation launch because the issue is blocked");
+            return;
+        }
         const remainingZombieDelayMs = shouldDelayZombieRecoveryLaunch(issue, issueSession, runType);
         if (remainingZombieDelayMs > 0) {
             this.logger.debug({ issueKey: issue.issueKey, runType, remainingZombieDelayMs }, "Deferring recovered run launch until zombie backoff elapses");
@@ -152,7 +158,7 @@ export class RunOrchestrator {
             : typeof effectiveContext?.headSha === "string"
                 ? effectiveContext.headSha
                 : issue.prHeadSha;
-        const budgetExceeded = this.runWakePlanner.budgetExceeded(issue, runType, isRequestedChangesRunType);
+        const budgetExceeded = this.runWakePlanner.budgetExceeded(issue, project, runType, isRequestedChangesRunType);
         if (budgetExceeded) {
             this.escalate(issue, runType, budgetExceeded);
             return;

package/dist/run-wake-planner.js

@@ -1,6 +1,4 @@
-const DEFAULT_CI_REPAIR_BUDGET = 3;
-const DEFAULT_QUEUE_REPAIR_BUDGET = 3;
-const DEFAULT_REVIEW_FIX_BUDGET = 12;
+import { getCiRepairBudget, getQueueRepairBudget, getReviewFixBudget, } from "./run-budgets.js";
 export class RunWakePlanner {
     db;
     constructor(db) {
@@ -62,15 +60,18 @@ export class RunWakePlanner {
             return issue;
         return this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
     }
-    budgetExceeded(issue, runType, isRequestedChangesRunType) {
-        if (runType === "ci_repair" && issue.ciRepairAttempts >= DEFAULT_CI_REPAIR_BUDGET) {
-            return `CI repair budget exhausted (${DEFAULT_CI_REPAIR_BUDGET} attempts)`;
+    budgetExceeded(issue, project, runType, isRequestedChangesRunType) {
+        const ciRepairBudget = getCiRepairBudget(project);
+        if (runType === "ci_repair" && issue.ciRepairAttempts >= ciRepairBudget) {
+            return `CI repair budget exhausted (${ciRepairBudget} attempts)`;
         }
-        if (runType === "queue_repair" && issue.queueRepairAttempts >= DEFAULT_QUEUE_REPAIR_BUDGET) {
-            return `Queue repair budget exhausted (${DEFAULT_QUEUE_REPAIR_BUDGET} attempts)`;
+        const queueRepairBudget = getQueueRepairBudget(project);
+        if (runType === "queue_repair" && issue.queueRepairAttempts >= queueRepairBudget) {
+            return `Queue repair budget exhausted (${queueRepairBudget} attempts)`;
         }
-        if (isRequestedChangesRunType(runType) && issue.reviewFixAttempts >= DEFAULT_REVIEW_FIX_BUDGET) {
-            return `Requested-changes budget exhausted (${DEFAULT_REVIEW_FIX_BUDGET} attempts)`;
+        const reviewFixBudget = getReviewFixBudget(project);
+        if (isRequestedChangesRunType(runType) && issue.reviewFixAttempts >= reviewFixBudget) {
+            return `Requested-changes budget exhausted (${reviewFixBudget} attempts)`;
         }
         return undefined;
     }

package/dist/service-issue-actions.js

@@ -1,5 +1,5 @@
 import { buildOperatorRetryEvent } from "./operator-retry-event.js";
-import { hasOpenPr } from "./pr-state.js";
+import { buildManualRetryAttemptReset, resolveRetryTarget } from "./manual-issue-actions.js";
 export class ServiceIssueActions {
     db;
     codex;
@@ -103,7 +103,16 @@ export class ServiceIssueActions {
         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") {
+        const retryTarget = resolveRetryTarget({
+            prNumber: issue.prNumber,
+            prState: issue.prState,
+            prReviewState: issue.prReviewState,
+            prCheckStatus: issue.prCheckStatus,
+            pendingRunType: issue.pendingRunType,
+            lastRunType: issueSession?.lastRunType,
+            lastGitHubFailureSource: issue.lastGitHubFailureSource,
+        });
+        if (retryTarget.runType === "none") {
             this.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
@@ -111,45 +120,89 @@ export class ServiceIssueActions {
             });
             return { issueKey, runType: "none" };
         }
-        let runType = "implementation";
-        let factoryState = "delegated";
-        if (hasOpenPr(issue.prNumber, issue.prState) && issue.lastGitHubFailureSource === "queue_eviction") {
-            runType = "queue_repair";
-            factoryState = "repairing_queue";
-        }
-        else if (hasOpenPr(issue.prNumber, issue.prState) && (issue.prCheckStatus === "failed" || issue.prCheckStatus === "failure" || issue.lastGitHubFailureSource === "branch_ci")) {
-            runType = "ci_repair";
-            factoryState = "repairing_ci";
-        }
-        else if (hasOpenPr(issue.prNumber, issue.prState) && issue.prReviewState === "changes_requested") {
-            runType = issue.pendingRunType === "branch_upkeep" || issueSession?.lastRunType === "branch_upkeep"
-                ? "branch_upkeep"
-                : "review_fix";
-            factoryState = "changes_requested";
-        }
-        else if (hasOpenPr(issue.prNumber, issue.prState)) {
-            runType = "implementation";
-            factoryState = "implementing";
-        }
-        this.appendOperatorRetryEvent(issue, runType);
+        this.appendOperatorRetryEvent(issue, retryTarget.runType);
         this.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
-            factoryState: factoryState,
+            factoryState: retryTarget.factoryState,
+            ...buildManualRetryAttemptReset(retryTarget.runType),
         });
         this.feed.publish({
             level: "info",
             kind: "stage",
             issueKey: issue.issueKey,
             projectId: issue.projectId,
-            stage: factoryState,
+            stage: retryTarget.factoryState,
             status: "retry",
-            summary: `Retry queued: ${runType}`,
+            summary: `Retry queued: ${retryTarget.runType}`,
         });
         if (this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
             this.runtime.enqueueIssue(issue.projectId, issue.linearIssueId);
         }
-        return { issueKey, runType };
+        return { issueKey, runType: retryTarget.runType };
+    }
+    async closeIssue(issueKey, options) {
+        const issue = this.db.issues.getIssueByKey(issueKey);
+        if (!issue)
+            return undefined;
+        const terminalState = options?.failed ? "failed" : "done";
+        const run = issue.activeRunId ? this.db.runs.getRunById(issue.activeRunId) : undefined;
+        if (run?.threadId && run.turnId) {
+            try {
+                await this.codex.steerTurn({
+                    threadId: run.threadId,
+                    turnId: run.turnId,
+                    input: `STOP: The operator manually closed this issue in PatchRelay as ${terminalState}. Stop working immediately and exit without making further changes.`,
+                });
+            }
+            catch {
+                // The turn may already be settled.
+            }
+        }
+        this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            eventType: "operator_closed",
+            eventJson: JSON.stringify({
+                terminalState,
+                ...(options?.reason ? { reason: options.reason } : {}),
+            }),
+            dedupeKey: `operator_closed:${issue.linearIssueId}:${terminalState}:${issue.activeRunId ?? "no-run"}`,
+        });
+        this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(issue.projectId, issue.linearIssueId);
+        if (run) {
+            this.db.issueSessions.finishRunRespectingActiveLease(issue.projectId, issue.linearIssueId, run.id, {
+                status: "released",
+                failureReason: options?.reason
+                    ? `Operator closed issue as ${terminalState}: ${options.reason}`
+                    : `Operator closed issue as ${terminalState}`,
+            });
+        }
+        this.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            factoryState: terminalState,
+            activeRunId: null,
+            pendingRunType: null,
+            pendingRunContextJson: null,
+        });
+        this.db.issueSessions.releaseIssueSessionLeaseRespectingActiveLease(issue.projectId, issue.linearIssueId);
+        this.feed.publish({
+            level: terminalState === "failed" ? "warn" : "info",
+            kind: "workflow",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: terminalState,
+            status: "operator_closed",
+            summary: options?.reason
+                ? `Operator closed issue as ${terminalState}: ${options.reason}`
+                : `Operator closed issue as ${terminalState}`,
+        });
+        return {
+            issueKey,
+            factoryState: terminalState,
+            ...(run ? { releasedRunId: run.id } : {}),
+        };
     }
     queueOperatorPrompt(issue, text, source) {
         this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {

package/dist/service.js

@@ -215,6 +215,9 @@ export class PatchRelayService {
     retryIssue(issueKey) {
         return this.issueActions.retryIssue(issueKey);
     }
+    async closeIssue(issueKey, options) {
+        return await this.issueActions.closeIssue(issueKey, options);
+    }
     async acceptWebhook(params) {
         const result = await acceptIncomingWebhook({
             config: this.config,

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

@@ -0,0 +1,7 @@
+export function hasTrustedNoPrCompletion(issue, latestRun) {
+    return issue.factoryState === "done"
+        && issue.prNumber === undefined
+        && !issue.prUrl
+        && latestRun?.status === "completed"
+        && latestRun.completionCheckOutcome === "done";
+}