patchrelay 0.38.1 → 0.38.2

package/dist/linear-activity-key.js

@@ -0,0 +1,11 @@
+import { sanitizeOperatorFacingText } from "./presentation-text.js";
+export function computeLinearActivityKey(content) {
+    if (content.type === "action") {
+        const action = sanitizeOperatorFacingText(content.action) ?? content.action;
+        const parameter = sanitizeOperatorFacingText(content.parameter) ?? content.parameter;
+        const result = sanitizeOperatorFacingText(content.result);
+        return `action:${action}:${parameter}:${result ?? ""}`;
+    }
+    const body = sanitizeOperatorFacingText(content.body) ?? content.body;
+    return `${content.type}:${body}`;
+}

package/dist/linear-agent-session-client.js

@@ -1,5 +1,6 @@
 import { buildAgentSessionPlanForIssue } from "./agent-session-plan.js";
 import { buildAgentSessionExternalUrls } from "./agent-session-presentation.js";
+import { computeLinearActivityKey } from "./linear-activity-key.js";
 export class LinearAgentSessionClient {
     config;
     db;
@@ -36,11 +37,23 @@ export class LinearAgentSessionClient {
             if (!linear)
                 return;
             const allowEphemeral = content.type === "thought" || content.type === "action";
+            const ephemeral = options?.ephemeral && allowEphemeral;
+            const activityKey = ephemeral ? undefined : computeLinearActivityKey(content);
+            if (activityKey && syncedIssue.lastLinearActivityKey === activityKey) {
+                return;
+            }
             await linear.createAgentActivity({
                 agentSessionId: syncedIssue.agentSessionId,
                 content,
-                ...(options?.ephemeral && allowEphemeral ? { ephemeral: true } : {}),
+                ...(ephemeral ? { ephemeral: true } : {}),
             });
+            if (activityKey) {
+                this.db.issues.upsertIssue({
+                    projectId: syncedIssue.projectId,
+                    linearIssueId: syncedIssue.linearIssueId,
+                    lastLinearActivityKey: activityKey,
+                });
+            }
         }
         catch (error) {
             const msg = error instanceof Error ? error.message : String(error);

package/dist/linear-progress-reporter.js

@@ -1,185 +1,11 @@
-import { sanitizeOperatorFacingCommand, sanitizeOperatorFacingText } from "./presentation-text.js";
-const PROGRESS_THROTTLE_MS = 5_000;
-const MAX_PROGRESS_TEXT_LENGTH = 220;
 export class LinearProgressReporter {
-    db;
-    emitActivity;
-    progressThrottle = new Map();
-    workingOnPublishedRuns = new Set();
-    agentMessageBuffers = new Map();
-    agentMessageProgressPublished = new Set();
-    constructor(db, emitActivity) {
-        this.db = db;
-        this.emitActivity = emitActivity;
+    constructor(_db, _emitActivity) { }
+    maybeEmitProgress(_notification, _run) {
+        // Keep routine Codex progress in local/operator surfaces rather than
+        // turning every planning or reasoning update into Linear thread chatter.
+        return;
     }
-    maybeEmitProgress(notification, run) {
-        const issue = this.db.issues.getIssue(run.projectId, run.linearIssueId);
-        if (!issue)
-            return;
-        const agentSentence = this.consumeAgentMessageSentence(notification, run);
-        const workingOn = resolveWorkingOnActivity(notification, agentSentence?.sentence);
-        if (workingOn && !this.workingOnPublishedRuns.has(run.id)) {
-            this.workingOnPublishedRuns.add(run.id);
-            void this.emitActivity(issue, workingOn);
-        }
-        const progress = resolveEphemeralProgressActivity(notification, agentSentence?.sentence);
-        if (!progress)
-            return;
-        if (!progress.bypassThrottle) {
-            const now = Date.now();
-            const lastEmit = this.progressThrottle.get(run.id) ?? 0;
-            if (now - lastEmit < PROGRESS_THROTTLE_MS)
-                return;
-            this.progressThrottle.set(run.id, now);
-        }
-        void this.emitActivity(issue, progress.activity, { ephemeral: true });
+    clearProgress(_runId) {
+        return;
     }
-    clearProgress(runId) {
-        this.progressThrottle.delete(runId);
-        this.workingOnPublishedRuns.delete(runId);
-        for (const key of this.agentMessageBuffers.keys()) {
-            if (key.startsWith(`${runId}:`)) {
-                this.agentMessageBuffers.delete(key);
-            }
-        }
-        for (const key of this.agentMessageProgressPublished) {
-            if (key.startsWith(`${runId}:`)) {
-                this.agentMessageProgressPublished.delete(key);
-            }
-        }
-    }
-    consumeAgentMessageSentence(notification, run) {
-        const messageKey = resolveAgentMessageKey(notification, run);
-        if (!messageKey)
-            return undefined;
-        if (this.agentMessageProgressPublished.has(messageKey))
-            return undefined;
-        const delta = resolveAgentMessageDelta(notification);
-        if (delta) {
-            const previous = this.agentMessageBuffers.get(messageKey) ?? "";
-            const next = `${previous}${delta}`;
-            this.agentMessageBuffers.set(messageKey, next);
-            const sentence = extractFirstCompletedSentence(next);
-            if (!sentence)
-                return undefined;
-            this.agentMessageProgressPublished.add(messageKey);
-            return { sentence };
-        }
-        const completedText = resolveCompletedAgentMessageText(notification);
-        if (!completedText)
-            return undefined;
-        const sentence = extractFirstSentence(completedText);
-        if (!sentence)
-            return undefined;
-        this.agentMessageProgressPublished.add(messageKey);
-        return { sentence };
-    }
-}
-function resolveWorkingOnActivity(notification, agentSentence) {
-    const summary = resolveWorkingOnSummary(notification) ?? agentSentence;
-    if (!summary)
-        return undefined;
-    return { type: "response", body: `Working on: ${summary}` };
-}
-function resolveEphemeralProgressActivity(notification, agentSentence) {
-    if (notification.method === "item/started") {
-        const item = notification.params.item;
-        if (!item)
-            return undefined;
-        const type = typeof item.type === "string" ? item.type : undefined;
-        if (type === "commandExecution") {
-            const cmd = item.command;
-            const cmdStr = Array.isArray(cmd)
-                ? sanitizeOperatorFacingCommand(cmd.map((part) => String(part)).join(" "))
-                : sanitizeOperatorFacingCommand(typeof cmd === "string" ? cmd : undefined);
-            return { activity: { type: "action", action: "Running", parameter: truncateProgressText(cmdStr ?? "command", 120) } };
-        }
-        if (type === "mcpToolCall") {
-            const server = typeof item.server === "string" ? item.server : "";
-            const tool = typeof item.tool === "string" ? item.tool : "";
-            return { activity: { type: "action", action: "Using", parameter: `${server}/${tool}` } };
-        }
-        if (type === "dynamicToolCall") {
-            const tool = typeof item.tool === "string" ? item.tool : "tool";
-            return { activity: { type: "action", action: "Using", parameter: tool } };
-        }
-    }
-    if (agentSentence) {
-        return {
-            activity: { type: "thought", body: agentSentence },
-            bypassThrottle: true,
-        };
-    }
-    return undefined;
-}
-function resolveWorkingOnSummary(notification) {
-    if (notification.method !== "turn/plan/updated") {
-        return undefined;
-    }
-    const plan = notification.params.plan;
-    if (!Array.isArray(plan))
-        return undefined;
-    const ranked = plan
-        .map((entry) => entry)
-        .filter((entry) => typeof entry.step === "string" && entry.step.trim().length > 0)
-        .sort((a, b) => rankPlanStatus(a.status) - rankPlanStatus(b.status));
-    const first = ranked[0];
-    return summarizeProgressSentence(typeof first?.step === "string" ? first.step : undefined);
-}
-function rankPlanStatus(status) {
-    return status === "inProgress" ? 0
-        : status === "pending" ? 1
-            : status === "completed" ? 2
-                : 3;
-}
-function resolveAgentMessageKey(notification, run) {
-    if (notification.method === "item/agentMessage/delta") {
-        const itemId = typeof notification.params.itemId === "string" ? notification.params.itemId : undefined;
-        return itemId ? `${run.id}:${itemId}` : undefined;
-    }
-    if (notification.method === "item/completed") {
-        const item = notification.params.item;
-        const itemId = typeof item?.id === "string" ? item.id : undefined;
-        const itemType = typeof item?.type === "string" ? item.type : undefined;
-        return itemId && itemType === "agentMessage" ? `${run.id}:${itemId}` : undefined;
-    }
-    return undefined;
-}
-function resolveAgentMessageDelta(notification) {
-    if (notification.method !== "item/agentMessage/delta") {
-        return undefined;
-    }
-    return typeof notification.params.delta === "string" ? notification.params.delta : undefined;
-}
-function resolveCompletedAgentMessageText(notification) {
-    if (notification.method !== "item/completed") {
-        return undefined;
-    }
-    const item = notification.params.item;
-    if (!item || item.type !== "agentMessage")
-        return undefined;
-    return typeof item.text === "string" ? item.text : undefined;
-}
-function extractFirstSentence(text) {
-    const sanitized = sanitizeOperatorFacingText(text)?.replace(/\s+/g, " ").trim();
-    if (!sanitized)
-        return undefined;
-    const match = sanitized.match(/^(.+?[.!?])(?:\s|$)/);
-    return truncateProgressText((match?.[1] ?? sanitized).trim(), MAX_PROGRESS_TEXT_LENGTH);
-}
-function extractFirstCompletedSentence(text) {
-    const sanitized = sanitizeOperatorFacingText(text)?.replace(/\s+/g, " ").trim();
-    if (!sanitized)
-        return undefined;
-    const match = sanitized.match(/^(.+?[.!?])(?:\s|$)/);
-    return match?.[1] ? truncateProgressText(match[1].trim(), MAX_PROGRESS_TEXT_LENGTH) : undefined;
-}
-function summarizeProgressSentence(text) {
-    const summary = extractFirstSentence(text);
-    if (!summary)
-        return undefined;
-    return summary.endsWith(".") || summary.endsWith("!") || summary.endsWith("?") ? summary : `${summary}.`;
-}
-function truncateProgressText(text, maxLength) {
-    return text.length <= maxLength ? text : `${text.slice(0, maxLength - 3).trimEnd()}...`;
 }

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

@@ -1,8 +1,7 @@
 import { extractCompletionCheck } from "./completion-check.js";
+import { isClosedPrState } from "./pr-state.js";
 import { deriveIssueStatusNote } from "./status-note.js";
 import { derivePatchRelayWaitingReason } from "./waiting-reason.js";
-import { isClosedPrState } from "./pr-state.js";
-import { isUndelegatedPausedIssue } from "./paused-issue-state.js";
 export async function syncVisibleStatusComment(params) {
     const { db, issue, linear, logger, trackedIssue, options } = params;
     try {
@@ -25,23 +24,8 @@ export async function syncVisibleStatusComment(params) {
         logger.warn({ issueKey: issue.issueKey, error: msg }, "Failed to sync Linear status comment");
     }
 }
-export function shouldSyncVisibleIssueComment(issue, hasAgentSession) {
-    if (!hasAgentSession) {
-        return true;
-    }
-    if (issue.sessionState === "waiting_input" || issue.sessionState === "failed"
-        || issue.factoryState === "awaiting_input" || issue.factoryState === "failed" || issue.factoryState === "escalated") {
-        return true;
-    }
-    if (isUndelegatedPausedIssue(issue)) {
-        return true;
-    }
-    if ((issue.sessionState === "done" || issue.factoryState === "done")
-        && ((issue.prNumber === undefined && !issue.prUrl)
-            || isClosedPrState(issue.prState))) {
-        return true;
-    }
-    return false;
+export function shouldSyncVisibleIssueComment(_issue, _hasAgentSession) {
+    return true;
 }
 function renderStatusComment(db, issue, trackedIssue, options) {
     const activeRun = issue.activeRunId ? db.runs.getRunById(issue.activeRunId) : undefined;

package/dist/manual-issue-actions.js

@@ -0,0 +1,37 @@
+import { hasOpenPr } from "./pr-state.js";
+export function resolveRetryTarget(params) {
+    if (params.prState === "merged") {
+        return { runType: "none", factoryState: "done" };
+    }
+    if (hasOpenPr(params.prNumber, params.prState) && params.lastGitHubFailureSource === "queue_eviction") {
+        return { runType: "queue_repair", factoryState: "repairing_queue" };
+    }
+    if (hasOpenPr(params.prNumber, params.prState)
+        && (params.prCheckStatus === "failed" || params.prCheckStatus === "failure" || params.lastGitHubFailureSource === "branch_ci")) {
+        return { runType: "ci_repair", factoryState: "repairing_ci" };
+    }
+    if (hasOpenPr(params.prNumber, params.prState) && params.prReviewState === "changes_requested") {
+        return {
+            runType: params.pendingRunType === "branch_upkeep" || params.lastRunType === "branch_upkeep"
+                ? "branch_upkeep"
+                : "review_fix",
+            factoryState: "changes_requested",
+        };
+    }
+    if (hasOpenPr(params.prNumber, params.prState)) {
+        return { runType: "implementation", factoryState: "implementing" };
+    }
+    return { runType: "implementation", factoryState: "delegated" };
+}
+export function buildManualRetryAttemptReset(runType) {
+    if (runType === "ci_repair") {
+        return { ciRepairAttempts: 0 };
+    }
+    if (runType === "queue_repair") {
+        return { queueRepairAttempts: 0 };
+    }
+    if (runType === "review_fix" || runType === "branch_upkeep") {
+        return { reviewFixAttempts: 0 };
+    }
+    return {};
+}

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-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,