patchrelay 0.35.7 → 0.35.9

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.35.7",
-  "commit": "880bc08921ac",
-  "builtAt": "2026-04-03T11:50:11.628Z"
+  "version": "0.35.9",
+  "commit": "26b4d319fde3",
+  "builtAt": "2026-04-03T23:53:54.564Z"
 }

package/dist/github-app-token.js

@@ -203,8 +203,10 @@ async function resolveBotIdentity(jwt) {
         throw new Error(`Failed to fetch bot user ${botLogin} (${userResponse.status}): ${body}`);
     }
     const user = await userResponse.json();
+    const { tokenFile } = getGitHubAppPaths();
     return {
         name: user.login,
         email: `${user.id}+${user.login}@users.noreply.github.com`,
+        tokenFile,
     };
 }

package/dist/idle-reconciliation.js

@@ -0,0 +1,262 @@
+import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
+import { parseGitHubFailureContext } from "./github-failure-context.js";
+import { parseStoredQueueRepairContext } from "./merge-queue-incident.js";
+import { execCommand } from "./utils.js";
+function isDuplicateRepairAttempt(issue, context) {
+    const signature = typeof context?.failureSignature === "string" ? context.failureSignature : undefined;
+    const headSha = typeof context?.failureHeadSha === "string"
+        ? context.failureHeadSha
+        : typeof context?.headSha === "string" ? context.headSha : undefined;
+    if (!signature)
+        return false;
+    return issue.lastAttemptedFailureSignature === signature
+        && (headSha === undefined || issue.lastAttemptedFailureHeadSha === headSha);
+}
+function buildFailureContext(issue) {
+    const storedFailureContext = parseGitHubFailureContext(issue.lastGitHubFailureContextJson);
+    const queueRepairContext = issue.lastQueueIncidentJson
+        ? parseStoredQueueRepairContext(issue.lastQueueIncidentJson)
+        : undefined;
+    if (!queueRepairContext
+        && !issue.lastGitHubFailureSource
+        && !issue.lastGitHubFailureHeadSha
+        && !issue.lastGitHubFailureSignature
+        && !issue.lastGitHubFailureCheckName
+        && !issue.lastGitHubFailureCheckUrl
+        && !storedFailureContext) {
+        return undefined;
+    }
+    return {
+        ...(issue.lastGitHubFailureSource ? { failureReason: issue.lastGitHubFailureSource } : {}),
+        ...(issue.lastGitHubFailureHeadSha ? { failureHeadSha: issue.lastGitHubFailureHeadSha } : {}),
+        ...(issue.lastGitHubFailureSignature ? { failureSignature: issue.lastGitHubFailureSignature } : {}),
+        ...(issue.lastGitHubFailureCheckName ? { checkName: issue.lastGitHubFailureCheckName } : {}),
+        ...(issue.lastGitHubFailureCheckUrl ? { checkUrl: issue.lastGitHubFailureCheckUrl } : {}),
+        ...(storedFailureContext ? storedFailureContext : {}),
+        ...(queueRepairContext ? queueRepairContext : {}),
+    };
+}
+export function resolveBranchOwnerForStateTransition(newState, pendingRunType) {
+    if (pendingRunType)
+        return "patchrelay";
+    if (newState === "awaiting_queue")
+        return "merge_steward";
+    if (newState === "repairing_ci" || newState === "repairing_queue")
+        return "patchrelay";
+    return undefined;
+}
+export class IdleIssueReconciler {
+    db;
+    config;
+    deps;
+    logger;
+    feed;
+    constructor(db, config, deps, logger, feed) {
+        this.db = db;
+        this.config = config;
+        this.deps = deps;
+        this.logger = logger;
+        this.feed = feed;
+    }
+    async reconcile() {
+        for (const issue of this.db.listIdleNonTerminalIssues()) {
+            if (issue.prState === "merged") {
+                this.advanceIdleIssue(issue, "done", { clearFailureProvenance: true });
+                continue;
+            }
+            if (issue.prReviewState === "approved" && issue.prCheckStatus !== "failed") {
+                if (issue.factoryState !== "awaiting_queue" || issue.branchOwner !== "merge_steward") {
+                    this.advanceIdleIssue(issue, "awaiting_queue", { clearFailureProvenance: true });
+                }
+                else if (!issue.queueLabelApplied) {
+                    await this.deps.requestMergeQueueAdmission(issue, issue.projectId);
+                }
+                continue;
+            }
+            if (issue.prCheckStatus === "failed") {
+                await this.routeFailedIssue(issue);
+                continue;
+            }
+            // Probe GitHub for stale pr_open issues: detect missed reviews,
+            // merge conflicts, and other state that webhooks may have missed.
+            if (issue.factoryState === "pr_open") {
+                await this.reconcileFromGitHub(issue);
+            }
+        }
+        for (const issue of this.db.listBlockedDelegatedIssues()) {
+            const unresolved = this.db.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
+            if (unresolved === 0) {
+                this.db.upsertIssue({
+                    projectId: issue.projectId,
+                    linearIssueId: issue.linearIssueId,
+                    pendingRunType: "implementation",
+                });
+                this.deps.enqueueIssue(issue.projectId, issue.linearIssueId);
+            }
+        }
+    }
+    advanceIdleIssue(issue, newState, options) {
+        if (issue.factoryState === newState && !options?.pendingRunType && !options?.clearFailureProvenance) {
+            return;
+        }
+        this.logger.info({ issueKey: issue.issueKey, from: issue.factoryState, to: newState, pendingRunType: options?.pendingRunType }, "Reconciliation: advancing idle issue");
+        const resetQueueLabel = newState === "awaiting_queue" || issue.factoryState === "awaiting_queue";
+        this.db.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            factoryState: newState,
+            ...(options?.pendingRunType ? { pendingRunType: options.pendingRunType } : {}),
+            ...(options?.pendingRunType
+                ? {
+                    pendingRunContextJson: options.pendingRunContext ? JSON.stringify(options.pendingRunContext) : null,
+                }
+                : {}),
+            ...(resetQueueLabel ? { queueLabelApplied: false } : {}),
+            ...(options?.clearFailureProvenance
+                ? {
+                    lastGitHubFailureSource: null,
+                    lastGitHubFailureHeadSha: null,
+                    lastGitHubFailureSignature: null,
+                    lastGitHubFailureCheckName: null,
+                    lastGitHubFailureCheckUrl: null,
+                    lastGitHubFailureContextJson: null,
+                    lastGitHubFailureAt: null,
+                    lastQueueIncidentJson: null,
+                    lastAttemptedFailureHeadSha: null,
+                    lastAttemptedFailureSignature: null,
+                }
+                : {}),
+        });
+        const branchOwner = resolveBranchOwnerForStateTransition(newState, options?.pendingRunType);
+        if (branchOwner) {
+            this.db.setBranchOwner(issue.projectId, issue.linearIssueId, branchOwner);
+        }
+        this.feed?.publish({
+            level: "info",
+            kind: "stage",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: newState,
+            status: "reconciled",
+            summary: `Reconciliation: ${issue.factoryState} \u2192 ${newState}`,
+        });
+        if (newState === "awaiting_queue" && issue.factoryState !== "awaiting_queue") {
+            void this.deps.requestMergeQueueAdmission(issue, issue.projectId);
+        }
+        if (options?.pendingRunType) {
+            this.deps.enqueueIssue(issue.projectId, issue.linearIssueId);
+        }
+    }
+    async routeFailedIssue(issue) {
+        if (issue.lastGitHubFailureSource === "queue_eviction") {
+            const pendingRunContext = buildFailureContext(issue);
+            if (isDuplicateRepairAttempt(issue, pendingRunContext)) {
+                this.advanceIdleIssue(issue, "repairing_queue");
+            }
+            else {
+                this.advanceIdleIssue(issue, "repairing_queue", {
+                    pendingRunType: "queue_repair",
+                    ...(pendingRunContext ? { pendingRunContext } : {}),
+                });
+            }
+            return;
+        }
+        if (issue.lastGitHubFailureSource === "branch_ci") {
+            const pendingRunContext = buildFailureContext(issue);
+            if (isDuplicateRepairAttempt(issue, pendingRunContext)) {
+                this.advanceIdleIssue(issue, "repairing_ci");
+            }
+            else {
+                this.advanceIdleIssue(issue, "repairing_ci", {
+                    pendingRunType: "ci_repair",
+                    ...(pendingRunContext ? { pendingRunContext } : {}),
+                });
+            }
+            return;
+        }
+        if (issue.factoryState === "awaiting_queue") {
+            const inferProject = this.config.projects.find((p) => p.id === issue.projectId);
+            const inferProtocol = resolveMergeQueueProtocol(inferProject);
+            let inferred = "branch_ci";
+            const probeSha = issue.lastGitHubFailureHeadSha ?? issue.lastGitHubCiSnapshotHeadSha;
+            if (inferProject?.github?.repoFullName && issue.prNumber && probeSha) {
+                try {
+                    const { stdout } = await execCommand("gh", [
+                        "api",
+                        `repos/${inferProject.github.repoFullName}/commits/${probeSha}/check-runs`,
+                        "--jq", `.check_runs[] | select(.name == "${inferProtocol.evictionCheckName}" and .conclusion == "failure") | .name`,
+                    ], { timeoutMs: 10_000 });
+                    if (stdout.trim().length > 0)
+                        inferred = "queue_eviction";
+                }
+                catch { /* best effort */ }
+            }
+            const inferRunType = inferred === "queue_eviction" ? "queue_repair" : "ci_repair";
+            const inferState = inferred === "queue_eviction" ? "repairing_queue" : "repairing_ci";
+            this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, inferred }, "Inferred failure provenance for awaiting_queue issue");
+            const pendingRunContext = buildFailureContext(issue);
+            this.advanceIdleIssue(issue, inferState, {
+                pendingRunType: inferRunType,
+                ...(pendingRunContext ? { pendingRunContext } : {}),
+            });
+            return;
+        }
+        const pendingRunContext = buildFailureContext(issue);
+        if (isDuplicateRepairAttempt(issue, pendingRunContext)) {
+            this.advanceIdleIssue(issue, "repairing_ci");
+        }
+        else {
+            this.advanceIdleIssue(issue, "repairing_ci", {
+                pendingRunType: "ci_repair",
+                ...(pendingRunContext ? { pendingRunContext } : {}),
+            });
+        }
+    }
+    async reconcileFromGitHub(issue) {
+        const project = this.config.projects.find((p) => p.id === issue.projectId);
+        if (!project?.github?.repoFullName || !issue.prNumber)
+            return;
+        try {
+            const { stdout } = await execCommand("gh", [
+                "pr", "view", String(issue.prNumber),
+                "--repo", project.github.repoFullName,
+                "--json", "state,reviewDecision,mergeable,mergeStateStatus",
+            ], { timeoutMs: 10_000 });
+            const pr = JSON.parse(stdout);
+            if (pr.state === "MERGED") {
+                this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "merged" });
+                this.advanceIdleIssue(issue, "done", { clearFailureProvenance: true });
+                return;
+            }
+            if (pr.reviewDecision === "APPROVED") {
+                this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prReviewState: "approved" });
+                this.advanceIdleIssue(issue, "awaiting_queue", { clearFailureProvenance: true });
+                return;
+            }
+            // Merge conflict detected — dispatch a repair run to rebase the branch.
+            if (pr.mergeable === "CONFLICTING" || pr.mergeStateStatus === "DIRTY") {
+                this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, mergeable: pr.mergeable }, "Reconciliation: PR has merge conflicts, dispatching rebase");
+                this.advanceIdleIssue(issue, "repairing_queue", {
+                    pendingRunType: "queue_repair",
+                    pendingRunContext: {
+                        source: "idle_reconciliation",
+                        failureReason: "merge_conflict_detected",
+                        failureSignature: `conflict:${issue.prNumber}`,
+                    },
+                });
+                this.feed?.publish({
+                    level: "warn",
+                    kind: "github",
+                    issueKey: issue.issueKey,
+                    projectId: issue.projectId,
+                    stage: "repairing_queue",
+                    status: "conflict_detected",
+                    summary: `PR #${issue.prNumber} has merge conflicts with main, dispatching rebase`,
+                });
+            }
+        }
+        catch (error) {
+            this.logger.debug({ issueKey: issue.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to query GitHub PR state during reconciliation");
+        }
+    }
+}

