patchrelay 0.38.1 → 0.39.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.38.1",
-  "commit": "f8444979b2ac",
-  "builtAt": "2026-04-10T18:39:19.100Z"
+  "version": "0.39.0",
+  "commit": "80d285a7e9bd",
+  "builtAt": "2026-04-11T20:04:29.313Z"
 }

package/dist/cli/args.js

@@ -3,6 +3,7 @@ export const KNOWN_COMMANDS = new Set([
     "version",
     "serve",
     "issue",
+    "close",
     "cluster",
     "doctor",
     "init",
@@ -56,6 +57,9 @@ export function resolveCommand(parsed) {
         return { command: "help", commandArgs: [] };
     }
     if (KNOWN_COMMANDS.has(requestedCommand)) {
+        if (requestedCommand === "close") {
+            return { command: "issue", commandArgs: ["close", ...parsed.positionals.slice(1)] };
+        }
         if (requestedCommand === "attach") {
             return { command: "repo", commandArgs: ["link", ...parsed.positionals.slice(1)] };
         }

package/dist/cli/commands/issues.js

@@ -2,7 +2,7 @@ import { setTimeout as delay } from "node:timers/promises";
 import { getRunTypeFlag } from "../args.js";
 import { CliUsageError } from "../errors.js";
 import { formatJson } from "../formatters/json.js";
-import { formatInspect, formatList, formatLive, formatOpen, formatRetry, formatSessionHistory, formatWorktree } from "../formatters/text.js";
+import { formatClose, formatInspect, formatList, formatLive, formatOpen, formatRetry, formatSessionHistory, formatWorktree } from "../formatters/text.js";
 import { buildOpenCommand } from "../interactive.js";
 import { writeOutput } from "../output.js";
 export async function handleIssueCommand(params) {
@@ -38,6 +38,8 @@ export async function handleIssueCommand(params) {
             return await handleSessionsCommand(nested);
         case "retry":
             return await handleRetryCommand(nested);
+        case "close":
+            return await handleCloseCommand(nested);
         default:
             throw new CliUsageError(`Unknown issue command: ${subcommand}`, "issue");
     }
@@ -148,6 +150,23 @@ export async function handleRetryCommand(params) {
     writeOutput(params.stdout, params.json ? formatJson(result) : formatRetry(result));
     return 0;
 }
+export async function handleCloseCommand(params) {
+    const issueKey = params.commandArgs[0];
+    if (!issueKey) {
+        throw new Error("close requires <issueKey>.");
+    }
+    const result = params.data.closeIssue(issueKey, {
+        failed: params.parsed.flags.get("failed") === true,
+        ...(typeof params.parsed.flags.get("reason") === "string"
+            ? { reason: String(params.parsed.flags.get("reason")) }
+            : {}),
+    });
+    if (!result) {
+        throw new Error(`Issue not found: ${issueKey}`);
+    }
+    writeOutput(params.stdout, params.json ? formatJson(result) : formatClose(result));
+    return 0;
+}
 export async function handleListCommand(params) {
     const result = params.data.list({
         active: params.parsed.flags.get("active") === true,

package/dist/cli/data.js

@@ -4,6 +4,7 @@ import { CodexAppServerClient } from "../codex-app-server.js";
 import { extractCompletionCheck } from "../completion-check.js";
 import { getThreadTurns } from "../codex-thread-utils.js";
 import { PatchRelayDatabase } from "../db.js";
+import { buildManualRetryAttemptReset, resolveRetryTarget } from "../manual-issue-actions.js";
 import { WorktreeManager } from "../worktree-manager.js";
 import { CliOperatorApiClient } from "./operator-client.js";
 function safeJsonParse(value) {
@@ -200,13 +201,15 @@ export class CliDataAccess extends CliOperatorApiClient {
             throw new Error(`Issue ${issueKey} already has an active run.`);
         }
         const runType = (options?.runType
-            ?? (issue.latestFailureSource === "queue_eviction" || issue.factoryState === "repairing_queue"
-                ? "queue_repair"
-                : dbIssue.prCheckStatus === "failed" || dbIssue.prCheckStatus === "failure" || issue.latestFailureSource === "branch_ci" || issue.factoryState === "repairing_ci"
-                    ? "ci_repair"
-                    : dbIssue.prReviewState === "changes_requested" || issue.factoryState === "changes_requested"
-                        ? (dbIssue.pendingRunType === "branch_upkeep" || issueSession?.lastRunType === "branch_upkeep" ? "branch_upkeep" : "review_fix")
-                        : "implementation"));
+            ?? resolveRetryTarget({
+                prNumber: dbIssue.prNumber,
+                prState: dbIssue.prState,
+                prReviewState: dbIssue.prReviewState,
+                prCheckStatus: dbIssue.prCheckStatus,
+                pendingRunType: dbIssue.pendingRunType,
+                lastRunType: issueSession?.lastRunType,
+                lastGitHubFailureSource: issue.latestFailureSource,
+            }).runType);
         const factoryState = runType === "queue_repair"
             ? "repairing_queue"
             : runType === "ci_repair"
@@ -221,10 +224,54 @@ export class CliDataAccess extends CliOperatorApiClient {
             pendingRunType: null,
             pendingRunContextJson: null,
             factoryState,
+            ...buildManualRetryAttemptReset(runType),
         });
         const updated = this.db.getTrackedIssue(issue.projectId, issue.linearIssueId);
         return { issue: updated, runType, ...(options?.reason ? { reason: options.reason } : {}) };
     }
+    closeIssue(issueKey, options) {
+        const issue = this.db.getTrackedIssueByKey(issueKey);
+        if (!issue)
+            return undefined;
+        const dbIssue = this.db.issues.getIssueByKey(issueKey);
+        const terminalState = options?.failed ? "failed" : "done";
+        const run = dbIssue.activeRunId ? this.db.runs.getRunById(dbIssue.activeRunId) : undefined;
+        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}:${dbIssue.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);
+        const updated = this.db.getTrackedIssue(issue.projectId, issue.linearIssueId);
+        return {
+            issue: updated,
+            factoryState: terminalState,
+            ...(options?.reason ? { reason: options.reason } : {}),
+            ...(run ? { releasedRunId: run.id } : {}),
+        };
+    }
     sessions(issueKey) {
         const issue = this.db.getTrackedIssueByKey(issueKey);
         if (!issue)

package/dist/cli/formatters/text.js

@@ -84,6 +84,16 @@ export function formatRetry(result) {
         .filter(Boolean)
         .join("\n")}\n`;
 }
+export function formatClose(result) {
+    return `${[
+        value("Issue", result.issue.issueKey ?? result.issue.linearIssueId),
+        value("Closed as", result.factoryState),
+        result.releasedRunId ? value("Released run", result.releasedRunId) : undefined,
+        result.reason ? value("Reason", result.reason) : undefined,
+    ]
+        .filter(Boolean)
+        .join("\n")}\n`;
+}
 function formatTimestampRange(startedAt, endedAt) {
     return endedAt ? `${startedAt} -> ${endedAt}` : `${startedAt} -> running`;
 }

package/dist/cli/help.js

@@ -37,6 +37,8 @@ export function rootHelpText() {
         "  issue watch <issueKey> [--json]                         Follow the active run until it settles",
         "  issue open <issueKey> [--print] [--json]                Open Codex in the issue worktree",
         "  issue sessions <issueKey> [--json]                      Show recorded Codex app-server sessions for one issue",
+        "  issue close <issueKey> [--failed] [--reason <text>] [--json]",
+        "                                                          Force-close one issue and release any active run",
         "  service status [--json]                                 Show systemd state and local health",
         "  cluster [--json]                                        Check service + workflow health across all tracked issues",
         "  service logs [--lines <count>] [--json]                 Show recent service logs",
@@ -149,12 +151,14 @@ export function issueHelpText() {
         "  open <issueKey>                 Open Codex in the issue worktree",
         "  sessions <issueKey>             Show recorded Codex app-server sessions",
         "  retry <issueKey>                Requeue a run",
+        "  close <issueKey>                Force-close a stuck issue",
         "",
         "Examples:",
         "  patchrelay issue list --active",
         "  patchrelay issue show USE-54",
         "  patchrelay issue watch USE-54",
         "  patchrelay issue sessions USE-54",
+        "  patchrelay close USE-54 --reason \"already handled manually\"",
     ].join("\n");
 }
 export function serviceHelpText() {

package/dist/cli/index.js

@@ -67,6 +67,9 @@ function validateFlags(command, commandArgs, parsed) {
                 case "retry":
                     assertKnownFlags(parsed, "issue", ["run-type", "reason", "json"]);
                     return;
+                case "close":
+                    assertKnownFlags(parsed, "issue", ["failed", "reason", "json"]);
+                    return;
                 default:
                     assertKnownFlags(parsed, "issue", []);
                     return;

package/dist/config.js

@@ -21,6 +21,11 @@ const repoSettingsSchema = z.object({
     trigger_events: z.array(z.string().min(1)).min(1).optional(),
     branch_prefix: z.string().min(1).optional(),
 });
+const repairBudgetsSchema = z.object({
+    ci_repair: z.number().int().positive().default(3),
+    queue_repair: z.number().int().positive().default(3),
+    review_fix: z.number().int().positive().default(3),
+});
 const projectSchema = z.object({
     id: z.string().min(1),
     repo_path: z.string().min(1),
@@ -31,6 +36,11 @@ const projectSchema = z.object({
     allow_labels: z.array(z.string().min(1)).default([]),
     trigger_events: z.array(z.string().min(1)).min(1).optional(),
     branch_prefix: z.string().min(1).optional(),
+    repair_budgets: repairBudgetsSchema.default({
+        ci_repair: 3,
+        queue_repair: 3,
+        review_fix: 3,
+    }),
     /** Check names that are review gates (AI Review, quality analysis). Default: code class. */
     review_checks: z.array(z.string().min(1)).default([]),
     /** Check names that are policy gates (conventional title, release policy). Default: code class. */
@@ -52,6 +62,11 @@ const repositorySchema = z.object({
     gate_checks: z.array(z.string().min(1)).default([]),
     trigger_events: z.array(z.string().min(1)).min(1).optional(),
     branch_prefix: z.string().min(1).optional(),
+    repair_budgets: repairBudgetsSchema.default({
+        ci_repair: 3,
+        queue_repair: 3,
+        review_fix: 3,
+    }),
     github: z.object({
         webhook_secret: z.string().min(1).optional(),
         base_branch: z.string().min(1).optional(),
@@ -405,6 +420,11 @@ export function loadConfig(configPath = process.env.PATCHRELAY_CONFIG ?? getDefa
             gateChecks: repository.gate_checks,
             triggerEvents: repository.trigger_events,
             branchPrefix: repository.branch_prefix,
+            repairBudgets: {
+                ciRepair: repository.repair_budgets.ci_repair,
+                queueRepair: repository.repair_budgets.queue_repair,
+                reviewFix: repository.repair_budgets.review_fix,
+            },
             github: repository.github,
         };
     });
@@ -421,6 +441,7 @@ export function loadConfig(configPath = process.env.PATCHRELAY_CONFIG ?? getDefa
             gateChecks: repository.gateChecks,
             triggerEvents: normalizeTriggerEvents(parsed.linear.oauth.actor, repoSettings?.trigger_events ?? repository.triggerEvents),
             branchPrefix: repoSettings?.branch_prefix ?? repository.branchPrefix ?? defaultBranchPrefix(repository.githubRepo),
+            repairBudgets: repository.repairBudgets,
             ...(repoSettings?.configPath ? { repoSettingsPath: repoSettings.configPath } : {}),
             github: {
                 repoFullName: repository.githubRepo,
@@ -457,6 +478,11 @@ export function loadConfig(configPath = process.env.PATCHRELAY_CONFIG ?? getDefa
             triggerEvents: normalizeTriggerEvents(parsed.linear.oauth.actor, repoSettings?.trigger_events ??
                 project.trigger_events),
             branchPrefix: repoSettings?.branch_prefix ?? project.branch_prefix ?? defaultBranchPrefix(project.id),
+            repairBudgets: {
+                ciRepair: project.repair_budgets.ci_repair,
+                queueRepair: project.repair_budgets.queue_repair,
+                reviewFix: project.repair_budgets.review_fix,
+            },
             ...(repoSettings?.configPath ? { repoSettingsPath: repoSettings.configPath } : {}),
             ...(project.github ? {
                 github: {

package/dist/db/issue-store.js

@@ -88,6 +88,10 @@ export class IssueStore {
                 sets.push("agent_session_id = @agentSessionId");
                 values.agentSessionId = params.agentSessionId;
             }
+            if (params.lastLinearActivityKey !== undefined) {
+                sets.push("last_linear_activity_key = @lastLinearActivityKey");
+                values.lastLinearActivityKey = params.lastLinearActivityKey;
+            }
             if (params.prNumber !== undefined) {
                 sets.push("pr_number = @prNumber");
                 values.prNumber = params.prNumber;
@@ -213,7 +217,7 @@ export class IssueStore {
           priority, estimate,
           current_linear_state, current_linear_state_type, factory_state, pending_run_type, pending_run_context_json,
           branch_name, worktree_path, thread_id, active_run_id, status_comment_id,
-          agent_session_id,
+          agent_session_id, last_linear_activity_key,
           pr_number, pr_url, pr_state, pr_head_sha, pr_author_login, pr_review_state, pr_check_status, last_blocking_review_head_sha,
           last_github_failure_source, last_github_failure_head_sha, last_github_failure_signature, last_github_failure_check_name, last_github_failure_check_url, last_github_failure_context_json, last_github_failure_at,
           last_github_ci_snapshot_head_sha, last_github_ci_snapshot_gate_check_name, last_github_ci_snapshot_gate_check_status, last_github_ci_snapshot_json, last_github_ci_snapshot_settled_at,
@@ -226,7 +230,7 @@ export class IssueStore {
           @priority, @estimate,
           @currentLinearState, @currentLinearStateType, @factoryState, @pendingRunType, @pendingRunContextJson,
           @branchName, @worktreePath, @threadId, @activeRunId, @statusCommentId,
-          @agentSessionId,
+          @agentSessionId, @lastLinearActivityKey,
           @prNumber, @prUrl, @prState, @prHeadSha, @prAuthorLogin, @prReviewState, @prCheckStatus, @lastBlockingReviewHeadSha,
           @lastGitHubFailureSource, @lastGitHubFailureHeadSha, @lastGitHubFailureSignature, @lastGitHubFailureCheckName, @lastGitHubFailureCheckUrl, @lastGitHubFailureContextJson, @lastGitHubFailureAt,
           @lastGitHubCiSnapshotHeadSha, @lastGitHubCiSnapshotGateCheckName, @lastGitHubCiSnapshotGateCheckStatus, @lastGitHubCiSnapshotJson, @lastGitHubCiSnapshotSettledAt,
@@ -256,6 +260,7 @@ export class IssueStore {
                 activeRunId: params.activeRunId ?? null,
                 statusCommentId: params.statusCommentId ?? null,
                 agentSessionId: params.agentSessionId ?? null,
+                lastLinearActivityKey: params.lastLinearActivityKey ?? null,
                 prNumber: params.prNumber ?? null,
                 prUrl: params.prUrl ?? null,
                 prState: params.prState ?? null,
@@ -483,6 +488,9 @@ export function mapIssueRow(row) {
         ...(row.active_run_id !== null ? { activeRunId: Number(row.active_run_id) } : {}),
         ...(row.status_comment_id !== null && row.status_comment_id !== undefined ? { statusCommentId: String(row.status_comment_id) } : {}),
         ...(row.agent_session_id !== null ? { agentSessionId: String(row.agent_session_id) } : {}),
+        ...(row.last_linear_activity_key !== null && row.last_linear_activity_key !== undefined
+            ? { lastLinearActivityKey: String(row.last_linear_activity_key) }
+            : {}),
         updatedAt: String(row.updated_at),
         ...(row.pr_number !== null && row.pr_number !== undefined ? { prNumber: Number(row.pr_number) } : {}),
         ...(row.pr_url !== null && row.pr_url !== undefined ? { prUrl: String(row.pr_url) } : {}),

package/dist/db/migrations.js

@@ -18,6 +18,7 @@ CREATE TABLE IF NOT EXISTS issues (
   active_run_id INTEGER,
   status_comment_id TEXT,
   agent_session_id TEXT,
+  last_linear_activity_key TEXT,
   pr_number INTEGER,
   pr_url TEXT,
   pr_state TEXT,
@@ -264,6 +265,7 @@ export function runPatchRelayMigrations(connection) {
     addColumnIfMissing(connection, "issues", "priority", "INTEGER");
     addColumnIfMissing(connection, "issues", "estimate", "REAL");
     addColumnIfMissing(connection, "issues", "status_comment_id", "TEXT");
+    addColumnIfMissing(connection, "issues", "last_linear_activity_key", "TEXT");
     addColumnIfMissing(connection, "issues", "current_linear_state_type", "TEXT");
     addColumnIfMissing(connection, "issue_dependencies", "blocker_current_linear_state_type", "TEXT");
     // Zombie/stale recovery backoff
@@ -329,6 +331,7 @@ function removeRetiredIssueColumnsIfPresent(connection) {
         active_run_id INTEGER,
         status_comment_id TEXT,
         agent_session_id TEXT,
+        last_linear_activity_key TEXT,
         pr_number INTEGER,
         pr_url TEXT,
         pr_state TEXT,
@@ -384,6 +387,7 @@ function removeRetiredIssueColumnsIfPresent(connection) {
         active_run_id,
         status_comment_id,
         agent_session_id,
+        last_linear_activity_key,
         pr_number,
         pr_url,
         pr_state,
@@ -437,6 +441,7 @@ function removeRetiredIssueColumnsIfPresent(connection) {
         active_run_id,
         status_comment_id,
         agent_session_id,
+        last_linear_activity_key,
         pr_number,
         pr_url,
         pr_state,

package/dist/factory-state.js

@@ -48,6 +48,7 @@ const TRANSITION_RULES = [
         to: "changes_requested" },
     // review_commented: no rule → no transition (informational only)
     // ── CI check events ────────────────────────────────────────────
+    // check_pending: no rule → no transition (metadata / progress only)
     // After queue repair, return to the merge queue.
     { event: "check_passed",
         guard: (s) => s === "repairing_queue",

package/dist/github-webhook-handler.js

@@ -4,6 +4,7 @@ import { safeJsonParse } from "./utils.js";
 import { GitHubPrCommentHandler } from "./github-pr-comment-handler.js";
 import { createGitHubCiSnapshotResolver, createGitHubFailureContextResolver, } from "./github-failure-context.js";
 import { resolveGitHubWebhookIssue } from "./github-webhook-issue-resolution.js";
+import { maybeCloseLatePublishedImplementationPr } from "./github-webhook-late-publication-guard.js";
 import { projectGitHubWebhookState } from "./github-webhook-state-projector.js";
 import { maybeEnqueueGitHubReactiveRun } from "./github-webhook-reactive-run.js";
 import { handleGitHubTerminalPrEvent } from "./github-webhook-terminal-handler.js";
@@ -98,6 +99,17 @@ export class GitHubWebhookHandler {
             this.logger.debug({ repoFullName: event.repoFullName, branchName: event.branchName, prNumber: event.prNumber, triggerEvent: event.triggerEvent }, "GitHub webhook: no matching tracked issue");
             return;
         }
+        const suppressedLatePublication = await maybeCloseLatePublishedImplementationPr({
+            db: this.db,
+            logger: this.logger,
+            feed: this.feed,
+            issue,
+            event,
+            fetchImpl: this.fetchImpl,
+        });
+        if (suppressedLatePublication) {
+            return;
+        }
         const freshIssue = await projectGitHubWebhookState({
             config: this.config,
             db: this.db,

package/dist/github-webhook-late-publication-guard.js

@@ -0,0 +1,94 @@
+function isPatchRelayBot(login) {
+    return login === "patchrelay[bot]" || login === "app/patchrelay";
+}
+function parseRepo(repoFullName) {
+    const [owner, repo] = repoFullName.split("/", 2);
+    if (!owner || !repo)
+        return undefined;
+    return { owner, repo };
+}
+export async function maybeCloseLatePublishedImplementationPr(params) {
+    const { db, logger, feed, issue, event, fetchImpl } = params;
+    if (event.triggerEvent !== "pr_opened")
+        return false;
+    if (event.prNumber === undefined)
+        return false;
+    if (issue.prNumber !== undefined)
+        return false;
+    if (!isPatchRelayBot(event.prAuthorLogin))
+        return false;
+    const latestRun = db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
+    if (!latestRun || latestRun.runType !== "implementation")
+        return false;
+    if (latestRun.status === "running" || latestRun.status === "completed")
+        return false;
+    const repo = parseRepo(event.repoFullName);
+    const token = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
+    if (!repo || !token) {
+        logger.warn({
+            issueKey: issue.issueKey,
+            prNumber: event.prNumber,
+            latestRunId: latestRun.id,
+            latestRunStatus: latestRun.status,
+        }, "Late PatchRelay PR was detected after the implementation run had already stopped, but PatchRelay could not auto-close it");
+        feed?.publish({
+            level: "warn",
+            kind: "github",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: issue.factoryState,
+            status: "late_pr_detected",
+            summary: `Detected late PR #${event.prNumber} from an inactive implementation run`,
+            detail: latestRun.failureReason ?? `Latest implementation run status: ${latestRun.status}`,
+        });
+        return false;
+    }
+    const response = await fetchImpl(`https://api.github.com/repos/${encodeURIComponent(repo.owner)}/${encodeURIComponent(repo.repo)}/pulls/${event.prNumber}`, {
+        method: "PATCH",
+        headers: {
+            Authorization: `Bearer ${token}`,
+            Accept: "application/vnd.github+json",
+            "Content-Type": "application/json",
+            "User-Agent": "patchrelay",
+            "X-GitHub-Api-Version": "2022-11-28",
+        },
+        body: JSON.stringify({ state: "closed" }),
+    });
+    if (!response.ok) {
+        logger.warn({
+            issueKey: issue.issueKey,
+            prNumber: event.prNumber,
+            status: response.status,
+            latestRunId: latestRun.id,
+            latestRunStatus: latestRun.status,
+        }, "Failed to auto-close late PatchRelay PR from an inactive implementation run");
+        feed?.publish({
+            level: "warn",
+            kind: "github",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: issue.factoryState,
+            status: "late_pr_close_failed",
+            summary: `Could not auto-close late PR #${event.prNumber}`,
+            detail: latestRun.failureReason ?? `Latest implementation run status: ${latestRun.status}`,
+        });
+        return false;
+    }
+    logger.warn({
+        issueKey: issue.issueKey,
+        prNumber: event.prNumber,
+        latestRunId: latestRun.id,
+        latestRunStatus: latestRun.status,
+    }, "Auto-closed late PatchRelay PR from an inactive implementation run");
+    feed?.publish({
+        level: "warn",
+        kind: "github",
+        issueKey: issue.issueKey,
+        projectId: issue.projectId,
+        stage: issue.factoryState,
+        status: "late_pr_closed",
+        summary: `Auto-closed late PR #${event.prNumber} from an inactive implementation run`,
+        detail: latestRun.failureReason ?? `Latest implementation run status: ${latestRun.status}`,
+    });
+    return true;
+}

package/dist/github-webhook-state-projector.js

@@ -112,6 +112,7 @@ async function updateGitHubCiSnapshot(deps, issue, event, project, ciSnapshotRes
         deps.db.issues.upsertIssue({
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
+            prCheckStatus: "pending",
             lastGitHubCiSnapshotHeadSha: event.headSha ?? null,
             lastGitHubCiSnapshotGateCheckName: getPrimaryGateCheckName(project),
             lastGitHubCiSnapshotGateCheckStatus: "pending",
@@ -122,7 +123,7 @@ async function updateGitHubCiSnapshot(deps, issue, event, project, ciSnapshotRes
     }
     if (issue.prState !== "open")
         return;
-    if (event.eventSource !== "check_run")
+    if (event.eventSource !== "check_run" && event.eventSource !== "check_suite")
         return;
     if (isQueueEvictionFailure(issue, event, project))
         return;
@@ -130,6 +131,19 @@ async function updateGitHubCiSnapshot(deps, issue, event, project, ciSnapshotRes
         return;
     if (isStaleGateEvent(issue, event))
         return;
+    if (event.triggerEvent === "check_pending") {
+        deps.db.issues.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            prCheckStatus: "pending",
+            lastGitHubCiSnapshotHeadSha: event.headSha ?? issue.lastGitHubCiSnapshotHeadSha ?? null,
+            lastGitHubCiSnapshotGateCheckName: event.checkName ?? getPrimaryGateCheckName(project),
+            lastGitHubCiSnapshotGateCheckStatus: "pending",
+            lastGitHubCiSnapshotJson: null,
+            lastGitHubCiSnapshotSettledAt: null,
+        });
+        return;
+    }
     const snapshot = await ciSnapshotResolver.resolve({
         repoFullName: project?.github?.repoFullName ?? event.repoFullName,
         event,

package/dist/github-webhooks.js

@@ -114,9 +114,25 @@ function normalizePullRequestReviewEvent(payload, repoFullName) {
     };
 }
 function normalizeCheckSuiteEvent(payload, repoFullName) {
-    if (payload.action !== "completed")
-        return undefined;
     const suite = payload.check_suite;
+    if (payload.action !== "completed") {
+        if (payload.action !== "requested" && payload.action !== "rerequested" && payload.action !== "in_progress") {
+            return undefined;
+        }
+        const pr = suite.pull_requests?.[0];
+        const branchName = pr?.head.ref ?? suite.head_branch ?? "";
+        if (!branchName)
+            return undefined;
+        return {
+            triggerEvent: "check_pending",
+            repoFullName,
+            branchName,
+            headSha: suite.head_sha,
+            prNumber: pr?.number,
+            checkStatus: "pending",
+            eventSource: "check_suite",
+        };
+    }
     const conclusion = suite.conclusion?.toLowerCase();
     const pr = suite.pull_requests?.[0];
     const branchName = pr?.head.ref ?? suite.head_branch ?? "";
@@ -134,9 +150,28 @@ function normalizeCheckSuiteEvent(payload, repoFullName) {
     };
 }
 function normalizeCheckRunEvent(payload, repoFullName) {
-    if (payload.action !== "completed")
-        return undefined;
     const run = payload.check_run;
+    if (payload.action !== "completed") {
+        if (payload.action !== "requested" && payload.action !== "rerequested" && payload.action !== "in_progress") {
+            return undefined;
+        }
+        const pr = run.check_suite?.pull_requests?.[0];
+        const branchName = pr?.head.ref ?? run.check_suite?.head_branch ?? "";
+        if (!branchName)
+            return undefined;
+        return {
+            triggerEvent: "check_pending",
+            repoFullName,
+            branchName,
+            headSha: run.head_sha,
+            prNumber: pr?.number,
+            checkStatus: "pending",
+            checkName: run.name,
+            checkUrl: run.html_url,
+            checkDetailsUrl: run.details_url,
+            eventSource: "check_run",
+        };
+    }
     const conclusion = run.conclusion?.toLowerCase();
     const pr = run.check_suite?.pull_requests?.[0];
     const branchName = pr?.head.ref ?? run.check_suite?.head_branch ?? "";

package/dist/github-worktree-auth.js

@@ -0,0 +1,18 @@
+import { execCommand } from "./utils.js";
+function shellSingleQuote(value) {
+    return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+export function buildGitHubBotCredentialHelper(tokenFile) {
+    const quotedTokenFile = shellSingleQuote(tokenFile);
+    return `!f() { [ "$1" = get ] || exit 0; echo "username=x-access-token"; echo "password=$(cat ${quotedTokenFile})"; }; f`;
+}
+export async function configureGitHubBotAuthForWorktree(params) {
+    const helper = buildGitHubBotCredentialHelper(params.botIdentity.tokenFile);
+    const gitArgs = ["-C", params.worktreePath, "config"];
+    await execCommand(params.gitBin, [...gitArgs, "user.name", params.botIdentity.name], { timeoutMs: 5_000 });
+    await execCommand(params.gitBin, [...gitArgs, "user.email", params.botIdentity.email], { timeoutMs: 5_000 });
+    // Clear inherited GitHub-specific helpers such as `gh auth git-credential`
+    // so git HTTPS operations use the same bot token as the wrapped `gh` CLI.
+    await execCommand(params.gitBin, [...gitArgs, "--replace-all", "credential.https://github.com.helper", ""], { timeoutMs: 5_000 });
+    await execCommand(params.gitBin, [...gitArgs, "--add", "credential.https://github.com.helper", helper], { timeoutMs: 5_000 });
+}

package/dist/http.js

@@ -314,6 +314,23 @@ export async function buildHttpServer(config, service, logger) {
             }
             return reply.send({ ok: true, ...result });
         });
+        app.post("/api/issues/:issueKey/close", async (request, reply) => {
+            const issueKey = request.params.issueKey;
+            const body = request.body;
+            const result = await service.closeIssue(issueKey, {
+                failed: body?.failed === true,
+                ...(typeof body?.reason === "string" && body.reason.trim()
+                    ? { reason: body.reason.trim() }
+                    : {}),
+            });
+            if (!result) {
+                return reply.code(404).send({ ok: false, reason: "issue_not_found" });
+            }
+            if ("error" in result) {
+                return reply.code(409).send({ ok: false, reason: result.error });
+            }
+            return reply.send({ ok: true, ...result });
+        });
         app.get("/api/installations", async (_request, reply) => {
             return reply.send({ ok: true, installations: service.listLinearInstallations() });
         });