patchrelay 0.38.1 → 0.39.0

package/dist/idle-reconciliation.js

@@ -4,8 +4,8 @@ import { deriveGateCheckStatusFromRollup } from "./github-rollup.js";
 import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
 import { parseStoredQueueRepairContext } from "./merge-queue-incident.js";
 import { buildClosedPrCleanupFields, resolveClosedPrDisposition } from "./pr-state.js";
+import { getReviewFixBudget } from "./run-budgets.js";
 import { execCommand } from "./utils.js";
-const DEFAULT_REVIEW_FIX_BUDGET = 12;
 function isFailingCheckStatus(status) {
     return status === "failed" || status === "failure";
 }
@@ -510,13 +510,15 @@ export class IdleIssueReconciler {
             if (issue.delegatedToPatchRelay
                 && (issue.factoryState === "escalated" || issue.factoryState === "failed")
                 && (reactiveIntent?.runType === "review_fix" || reactiveIntent?.runType === "branch_upkeep")) {
-                if (issue.reviewFixAttempts >= DEFAULT_REVIEW_FIX_BUDGET) {
+                const reviewFixBudget = getReviewFixBudget(project);
+                if (issue.reviewFixAttempts >= reviewFixBudget) {
                     this.logger.debug({
                         issueKey: issue.issueKey,
                         prNumber: issue.prNumber,
                         from: issue.factoryState,
                         runType: reactiveIntent.runType,
                         reviewFixAttempts: issue.reviewFixAttempts,
+                        reviewFixBudget,
                     }, "Reconciliation: leaving terminal requested-changes issue escalated because the repair budget is exhausted");
                     return;
                 }

package/dist/issue-session-events.js

@@ -1,6 +1,7 @@
 import { sanitizeOperatorFacingText } from "./presentation-text.js";
 const TERMINAL_SESSION_EVENTS = new Set([
     "stop_requested",
+    "operator_closed",
     "undelegated",
     "issue_removed",
     "pr_closed",

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-facts.js

@@ -0,0 +1,170 @@
+import { sanitizeOperatorFacingText } from "./presentation-text.js";
+export function deriveLinearProgressFact(notification, issue) {
+    switch (notification.method) {
+        case "item/completed":
+            return deriveProgressFactFromCompletedItem(notification.params.item, issue);
+        case "turn/plan/updated":
+            return deriveProgressFactFromPlan(notification.params.plan, issue);
+        default:
+            return undefined;
+    }
+}
+function deriveProgressFactFromCompletedItem(rawItem, issue) {
+    void issue;
+    if (!rawItem || typeof rawItem !== "object") {
+        return undefined;
+    }
+    const item = rawItem;
+    if (item.type !== "agentMessage" || typeof item.text !== "string") {
+        return undefined;
+    }
+    const body = compactOperatorSentence(item.text);
+    if (!body) {
+        return undefined;
+    }
+    if (looksLikeVerification(body)) {
+        return {
+            kind: "verification_started",
+            meaningKey: `verification:${normalizeMeaningKey(body)}`,
+            content: { type: "thought", body },
+        };
+    }
+    if (looksLikePublishing(body)) {
+        return {
+            kind: "publishing_started",
+            meaningKey: `publishing:${normalizeMeaningKey(body)}`,
+            content: { type: "thought", body },
+        };
+    }
+    if (looksLikeRootCause(body)) {
+        return {
+            kind: "root_cause_found",
+            meaningKey: `finding:${normalizeMeaningKey(body)}`,
+            content: { type: "thought", body },
+        };
+    }
+    return undefined;
+}
+function deriveProgressFactFromPlan(rawPlan, issue) {
+    if (!Array.isArray(rawPlan)) {
+        return undefined;
+    }
+    const activeStep = rawPlan
+        .map((entry) => normalizePlanEntry(entry))
+        .find((entry) => entry && entry.status === "in_progress");
+    if (!activeStep) {
+        return undefined;
+    }
+    if (looksLikeVerification(activeStep.step)) {
+        return {
+            kind: "verification_started",
+            meaningKey: `verification:${normalizeMeaningKey(activeStep.step)}`,
+            content: {
+                type: "action",
+                action: "Verifying",
+                parameter: summarizePlanStep(activeStep.step, "latest changes before publishing"),
+            },
+        };
+    }
+    if (looksLikePublishing(activeStep.step)) {
+        const parameter = summarizePlanStep(activeStep.step, issue?.prNumber !== undefined ? `changes to PR #${issue.prNumber}` : "latest changes");
+        return {
+            kind: "publishing_started",
+            meaningKey: `publishing:${normalizeMeaningKey(activeStep.step)}`,
+            content: {
+                type: "action",
+                action: "Publishing",
+                parameter,
+            },
+        };
+    }
+    return undefined;
+}
+function normalizePlanEntry(rawEntry) {
+    if (!rawEntry || typeof rawEntry !== "object") {
+        return undefined;
+    }
+    const entry = rawEntry;
+    const rawStep = entry.step;
+    if (typeof rawStep !== "string" || !rawStep.trim()) {
+        return undefined;
+    }
+    const rawStatus = typeof entry.status === "string" ? entry.status : "pending";
+    return {
+        step: rawStep.trim(),
+        status: rawStatus === "inProgress" ? "in_progress"
+            : rawStatus === "completed" ? "completed"
+                : rawStatus === "pending" ? "pending"
+                    : rawStatus === "in_progress" ? "in_progress"
+                        : "pending",
+    };
+}
+function looksLikeRootCause(text) {
+    const normalized = text.toLowerCase();
+    return /\b(narrowed|isolated|root cause)\b/.test(normalized)
+        || normalized.startsWith("found that ")
+        || normalized.startsWith("the failure is isolated")
+        || normalized.startsWith("the issue is isolated");
+}
+function looksLikeVerification(text) {
+    const normalized = text.toLowerCase();
+    return /\b(verifying|verification|targeted verification|smoke)\b/.test(normalized);
+}
+function looksLikePublishing(text) {
+    const normalized = text.toLowerCase();
+    return /\b(publish|publishing|push|pushing)\b/.test(normalized)
+        || normalized.includes("opening pr")
+        || normalized.includes("opening the pr")
+        || normalized.includes("opening pull request");
+}
+function compactOperatorSentence(text, maxLength = 160) {
+    const sanitized = sanitizeOperatorFacingText(text)?.replace(/\s+/g, " ").trim();
+    if (!sanitized) {
+        return undefined;
+    }
+    if (sanitized.length <= maxLength) {
+        return sanitized;
+    }
+    const punctuated = lastBoundaryWithinLimit(sanitized, maxLength, /[.;!?]/g);
+    if (punctuated !== undefined) {
+        return sanitized.slice(0, punctuated + 1).trim();
+    }
+    const spaced = sanitized.lastIndexOf(" ", maxLength);
+    if (spaced > 0) {
+        return `${sanitized.slice(0, spaced).trimEnd()}...`;
+    }
+    return `${sanitized.slice(0, maxLength).trimEnd()}...`;
+}
+function summarizePlanStep(step, fallback) {
+    const sanitized = sanitizeOperatorFacingText(step)?.replace(/\s+/g, " ").trim();
+    if (!sanitized) {
+        return fallback;
+    }
+    const stripped = sanitized
+        .replace(/^(run|running|start|starting)\s+/i, "")
+        .replace(/^(verify|verifying|verification of)\s+/i, "")
+        .replace(/^(publish|publishing|push|pushing|open|opening)\s+/i, "")
+        .trim()
+        .replace(/[.]+$/, "");
+    return stripped || fallback;
+}
+function normalizeMeaningKey(text) {
+    return text
+        .toLowerCase()
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function lastBoundaryWithinLimit(text, maxLength, pattern) {
+    let last = -1;
+    for (;;) {
+        const match = pattern.exec(text);
+        if (!match) {
+            break;
+        }
+        if (match.index >= maxLength) {
+            break;
+        }
+        last = match.index;
+    }
+    return last >= 0 ? last : undefined;
+}

package/dist/linear-progress-reporter.js

@@ -1,185 +1,38 @@
-import { sanitizeOperatorFacingCommand, sanitizeOperatorFacingText } from "./presentation-text.js";
-const PROGRESS_THROTTLE_MS = 5_000;
-const MAX_PROGRESS_TEXT_LENGTH = 220;
+import { deriveLinearProgressFact } from "./linear-progress-facts.js";
 export class LinearProgressReporter {
     db;
     emitActivity;
-    progressThrottle = new Map();
-    workingOnPublishedRuns = new Set();
-    agentMessageBuffers = new Map();
-    agentMessageProgressPublished = new Set();
+    publicationsByRun = new Map();
     constructor(db, emitActivity) {
         this.db = db;
         this.emitActivity = emitActivity;
     }
     maybeEmitProgress(notification, run) {
-        const issue = this.db.issues.getIssue(run.projectId, run.linearIssueId);
-        if (!issue)
+        const issue = this.db.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)
+        const fact = deriveLinearProgressFact(notification, issue);
+        if (!fact) {
             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) {
-        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 } };
+        const previous = this.publicationsByRun.get(run.id);
+        if (previous?.meaningKey === fact.meaningKey) {
+            return;
         }
-    }
-    if (agentSentence) {
-        return {
-            activity: { type: "thought", body: agentSentence },
-            bypassThrottle: true,
+        const publication = {
+            meaningKey: fact.meaningKey,
+            publishedAtMs: Date.now(),
         };
+        this.publicationsByRun.set(run.id, publication);
+        void this.emitActivity(issue, fact.content, { ephemeral: true }).catch(() => {
+            const current = this.publicationsByRun.get(run.id);
+            if (current?.publishedAtMs === publication.publishedAtMs && current.meaningKey === publication.meaningKey) {
+                this.publicationsByRun.delete(run.id);
+            }
+        });
     }
-    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;
+    clearProgress(runId) {
+        this.publicationsByRun.delete(runId);
     }
-    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/linear-workflow-state-sync.js

@@ -1,22 +1,24 @@
-import { resolvePreferredDeployingLinearState, resolvePreferredHumanNeededLinearState, resolvePreferredImplementingLinearState, resolvePreferredReviewLinearState, resolvePreferredReviewingLinearState, } from "./linear-workflow.js";
+import { resolvePreferredCompletedLinearState, resolvePreferredDeployingLinearState, resolvePreferredHumanNeededLinearState, resolvePreferredImplementingLinearState, resolvePreferredReviewLinearState, resolvePreferredReviewingLinearState, } from "./linear-workflow.js";
+import { isCompletedLinearState } from "./pr-state.js";
+import { hasTrustedNoPrCompletion } from "./trusted-no-pr-completion.js";
 export async function syncActiveWorkflowState(params) {
     const { db, issue, linear, trackedIssue, options } = params;
-    if (!shouldAutoAdvanceLinearState(issue)) {
-        return;
-    }
     const liveIssue = await linear.getIssue(issue.linearIssueId).catch(() => undefined);
     if (!liveIssue)
         return;
+    const latestRun = db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
+    if (hasTrustedNoPrCompletion(issue, latestRun)) {
+        await syncCompletedLinearState({ db, issue, linear, liveIssue });
+        return;
+    }
+    if (!shouldAutoAdvanceLinearState(issue)) {
+        return;
+    }
     if (!shouldAutoAdvanceLinearState({
         currentLinearState: liveIssue.stateName,
         currentLinearStateType: liveIssue.stateType,
     })) {
-        db.issues.upsertIssue({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
-            ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
-        });
+        refreshCachedLinearState(db, issue, liveIssue.stateName, liveIssue.stateType);
         return;
     }
     const targetState = resolveDesiredActiveWorkflowState(issue, trackedIssue, options, liveIssue);
@@ -24,20 +26,37 @@ export async function syncActiveWorkflowState(params) {
         return;
     const normalizedCurrent = liveIssue.stateName?.trim().toLowerCase();
     if (normalizedCurrent === targetState.trim().toLowerCase()) {
-        db.issues.upsertIssue({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
-            ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
-        });
+        refreshCachedLinearState(db, issue, liveIssue.stateName, liveIssue.stateType);
         return;
     }
     const updated = await linear.setIssueState(issue.linearIssueId, targetState);
+    refreshCachedLinearState(db, issue, updated.stateName, updated.stateType);
+}
+async function syncCompletedLinearState(params) {
+    const { db, issue, linear, liveIssue } = params;
+    if (isCompletedLinearState(liveIssue.stateType, liveIssue.stateName)) {
+        refreshCachedLinearState(db, issue, liveIssue.stateName, liveIssue.stateType);
+        return;
+    }
+    const targetState = resolvePreferredCompletedLinearState(liveIssue);
+    if (!targetState) {
+        refreshCachedLinearState(db, issue, liveIssue.stateName, liveIssue.stateType);
+        return;
+    }
+    const normalizedCurrent = liveIssue.stateName?.trim().toLowerCase();
+    if (normalizedCurrent === targetState.trim().toLowerCase()) {
+        refreshCachedLinearState(db, issue, liveIssue.stateName, liveIssue.stateType);
+        return;
+    }
+    const updated = await linear.setIssueState(issue.linearIssueId, targetState);
+    refreshCachedLinearState(db, issue, updated.stateName, updated.stateType);
+}
+function refreshCachedLinearState(db, issue, stateName, stateType) {
     db.issues.upsertIssue({
         projectId: issue.projectId,
         linearIssueId: issue.linearIssueId,
-        ...(updated.stateName ? { currentLinearState: updated.stateName } : {}),
-        ...(updated.stateType ? { currentLinearStateType: updated.stateType } : {}),
+        ...(stateName ? { currentLinearState: stateName } : {}),
+        ...(stateType ? { currentLinearStateType: stateType } : {}),
     });
 }
 function shouldAutoAdvanceLinearState(issue) {

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 {};
+}