package/dist/linear-session-sync.js

@@ -0,0 +1,143 @@
+import { buildAgentSessionPlanForIssue } from "./agent-session-plan.js";
+import { buildAgentSessionExternalUrls } from "./agent-session-presentation.js";
+const PROGRESS_THROTTLE_MS = 5_000;
+export class LinearSessionSync {
+    config;
+    db;
+    linearProvider;
+    logger;
+    feed;
+    progressThrottle = new Map();
+    constructor(config, db, linearProvider, logger, feed) {
+        this.config = config;
+        this.db = db;
+        this.linearProvider = linearProvider;
+        this.logger = logger;
+        this.feed = feed;
+    }
+    async emitActivity(issue, content, options) {
+        if (!issue.agentSessionId)
+            return;
+        try {
+            const linear = await this.linearProvider.forProject(issue.projectId);
+            if (!linear)
+                return;
+            const allowEphemeral = content.type === "thought" || content.type === "action";
+            await linear.createAgentActivity({
+                agentSessionId: issue.agentSessionId,
+                content,
+                ...(options?.ephemeral && allowEphemeral ? { ephemeral: true } : {}),
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger.warn({ issueKey: issue.issueKey, type: content.type, error: msg }, "Failed to emit Linear activity");
+            this.feed?.publish({
+                level: "warn",
+                kind: "linear",
+                issueKey: issue.issueKey,
+                projectId: issue.projectId,
+                status: "linear_error",
+                summary: `Linear activity failed: ${msg}`,
+            });
+        }
+    }
+    async syncSession(issue, options) {
+        if (!issue.agentSessionId)
+            return;
+        try {
+            const linear = await this.linearProvider.forProject(issue.projectId);
+            if (!linear?.updateAgentSession)
+                return;
+            const externalUrls = buildAgentSessionExternalUrls(this.config, {
+                ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
+                ...(issue.prUrl ? { prUrl: issue.prUrl } : {}),
+            });
+            await linear.updateAgentSession({
+                agentSessionId: issue.agentSessionId,
+                plan: buildAgentSessionPlanForIssue(issue, options),
+                ...(externalUrls ? { externalUrls } : {}),
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger.warn({ issueKey: issue.issueKey, error: msg }, "Failed to update Linear plan");
+        }
+    }
+    async syncCodexPlan(issue, params) {
+        if (!issue.agentSessionId)
+            return;
+        const plan = params.plan;
+        if (!Array.isArray(plan))
+            return;
+        const STATUS_MAP = {
+            pending: "pending",
+            inProgress: "inProgress",
+            completed: "completed",
+        };
+        const steps = plan.map((entry) => {
+            const e = entry;
+            const step = typeof e.step === "string" ? e.step : String(e.step ?? "");
+            const status = typeof e.status === "string" ? (STATUS_MAP[e.status] ?? "pending") : "pending";
+            return { content: step, status };
+        });
+        const fullPlan = [
+            { content: "Prepare workspace", status: "completed" },
+            ...steps,
+            { content: "Merge", status: "pending" },
+        ];
+        try {
+            const linear = await this.linearProvider.forProject(issue.projectId);
+            if (!linear?.updateAgentSession)
+                return;
+            await linear.updateAgentSession({
+                agentSessionId: issue.agentSessionId,
+                plan: fullPlan,
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger.warn({ issueKey: issue.issueKey, error: msg }, "Failed to sync codex plan to Linear");
+        }
+    }
+    maybeEmitProgress(notification, run) {
+        const activity = resolveProgressActivity(notification);
+        if (!activity)
+            return;
+        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);
+        const issue = this.db.getIssue(run.projectId, run.linearIssueId);
+        if (issue) {
+            void this.emitActivity(issue, activity, { ephemeral: true });
+        }
+    }
+    clearProgress(runId) {
+        this.progressThrottle.delete(runId);
+    }
+}
+function resolveProgressActivity(notification) {
+    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) ? cmd.join(" ") : typeof cmd === "string" ? cmd : undefined;
+            return { type: "action", action: "Running", parameter: cmdStr?.slice(0, 120) ?? "command" };
+        }
+        if (type === "mcpToolCall") {
+            const server = typeof item.server === "string" ? item.server : "";
+            const tool = typeof item.tool === "string" ? item.tool : "";
+            return { type: "action", action: "Using", parameter: `${server}/${tool}` };
+        }
+        if (type === "dynamicToolCall") {
+            const tool = typeof item.tool === "string" ? item.tool : "tool";
+            return { type: "action", action: "Using", parameter: tool };
+        }
+    }
+    return undefined;
+}

package/dist/queue-health-monitor.js

@@ -0,0 +1,131 @@
+import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
+import { execCommand } from "./utils.js";
+const QUEUE_HEALTH_GRACE_MS = 120_000;
+const QUEUE_HEALTH_PROBE_FAILURE_COOLDOWN_MS = 300_000;
+function isDuplicateProbe(issue, context) {
+    const signature = typeof context?.failureSignature === "string" ? context.failureSignature : undefined;
+    const headSha = typeof context?.failureHeadSha === "string" ? context.failureHeadSha : undefined;
+    if (!signature)
+        return false;
+    return issue.lastAttemptedFailureSignature === signature
+        && (headSha === undefined || issue.lastAttemptedFailureHeadSha === headSha);
+}
+export class QueueHealthMonitor {
+    db;
+    config;
+    advancer;
+    logger;
+    feed;
+    probeFailureFeedTimes = new Map();
+    constructor(db, config, advancer, logger, feed) {
+        this.db = db;
+        this.config = config;
+        this.advancer = advancer;
+        this.logger = logger;
+        this.feed = feed;
+    }
+    async reconcile() {
+        for (const issue of this.db.listAwaitingQueueIssues()) {
+            await this.probeQueuedIssue(issue);
+        }
+    }
+    async probeQueuedIssue(issue) {
+        if (!issue.prNumber)
+            return;
+        const project = this.config.projects.find((p) => p.id === issue.projectId);
+        if (!project?.github?.repoFullName)
+            return;
+        const age = Date.now() - Date.parse(issue.updatedAt);
+        if (age < QUEUE_HEALTH_GRACE_MS)
+            return;
+        const protocol = resolveMergeQueueProtocol(project);
+        let pr;
+        try {
+            const { stdout } = await execCommand("gh", [
+                "pr", "view", String(issue.prNumber),
+                "--repo", project.github.repoFullName,
+                "--json", "state,mergeable,mergeStateStatus,headRefOid,labels",
+            ], { timeoutMs: 10_000 });
+            pr = JSON.parse(stdout);
+        }
+        catch (error) {
+            this.logger.debug({ issueKey: issue.issueKey, prNumber: issue.prNumber, error: error instanceof Error ? error.message : String(error) }, "Queue health: failed to probe GitHub PR state");
+            const issueKey = `${issue.projectId}::${issue.linearIssueId}`;
+            const lastFeedAt = this.probeFailureFeedTimes.get(issueKey) ?? 0;
+            if (Date.now() - lastFeedAt >= QUEUE_HEALTH_PROBE_FAILURE_COOLDOWN_MS) {
+                this.probeFailureFeedTimes.set(issueKey, Date.now());
+                this.feed?.publish({
+                    level: "info",
+                    kind: "github",
+                    issueKey: issue.issueKey,
+                    projectId: issue.projectId,
+                    stage: "awaiting_queue",
+                    status: "queue_health_probe_failed",
+                    summary: `Queue health: failed to probe PR #${issue.prNumber}`,
+                });
+            }
+            return;
+        }
+        this.probeFailureFeedTimes.delete(`${issue.projectId}::${issue.linearIssueId}`);
+        if (pr.state === "MERGED") {
+            this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "merged" });
+            this.advancer.advanceIdleIssue(issue, "done", { clearFailureProvenance: true });
+            return;
+        }
+        if (pr.state !== "OPEN")
+            return;
+        const hasQueueLabel = pr.labels?.some((l) => l.name === protocol.admissionLabel) ?? false;
+        if (!hasQueueLabel)
+            return;
+        const isDirty = pr.mergeStateStatus === "DIRTY" || pr.mergeable === "CONFLICTING";
+        let hasEvictionCheckRun = false;
+        if (!isDirty) {
+            try {
+                const { stdout: checksOut } = await execCommand("gh", [
+                    "api", `repos/${project.github.repoFullName}/commits/${pr.headRefOid}/check-runs`,
+                    "--jq", `.check_runs[] | select(.name == "${protocol.evictionCheckName}" and .conclusion == "failure") | .name`,
+                ], { timeoutMs: 10_000 });
+                hasEvictionCheckRun = checksOut.trim().length > 0;
+            }
+            catch {
+                // Best-effort check.
+            }
+        }
+        if (isDirty || hasEvictionCheckRun) {
+            const headRefOid = pr.headRefOid ?? "unknown";
+            const reason = hasEvictionCheckRun ? "queue_eviction_missed" : "preemptive_conflict";
+            const signature = `preemptive_queue_conflict:${headRefOid}`;
+            const pendingRunContext = {
+                source: "queue_health_monitor",
+                failureReason: reason,
+                failureHeadSha: headRefOid,
+                failureSignature: signature,
+            };
+            if (isDuplicateProbe(issue, pendingRunContext)) {
+                return;
+            }
+            this.db.upsertIssue({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                lastAttemptedFailureHeadSha: headRefOid,
+                lastAttemptedFailureSignature: signature,
+            });
+            this.advancer.advanceIdleIssue(issue, "repairing_queue", {
+                pendingRunType: "queue_repair",
+                pendingRunContext,
+            });
+            this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, headRefOid, reason }, "Queue health: queue issue detected, dispatching repair");
+            this.feed?.publish({
+                level: "warn",
+                kind: "github",
+                issueKey: issue.issueKey,
+                projectId: issue.projectId,
+                stage: "repairing_queue",
+                status: hasEvictionCheckRun ? "queue_health_eviction_detected" : "queue_health_conflict_detected",
+                summary: hasEvictionCheckRun
+                    ? `Queue health: missed eviction detected on PR #${issue.prNumber}, dispatching repair`
+                    : `Queue health: merge conflict detected on PR #${issue.prNumber}, dispatching preemptive repair`,
+            });
+        }
+    }
+}

package/dist/run-orchestrator.js

@@ -1,14 +1,10 @@
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { ACTIVE_RUN_STATES, TERMINAL_STATES } from "./factory-state.js";
-import { parseGitHubFailureContext } from "./github-failure-context.js";
 import { buildHookEnv, runProjectHook } from "./hook-runner.js";
-import { buildAgentSessionPlanForIssue, } from "./agent-session-plan.js";
 import { buildStageReport, countEventMethods, extractTurnId, resolveRunCompletionStatus, summarizeCurrentThread, } from "./run-reporting.js";
 import { buildRunCompletedActivity, buildRunFailureActivity, buildRunStartedActivity, } from "./linear-session-reporting.js";
 import { requestMergeQueueAdmission, resolveMergeQueueProtocol, } from "./merge-queue-protocol.js";
-import { parseStoredQueueRepairContext } from "./merge-queue-incident.js";
-import { buildAgentSessionExternalUrls } from "./agent-session-presentation.js";
 import { WorktreeManager } from "./worktree-manager.js";
 import { resolveAuthoritativeLinearStopState } from "./linear-workflow.js";
 import { execCommand } from "./utils.js";
@@ -17,12 +13,9 @@ const DEFAULT_QUEUE_REPAIR_BUDGET = 3;
 const DEFAULT_REVIEW_FIX_BUDGET = 3;
 const DEFAULT_ZOMBIE_RECOVERY_BUDGET = 5;
 const ZOMBIE_RECOVERY_BASE_DELAY_MS = 15_000; // 15s, 30s, 60s, 120s, 240s
-// Queue health monitor: wait before probing a freshly-queued PR.
-// TODO: replace updatedAt with a true factory_state_changed_at timestamp —
-// updatedAt can reset on unrelated row mutations (e.g. webhook metadata).
-const QUEUE_HEALTH_GRACE_MS = 120_000;
-// Suppress repeated probe-failure feed events — at most one per issue per window.
-const QUEUE_HEALTH_PROBE_FAILURE_COOLDOWN_MS = 300_000; // 5 minutes
+import { QueueHealthMonitor } from "./queue-health-monitor.js";
+import { IdleIssueReconciler, resolveBranchOwnerForStateTransition } from "./idle-reconciliation.js";
+import { LinearSessionSync } from "./linear-session-sync.js";
 function slugify(value) {
     return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
 }
@@ -93,7 +86,6 @@ function buildRunPrompt(issue, runType, repoPath, context) {
     }
     return lines.join("\n");
 }
-const PROGRESS_THROTTLE_MS = 10_000;
 export class RunOrchestrator {
     config;
     db;
@@ -103,9 +95,10 @@ export class RunOrchestrator {
     logger;
     feed;
     worktreeManager;
-    progressThrottle = new Map();
     /** Tracks last probe-failure feed event per issue to avoid spamming the operator feed. */
-    probeFailureFeedTimes = new Map();
+    queueHealthMonitor;
+    idleReconciler;
+    linearSync;
     activeThreadId;
     botIdentity;
     constructor(config, db, codex, linearProvider, enqueueIssue, logger, feed) {
@@ -117,6 +110,14 @@ export class RunOrchestrator {
         this.logger = logger;
         this.feed = feed;
         this.worktreeManager = new WorktreeManager(config);
+        this.linearSync = new LinearSessionSync(config, db, linearProvider, logger, feed);
+        this.idleReconciler = new IdleIssueReconciler(db, config, {
+            requestMergeQueueAdmission: (issue, projectId) => this.requestMergeQueueAdmission(issue, projectId),
+            enqueueIssue: (projectId, issueId) => this.enqueueIssue(projectId, issueId),
+        }, logger, feed);
+        this.queueHealthMonitor = new QueueHealthMonitor(db, config, {
+            advanceIdleIssue: (issue, newState, options) => this.idleReconciler.advanceIdleIssue(issue, newState, options),
+        }, logger, feed);
     }
     // ─── Run ────────────────────────────────────────────────────────
     async run(item) {
@@ -219,11 +220,17 @@ export class RunOrchestrator {
         try {
             // Ensure worktree
             await this.worktreeManager.ensureIssueWorktree(project.repoPath, project.worktreeRoot, worktreePath, branchName, { allowExistingOutsideRoot: issue.branchName !== undefined });
-            // Set bot git identity when GitHub App is configured
+            // Set bot git identity and push credentials when GitHub App is configured.
+            // This ensures commits are authored by and pushes are authenticated as
+            // patchrelay[bot], not the system user.
             if (this.botIdentity) {
                 const gitBin = this.config.runner.gitBin;
                 await execCommand(gitBin, ["-C", worktreePath, "config", "user.name", this.botIdentity.name], { timeoutMs: 5_000 });
                 await execCommand(gitBin, ["-C", worktreePath, "config", "user.email", this.botIdentity.email], { timeoutMs: 5_000 });
+                // Override credential helper to use the App installation token for git push.
+                // The helper script reads the token file and returns it as the password.
+                const credentialHelper = `!f() { echo "username=x-access-token"; echo "password=$(cat ${this.botIdentity.tokenFile})"; }; f`;
+                await execCommand(gitBin, ["-C", worktreePath, "config", "credential.helper", credentialHelper], { timeoutMs: 5_000 });
             }
             // Freshen the worktree: fetch + rebase onto latest base branch.
             // This prevents branch contamination when local main has drifted
@@ -279,8 +286,8 @@ export class RunOrchestrator {
             });
             this.logger.error({ issueKey: issue.issueKey, runType, error: message }, `Failed to launch ${runType} run`);
             const failedIssue = this.db.getIssue(item.projectId, item.issueId) ?? issue;
-            void this.emitLinearActivity(failedIssue, buildRunFailureActivity(runType, `Failed to start ${lowerCaseFirst(message)}`));
-            void this.syncLinearSession(failedIssue, { activeRunType: runType });
+            void this.linearSync.emitActivity(failedIssue, buildRunFailureActivity(runType, `Failed to start ${lowerCaseFirst(message)}`));
+            void this.linearSync.syncSession(failedIssue, { activeRunType: runType });
             throw error;
         }
         this.db.updateRunThread(run.id, { threadId, turnId });
@@ -296,8 +303,8 @@ export class RunOrchestrator {
         this.logger.info({ issueKey: issue.issueKey, runType, threadId, turnId }, `Started ${runType} run`);
         // Emit Linear activity + plan
         const freshIssue = this.db.getIssue(item.projectId, item.issueId) ?? issue;
-        void this.emitLinearActivity(freshIssue, buildRunStartedActivity(runType));
-        void this.syncLinearSession(freshIssue, { activeRunType: runType });
+        void this.linearSync.emitActivity(freshIssue, buildRunStartedActivity(runType));
+        void this.linearSync.syncSession(freshIssue, { activeRunType: runType });
     }
     // ─── Pre-run branch freshening ────────────────────────────────────
     /**
@@ -378,12 +385,12 @@ export class RunOrchestrator {
             });
         }
         // Emit ephemeral progress activity to Linear for notable in-flight events
-        this.maybeEmitProgressActivity(notification, run);
+        this.linearSync.maybeEmitProgress(notification, run);
         // Sync codex plan to Linear session when it updates
         if (notification.method === "turn/plan/updated") {
             const issue = this.db.getIssue(run.projectId, run.linearIssueId);
             if (issue) {
-                void this.syncLinearSessionWithCodexPlan(issue, notification.params);
+                void this.linearSync.syncCodexPlan(issue, notification.params);
             }
         }
         if (notification.method !== "turn/completed")
@@ -417,9 +424,9 @@ export class RunOrchestrator {
                 summary: `Turn failed for ${run.runType}`,
             });
             const failedIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
-            void this.emitLinearActivity(failedIssue, buildRunFailureActivity(run.runType));
-            void this.syncLinearSession(failedIssue, { activeRunType: run.runType });
-            this.progressThrottle.delete(run.id);
+            void this.linearSync.emitActivity(failedIssue, buildRunFailureActivity(run.runType));
+            void this.linearSync.syncSession(failedIssue, { activeRunType: run.runType });
+            this.linearSync.clearProgress(run.id);
             this.activeThreadId = undefined;
             return;
         }
@@ -442,9 +449,9 @@ export class RunOrchestrator {
                 status: "branch_not_advanced",
                 summary: verifiedRepairError,
             });
-            void this.emitLinearActivity(heldIssue, buildRunFailureActivity(run.runType, verifiedRepairError));
-            void this.syncLinearSession(heldIssue, { activeRunType: run.runType });
-            this.progressThrottle.delete(run.id);
+            void this.linearSync.emitActivity(heldIssue, buildRunFailureActivity(run.runType, verifiedRepairError));
+            void this.linearSync.syncSession(heldIssue, { activeRunType: run.runType });
+            this.linearSync.clearProgress(run.id);
             this.activeThreadId = undefined;
             return;
         }
@@ -499,54 +506,16 @@ export class RunOrchestrator {
         // Emit Linear completion activity + plan
         const updatedIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
         const completionSummary = report.assistantMessages.at(-1)?.slice(0, 300) ?? `${run.runType} completed.`;
-        void this.emitLinearActivity(updatedIssue, buildRunCompletedActivity({
+        void this.linearSync.emitActivity(updatedIssue, buildRunCompletedActivity({
             runType: run.runType,
             completionSummary,
             postRunState: updatedIssue.factoryState,
             ...(updatedIssue.prNumber !== undefined ? { prNumber: updatedIssue.prNumber } : {}),
         }));
-        void this.syncLinearSession(updatedIssue);
-        this.progressThrottle.delete(run.id);
+        void this.linearSync.syncSession(updatedIssue);
+        this.linearSync.clearProgress(run.id);
         this.activeThreadId = undefined;
     }
-    // ─── In-flight progress ──────────────────────────────────────────
-    maybeEmitProgressActivity(notification, run) {
-        const activity = this.resolveProgressActivity(notification);
-        if (!activity)
-            return;
-        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);
-        const issue = this.db.getIssue(run.projectId, run.linearIssueId);
-        if (issue) {
-            void this.emitLinearActivity(issue, activity, { ephemeral: true });
-        }
-    }
-    resolveProgressActivity(notification) {
-        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) ? cmd.join(" ") : typeof cmd === "string" ? cmd : undefined;
-                return { type: "action", action: "Running", parameter: cmdStr?.slice(0, 120) ?? "command" };
-            }
-            if (type === "mcpToolCall") {
-                const server = typeof item.server === "string" ? item.server : "";
-                const tool = typeof item.tool === "string" ? item.tool : "";
-                return { type: "action", action: "Using", parameter: `${server}/${tool}` };
-            }
-            if (type === "dynamicToolCall") {
-                const tool = typeof item.tool === "string" ? item.tool : "tool";
-                return { type: "action", action: "Using", parameter: tool };
-            }
-        }
-        return undefined;
-    }
     // ─── Active status for query ──────────────────────────────────────
     async getActiveRunStatus(issueKey) {
         const issue = this.db.getIssueByKey(issueKey);
@@ -570,309 +539,14 @@ export class RunOrchestrator {
         }
         // Preemptively detect stuck merge-queue PRs (conflicts visible on
         // GitHub) and dispatch queue_repair before the Steward evicts.
-        await this.reconcileQueueHealth();
+        await this.queueHealthMonitor.reconcile();
         // Advance issues stuck in pr_open whose stored PR metadata already
         // shows they should transition (e.g. approved PR, missed webhook).
-        await this.reconcileIdleIssues();
-    }
-    // ─── Queue Health Monitor ──────────────────────────────────────────
-    async reconcileQueueHealth() {
-        for (const issue of this.db.listAwaitingQueueIssues()) {
-            await this.probeQueuedIssue(issue);
-        }
-    }
-    async probeQueuedIssue(issue) {
-        if (!issue.prNumber)
-            return;
-        const project = this.config.projects.find((p) => p.id === issue.projectId);
-        if (!project?.github?.repoFullName)
-            return;
-        // Grace period — don't probe PRs that just entered the queue.
-        const age = Date.now() - Date.parse(issue.updatedAt);
-        if (age < QUEUE_HEALTH_GRACE_MS)
-            return;
-        const protocol = resolveMergeQueueProtocol(project);
-        let pr;
-        try {
-            const { stdout } = await execCommand("gh", [
-                "pr", "view", String(issue.prNumber),
-                "--repo", project.github.repoFullName,
-                "--json", "state,mergeable,mergeStateStatus,headRefOid,labels",
-            ], { timeoutMs: 10_000 });
-            pr = JSON.parse(stdout);
-        }
-        catch (error) {
-            this.logger.debug({ issueKey: issue.issueKey, prNumber: issue.prNumber, error: error instanceof Error ? error.message : String(error) }, "Queue health: failed to probe GitHub PR state");
-            // Throttle feed events — at most one per issue per cooldown window.
-            const issueKey = `${issue.projectId}::${issue.linearIssueId}`;
-            const lastFeedAt = this.probeFailureFeedTimes.get(issueKey) ?? 0;
-            if (Date.now() - lastFeedAt >= QUEUE_HEALTH_PROBE_FAILURE_COOLDOWN_MS) {
-                this.probeFailureFeedTimes.set(issueKey, Date.now());
-                this.feed?.publish({
-                    level: "info",
-                    kind: "github",
-                    issueKey: issue.issueKey,
-                    projectId: issue.projectId,
-                    stage: "awaiting_queue",
-                    status: "queue_health_probe_failed",
-                    summary: `Queue health: failed to probe PR #${issue.prNumber}`,
-                });
-            }
-            return;
-        }
-        // Successful probe — clear any probe-failure throttle for this issue.
-        this.probeFailureFeedTimes.delete(`${issue.projectId}::${issue.linearIssueId}`);
-        // Missed merge webhook — advance to done.
-        if (pr.state === "MERGED") {
-            this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "merged" });
-            this.advanceIdleIssue(issue, "done", { clearFailureProvenance: true });
-            return;
-        }
-        // Non-open PRs (closed, draft) — don't enter repair logic.
-        if (pr.state !== "OPEN")
-            return;
-        // Verify admission label is still present — if the Steward removed it
-        // (eviction, dequeue) but PatchRelay missed the webhook, we should not
-        // treat a DIRTY PR as a queue-health problem.
-        const hasQueueLabel = pr.labels?.some((l) => l.name === protocol.admissionLabel) ?? false;
-        if (!hasQueueLabel)
-            return;
-        // Detect queue issues: either GitHub reports DIRTY, or the steward
-        // eviction check run failed (webhook may have been missed).
-        const isDirty = pr.mergeStateStatus === "DIRTY" || pr.mergeable === "CONFLICTING";
-        let hasEvictionCheckRun = false;
-        if (!isDirty) {
-            // Check for missed eviction webhook by looking for the steward's
-            // check run on the PR head.
-            try {
-                const { stdout: checksOut } = await execCommand("gh", [
-                    "api", `repos/${project.github.repoFullName}/commits/${pr.headRefOid}/check-runs`,
-                    "--jq", `.check_runs[] | select(.name == "${protocol.evictionCheckName}" and .conclusion == "failure") | .name`,
-                ], { timeoutMs: 10_000 });
-                hasEvictionCheckRun = checksOut.trim().length > 0;
-            }
-            catch {
-                // Best-effort check.
-            }
-        }
-        if (isDirty || hasEvictionCheckRun) {
-            const headRefOid = pr.headRefOid ?? "unknown";
-            const reason = hasEvictionCheckRun ? "queue_eviction_missed" : "preemptive_conflict";
-            const signature = `preemptive_queue_conflict:${headRefOid}`;
-            const pendingRunContext = {
-                source: "queue_health_monitor",
-                failureReason: reason,
-                failureHeadSha: headRefOid,
-                failureSignature: signature,
-            };
-            if (isDuplicateRepairAttempt(issue, pendingRunContext)) {
-                return;
-            }
-            this.db.upsertIssue({
-                projectId: issue.projectId,
-                linearIssueId: issue.linearIssueId,
-                lastAttemptedFailureHeadSha: headRefOid,
-                lastAttemptedFailureSignature: signature,
-            });
-            this.advanceIdleIssue(issue, "repairing_queue", {
-                pendingRunType: "queue_repair",
-                pendingRunContext,
-            });
-            this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, headRefOid, reason }, "Queue health: queue issue detected, dispatching repair");
-            this.feed?.publish({
-                level: "warn",
-                kind: "github",
-                issueKey: issue.issueKey,
-                projectId: issue.projectId,
-                stage: "repairing_queue",
-                status: hasEvictionCheckRun ? "queue_health_eviction_detected" : "queue_health_conflict_detected",
-                summary: hasEvictionCheckRun
-                    ? `Queue health: missed eviction detected on PR #${issue.prNumber}, dispatching repair`
-                    : `Queue health: merge conflict detected on PR #${issue.prNumber}, dispatching preemptive repair`,
-            });
-        }
-    }
-    async reconcileIdleIssues() {
-        for (const issue of this.db.listIdleNonTerminalIssues()) {
-            // PR already merged — advance to done regardless of current state
-            if (issue.prState === "merged") {
-                this.advanceIdleIssue(issue, "done", { clearFailureProvenance: true });
-                continue;
-            }
-            // Review approved + checks not failed — advance to awaiting_queue
-            if (issue.prReviewState === "approved" && issue.prCheckStatus !== "failed") {
-                if (issue.factoryState !== "awaiting_queue" || issue.branchOwner !== "merge_steward") {
-                    this.advanceIdleIssue(issue, "awaiting_queue", { clearFailureProvenance: true });
-                }
-                else if (!issue.queueLabelApplied) {
-                    // Retry failed label application
-                    await this.requestMergeQueueAdmission(issue, issue.projectId);
-                }
-                continue;
-            }
-            // Checks failed + idle — route based on durable GitHub failure provenance.
-            if (issue.prCheckStatus === "failed") {
-                if (issue.lastGitHubFailureSource === "queue_eviction") {
-                    const pendingRunContext = buildFailureContext(issue);
-                    if (isDuplicateRepairAttempt(issue, pendingRunContext)) {
-                        this.advanceIdleIssue(issue, "repairing_queue");
-                    }
-                    else {
-                        this.advanceIdleIssue(issue, "repairing_queue", {
-                            pendingRunType: "queue_repair",
-                            ...(pendingRunContext ? { pendingRunContext } : {}),
-                        });
-                    }
-                    continue;
-                }
-                if (issue.lastGitHubFailureSource === "branch_ci") {
-                    const pendingRunContext = buildFailureContext(issue);
-                    if (isDuplicateRepairAttempt(issue, pendingRunContext)) {
-                        this.advanceIdleIssue(issue, "repairing_ci");
-                    }
-                    else {
-                        this.advanceIdleIssue(issue, "repairing_ci", {
-                            pendingRunType: "ci_repair",
-                            ...(pendingRunContext ? { pendingRunContext } : {}),
-                        });
-                    }
-                    continue;
-                }
-                if (issue.factoryState === "awaiting_queue") {
-                    // Infer provenance: check if steward eviction check run exists on the PR
-                    const inferProject = this.config.projects.find((p) => p.id === issue.projectId);
-                    const inferProtocol = resolveMergeQueueProtocol(inferProject);
-                    let inferred = "branch_ci";
-                    const probeSha = issue.lastGitHubFailureHeadSha ?? issue.lastGitHubCiSnapshotHeadSha;
-                    if (inferProject?.github?.repoFullName && issue.prNumber && probeSha) {
-                        try {
-                            const { stdout } = await execCommand("gh", [
-                                "api",
-                                `repos/${inferProject.github.repoFullName}/commits/${probeSha}/check-runs`,
-                                "--jq", `.check_runs[] | select(.name == "${inferProtocol.evictionCheckName}" and .conclusion == "failure") | .name`,
-                            ], { timeoutMs: 10_000 });
-                            if (stdout.trim().length > 0)
-                                inferred = "queue_eviction";
-                        }
-                        catch { /* best effort */ }
-                    }
-                    const inferRunType = inferred === "queue_eviction" ? "queue_repair" : "ci_repair";
-                    const inferState = inferred === "queue_eviction" ? "repairing_queue" : "repairing_ci";
-                    this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, inferred }, "Inferred failure provenance for awaiting_queue issue");
-                    const pendingRunContext = buildFailureContext(issue);
-                    this.advanceIdleIssue(issue, inferState, {
-                        pendingRunType: inferRunType,
-                        ...(pendingRunContext ? { pendingRunContext } : {}),
-                    });
-                    continue;
-                }
-                const pendingRunContext = buildFailureContext(issue);
-                if (isDuplicateRepairAttempt(issue, pendingRunContext)) {
-                    this.advanceIdleIssue(issue, "repairing_ci");
-                }
-                else {
-                    this.advanceIdleIssue(issue, "repairing_ci", {
-                        pendingRunType: "ci_repair",
-                        ...(pendingRunContext ? { pendingRunContext } : {}),
-                    });
-                }
-                continue;
-            }
-            // For pr_open issues with no review decision, check GitHub for stale metadata
-            if (issue.factoryState === "pr_open" && !issue.prReviewState) {
-                await this.reconcileFromGitHub(issue);
-            }
-        }
-        // Unblock delegated issues whose blockers have been resolved.
-        for (const issue of this.db.listBlockedDelegatedIssues()) {
-            const unresolved = this.db.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
-            if (unresolved === 0) {
-                this.db.upsertIssue({
-                    projectId: issue.projectId,
-                    linearIssueId: issue.linearIssueId,
-                    pendingRunType: "implementation",
-                });
-                this.enqueueIssue(issue.projectId, issue.linearIssueId);
-            }
-        }
-    }
-    async reconcileFromGitHub(issue) {
-        const project = this.config.projects.find((p) => p.id === issue.projectId);
-        if (!project?.github?.repoFullName || !issue.prNumber)
-            return;
-        try {
-            const { stdout } = await execCommand("gh", [
-                "pr", "view", String(issue.prNumber),
-                "--repo", project.github.repoFullName,
-                "--json", "state,reviewDecision",
-            ], { timeoutMs: 10_000 });
-            const pr = JSON.parse(stdout);
-            if (pr.state === "MERGED") {
-                this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "merged" });
-                this.advanceIdleIssue(issue, "done", { clearFailureProvenance: true });
-            }
-            else if (pr.reviewDecision === "APPROVED") {
-                this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prReviewState: "approved" });
-                this.advanceIdleIssue(issue, "awaiting_queue", { clearFailureProvenance: true });
-            }
-        }
-        catch (error) {
-            this.logger.debug({ issueKey: issue.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to query GitHub PR state during reconciliation");
-        }
+        await this.idleReconciler.reconcile();
     }
+    // advanceIdleIssue is now on IdleIssueReconciler — delegate for internal callers
     advanceIdleIssue(issue, newState, options) {
-        if (issue.factoryState === newState && !options?.pendingRunType && !options?.clearFailureProvenance) {
-            return;
-        }
-        this.logger.info({ issueKey: issue.issueKey, from: issue.factoryState, to: newState, pendingRunType: options?.pendingRunType }, "Reconciliation: advancing idle issue");
-        // Reset queueLabelApplied when entering or leaving awaiting_queue so
-        // the retry loop re-applies the label on each queue cycle.
-        const resetQueueLabel = newState === "awaiting_queue" || issue.factoryState === "awaiting_queue";
-        this.db.upsertIssue({
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            factoryState: newState,
-            ...(options?.pendingRunType ? { pendingRunType: options.pendingRunType } : {}),
-            ...(options?.pendingRunType
-                ? {
-                    pendingRunContextJson: options.pendingRunContext ? JSON.stringify(options.pendingRunContext) : null,
-                }
-                : {}),
-            ...(resetQueueLabel ? { queueLabelApplied: false } : {}),
-            ...(options?.clearFailureProvenance
-                ? {
-                    lastGitHubFailureSource: null,
-                    lastGitHubFailureHeadSha: null,
-                    lastGitHubFailureSignature: null,
-                    lastGitHubFailureCheckName: null,
-                    lastGitHubFailureCheckUrl: null,
-                    lastGitHubFailureContextJson: null,
-                    lastGitHubFailureAt: null,
-                    lastQueueIncidentJson: null,
-                    lastAttemptedFailureHeadSha: null,
-                    lastAttemptedFailureSignature: null,
-                }
-                : {}),
-        });
-        const branchOwner = this.resolveBranchOwnerForStateTransition(newState, options?.pendingRunType);
-        if (branchOwner) {
-            this.db.setBranchOwner(issue.projectId, issue.linearIssueId, branchOwner);
-        }
-        this.feed?.publish({
-            level: "info",
-            kind: "stage",
-            issueKey: issue.issueKey,
-            projectId: issue.projectId,
-            stage: newState,
-            status: "reconciled",
-            summary: `Reconciliation: ${issue.factoryState} \u2192 ${newState}`,
-        });
-        if (newState === "awaiting_queue" && issue.factoryState !== "awaiting_queue") {
-            this.requestMergeQueueAdmission(issue, issue.projectId);
-        }
-        if (options?.pendingRunType) {
-            this.enqueueIssue(issue.projectId, issue.linearIssueId);
-        }
+        this.idleReconciler.advanceIdleIssue(issue, newState, options);
     }
     /**
      * After a zombie/stale run is cleared, decide whether to re-enqueue
@@ -1036,9 +710,9 @@ export class RunOrchestrator {
                 });
             }
             else {
-                void this.emitLinearActivity(failedIssue, buildRunFailureActivity(run.runType, "The Codex turn was interrupted."));
+                void this.linearSync.emitActivity(failedIssue, buildRunFailureActivity(run.runType, "The Codex turn was interrupted."));
             }
-            void this.syncLinearSession(failedIssue, { activeRunType: run.runType });
+            void this.linearSync.syncSession(failedIssue, { activeRunType: run.runType });
             return;
         }
         // Handle completed turn discovered during reconciliation
@@ -1135,11 +809,11 @@ export class RunOrchestrator {
             summary: `Escalated: ${reason}`,
         });
         const escalatedIssue = this.db.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
-        void this.emitLinearActivity(escalatedIssue, {
+        void this.linearSync.emitActivity(escalatedIssue, {
             type: "error",
             body: `PatchRelay needs human help to continue.\n\n${reason}`,
         });
-        void this.syncLinearSession(escalatedIssue);
+        void this.linearSync.syncSession(escalatedIssue);
     }
     /** Add the merge queue admission label for external-queue projects (best-effort). */
     async requestMergeQueueAdmission(issue, projectId) {
@@ -1171,13 +845,7 @@ export class RunOrchestrator {
         });
     }
     resolveBranchOwnerForStateTransition(newState, pendingRunType) {
-        if (pendingRunType)
-            return "patchrelay";
-        if (newState === "awaiting_queue")
-            return "merge_steward";
-        if (newState === "repairing_ci" || newState === "repairing_queue")
-            return "patchrelay";
-        return undefined;
+        return resolveBranchOwnerForStateTransition(newState, pendingRunType);
     }
     async verifyReactiveRunAdvancedBranch(run, issue) {
         if (run.runType !== "ci_repair" && run.runType !== "queue_repair") {
@@ -1214,93 +882,6 @@ export class RunOrchestrator {
             return undefined;
         }
     }
-    async emitLinearActivity(issue, content, options) {
-        if (!issue.agentSessionId)
-            return;
-        try {
-            const linear = await this.linearProvider.forProject(issue.projectId);
-            if (!linear)
-                return;
-            const allowEphemeral = content.type === "thought" || content.type === "action";
-            await linear.createAgentActivity({
-                agentSessionId: issue.agentSessionId,
-                content,
-                ...(options?.ephemeral && allowEphemeral ? { ephemeral: true } : {}),
-            });
-        }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            this.logger.warn({ issueKey: issue.issueKey, type: content.type, error: msg }, "Failed to emit Linear activity");
-            this.feed?.publish({
-                level: "warn",
-                kind: "linear",
-                issueKey: issue.issueKey,
-                projectId: issue.projectId,
-                status: "linear_error",
-                summary: `Linear activity failed: ${msg}`,
-            });
-        }
-    }
-    async syncLinearSession(issue, options) {
-        if (!issue.agentSessionId)
-            return;
-        try {
-            const linear = await this.linearProvider.forProject(issue.projectId);
-            if (!linear?.updateAgentSession)
-                return;
-            const externalUrls = buildAgentSessionExternalUrls(this.config, {
-                ...(issue.issueKey ? { issueKey: issue.issueKey } : {}),
-                ...(issue.prUrl ? { prUrl: issue.prUrl } : {}),
-            });
-            await linear.updateAgentSession({
-                agentSessionId: issue.agentSessionId,
-                plan: buildAgentSessionPlanForIssue(issue, options),
-                ...(externalUrls ? { externalUrls } : {}),
-            });
-        }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            this.logger.warn({ issueKey: issue.issueKey, error: msg }, "Failed to update Linear plan");
-        }
-    }
-    async syncLinearSessionWithCodexPlan(issue, params) {
-        if (!issue.agentSessionId)
-            return;
-        const plan = params.plan;
-        if (!Array.isArray(plan))
-            return;
-        const STATUS_MAP = {
-            pending: "pending",
-            inProgress: "inProgress",
-            completed: "completed",
-        };
-        const steps = plan.map((entry) => {
-            const e = entry;
-            const step = typeof e.step === "string" ? e.step : String(e.step ?? "");
-            const status = typeof e.status === "string" ? (STATUS_MAP[e.status] ?? "pending") : "pending";
-            return { content: step, status };
-        });
-        // Prepend a "Prepare workspace" completed step and append a "Merge" pending step
-        // to frame the codex plan within the PatchRelay lifecycle
-        const fullPlan = [
-            { content: "Prepare workspace", status: "completed" },
-            ...steps,
-            { content: "Merge", status: "pending" },
-        ];
-        try {
-            const linear = await this.linearProvider.forProject(issue.projectId);
-            if (!linear?.updateAgentSession)
-                return;
-            await linear.updateAgentSession({
-                agentSessionId: issue.agentSessionId,
-                plan: fullPlan,
-            });
-        }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            this.logger.warn({ issueKey: issue.issueKey, error: msg }, "Failed to sync codex plan to Linear");
-        }
-    }
     async readThreadWithRetry(threadId, maxRetries = 3) {
         for (let attempt = 0; attempt < maxRetries; attempt++) {
             try {
@@ -1350,40 +931,6 @@ function resolveRecoverablePostRunState(issue) {
     }
     return resolvePostRunState(issue);
 }
-function buildFailureContext(issue) {
-    const storedFailureContext = parseGitHubFailureContext(issue.lastGitHubFailureContextJson);
-    const queueRepairContext = issue.lastQueueIncidentJson
-        ? parseStoredQueueRepairContext(issue.lastQueueIncidentJson)
-        : undefined;
-    if (!queueRepairContext
-        && !issue.lastGitHubFailureSource
-        && !issue.lastGitHubFailureHeadSha
-        && !issue.lastGitHubFailureSignature
-        && !issue.lastGitHubFailureCheckName
-        && !issue.lastGitHubFailureCheckUrl
-        && !storedFailureContext) {
-        return undefined;
-    }
-    return {
-        ...(issue.lastGitHubFailureSource ? { failureReason: issue.lastGitHubFailureSource } : {}),
-        ...(issue.lastGitHubFailureHeadSha ? { failureHeadSha: issue.lastGitHubFailureHeadSha } : {}),
-        ...(issue.lastGitHubFailureSignature ? { failureSignature: issue.lastGitHubFailureSignature } : {}),
-        ...(issue.lastGitHubFailureCheckName ? { checkName: issue.lastGitHubFailureCheckName } : {}),
-        ...(issue.lastGitHubFailureCheckUrl ? { checkUrl: issue.lastGitHubFailureCheckUrl } : {}),
-        ...(storedFailureContext ? storedFailureContext : {}),
-        ...(queueRepairContext ? queueRepairContext : {}),
-    };
-}
-function isDuplicateRepairAttempt(issue, context) {
-    const signature = typeof context?.failureSignature === "string" ? context.failureSignature : undefined;
-    const headSha = typeof context?.failureHeadSha === "string"
-        ? context.failureHeadSha
-        : typeof context?.headSha === "string" ? context.headSha : undefined;
-    if (!signature)
-        return false;
-    return issue.lastAttemptedFailureSignature === signature
-        && (headSha === undefined || issue.lastAttemptedFailureHeadSha === headSha);
-}
 function appendQueueRepairContext(lines, context) {
     const incidentTitle = typeof context?.incidentTitle === "string" ? context.incidentTitle.trim() : "";
     const incidentSummary = typeof context?.incidentSummary === "string" ? context.incidentSummary.trim() : "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchrelay",
-  "version": "0.35.7",
+  "version": "0.35.9",
   "license": "MIT",
   "type": "module",
   "repository": {