patchrelay 0.40.1 → 0.41.1

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.40.1",
-  "commit": "a0d40b1e8b30",
-  "builtAt": "2026-04-12T19:50:43.295Z"
+  "version": "0.41.1",
+  "commit": "da144bb1629f",
+  "builtAt": "2026-04-12T21:22:14.994Z"
 }

package/dist/db/issue-store.js

@@ -104,6 +104,10 @@ export class IssueStore {
                 sets.push("pr_state = @prState");
                 values.prState = params.prState;
             }
+            if (params.prIsDraft !== undefined) {
+                sets.push("pr_is_draft = @prIsDraft");
+                values.prIsDraft = params.prIsDraft == null ? null : params.prIsDraft ? 1 : 0;
+            }
             if (params.prHeadSha !== undefined) {
                 sets.push("pr_head_sha = @prHeadSha");
                 values.prHeadSha = params.prHeadSha;
@@ -218,7 +222,7 @@ export class IssueStore {
           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, 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,
+          pr_number, pr_url, pr_state, pr_is_draft, 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,
           last_queue_signal_at, last_queue_incident_json,
@@ -231,7 +235,7 @@ export class IssueStore {
           @currentLinearState, @currentLinearStateType, @factoryState, @pendingRunType, @pendingRunContextJson,
           @branchName, @worktreePath, @threadId, @activeRunId, @statusCommentId,
           @agentSessionId, @lastLinearActivityKey,
-          @prNumber, @prUrl, @prState, @prHeadSha, @prAuthorLogin, @prReviewState, @prCheckStatus, @lastBlockingReviewHeadSha,
+          @prNumber, @prUrl, @prState, @prIsDraft, @prHeadSha, @prAuthorLogin, @prReviewState, @prCheckStatus, @lastBlockingReviewHeadSha,
           @lastGitHubFailureSource, @lastGitHubFailureHeadSha, @lastGitHubFailureSignature, @lastGitHubFailureCheckName, @lastGitHubFailureCheckUrl, @lastGitHubFailureContextJson, @lastGitHubFailureAt,
           @lastGitHubCiSnapshotHeadSha, @lastGitHubCiSnapshotGateCheckName, @lastGitHubCiSnapshotGateCheckStatus, @lastGitHubCiSnapshotJson, @lastGitHubCiSnapshotSettledAt,
           @lastQueueSignalAt, @lastQueueIncidentJson,
@@ -264,6 +268,7 @@ export class IssueStore {
                 prNumber: params.prNumber ?? null,
                 prUrl: params.prUrl ?? null,
                 prState: params.prState ?? null,
+                prIsDraft: params.prIsDraft == null ? null : params.prIsDraft ? 1 : 0,
                 prHeadSha: params.prHeadSha ?? null,
                 prAuthorLogin: params.prAuthorLogin ?? null,
                 prReviewState: params.prReviewState ?? null,
@@ -495,6 +500,7 @@ export function mapIssueRow(row) {
         ...(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) } : {}),
         ...(row.pr_state !== null && row.pr_state !== undefined ? { prState: String(row.pr_state) } : {}),
+        ...(row.pr_is_draft !== null && row.pr_is_draft !== undefined ? { prIsDraft: Boolean(row.pr_is_draft) } : {}),
         ...(row.pr_head_sha !== null && row.pr_head_sha !== undefined ? { prHeadSha: String(row.pr_head_sha) } : {}),
         ...(row.pr_author_login !== null && row.pr_author_login !== undefined ? { prAuthorLogin: String(row.pr_author_login) } : {}),
         ...(row.pr_review_state !== null && row.pr_review_state !== undefined ? { prReviewState: String(row.pr_review_state) } : {}),

package/dist/db/migrations.js

@@ -22,6 +22,7 @@ CREATE TABLE IF NOT EXISTS issues (
   pr_number INTEGER,
   pr_url TEXT,
   pr_state TEXT,
+  pr_is_draft INTEGER,
   pr_head_sha TEXT,
   pr_author_login TEXT,
   pr_review_state TEXT,
@@ -275,6 +276,7 @@ export function runPatchRelayMigrations(connection) {
     // branch CI failures from merge-queue evictions after webhook delivery.
     addColumnIfMissing(connection, "issues", "pr_head_sha", "TEXT");
     addColumnIfMissing(connection, "issues", "pr_author_login", "TEXT");
+    addColumnIfMissing(connection, "issues", "pr_is_draft", "INTEGER");
     addColumnIfMissing(connection, "issues", "last_github_failure_source", "TEXT");
     addColumnIfMissing(connection, "issues", "last_github_failure_head_sha", "TEXT");
     addColumnIfMissing(connection, "issues", "last_github_failure_signature", "TEXT");
@@ -335,6 +337,7 @@ function removeRetiredIssueColumnsIfPresent(connection) {
         pr_number INTEGER,
         pr_url TEXT,
         pr_state TEXT,
+        pr_is_draft INTEGER,
         pr_head_sha TEXT,
         pr_author_login TEXT,
         pr_review_state TEXT,
@@ -391,6 +394,7 @@ function removeRetiredIssueColumnsIfPresent(connection) {
         pr_number,
         pr_url,
         pr_state,
+        pr_is_draft,
         pr_head_sha,
         pr_author_login,
         pr_review_state,
@@ -445,6 +449,7 @@ function removeRetiredIssueColumnsIfPresent(connection) {
         pr_number,
         pr_url,
         pr_state,
+        pr_is_draft,
         pr_head_sha,
         pr_author_login,
         pr_review_state,

package/dist/delegation-linked-pr.js

@@ -0,0 +1,104 @@
+import { deriveGateCheckStatusFromRollup } from "./github-rollup.js";
+import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
+import { buildClosedPrCleanupFields } from "./pr-state.js";
+import { buildReviewFixBranchUpkeepContext, normalizeRemotePrState, normalizeRemoteReviewDecision, } from "./reactive-pr-state.js";
+export function deriveLinkedPrAdoptionOutcome(project, prNumber, remote) {
+    const prState = normalizeRemotePrState(remote.state);
+    const reviewState = normalizeRemoteReviewDecision(remote.reviewDecision);
+    const configuredGateChecks = (project.gateChecks ?? []).map((entry) => entry.trim()).filter(Boolean);
+    const gateCheckNames = configuredGateChecks.length > 0 ? configuredGateChecks : ["verify"];
+    const primaryGateCheck = gateCheckNames[0];
+    const gateCheckStatus = deriveGateCheckStatusFromRollup(remote.statusCheckRollup, gateCheckNames);
+    const mergeConflictDetected = remote.mergeable === "CONFLICTING" || remote.mergeStateStatus === "DIRTY";
+    const downstreamOwned = reviewState === "approved";
+    const issueUpdates = {
+        prNumber,
+        ...(remote.url ? { prUrl: remote.url } : {}),
+        ...(prState ? { prState } : {}),
+        ...(typeof remote.isDraft === "boolean" ? { prIsDraft: remote.isDraft } : {}),
+        ...(remote.headRefName ? { branchName: remote.headRefName } : {}),
+        ...(remote.headRefOid ? { prHeadSha: remote.headRefOid } : {}),
+        ...(remote.author?.login ? { prAuthorLogin: remote.author.login } : {}),
+        ...(reviewState ? { prReviewState: reviewState } : {}),
+        ...(gateCheckStatus ? { prCheckStatus: gateCheckStatus } : {}),
+        ...(reviewState === "changes_requested"
+            ? { lastBlockingReviewHeadSha: remote.headRefOid ?? null }
+            : { lastBlockingReviewHeadSha: null }),
+        ...(remote.headRefOid && gateCheckStatus
+            ? {
+                lastGitHubCiSnapshotHeadSha: remote.headRefOid,
+                lastGitHubCiSnapshotGateCheckName: primaryGateCheck,
+                lastGitHubCiSnapshotGateCheckStatus: gateCheckStatus,
+                lastGitHubCiSnapshotSettledAt: gateCheckStatus === "pending" ? null : new Date().toISOString(),
+            }
+            : {}),
+    };
+    if (prState === "merged") {
+        return {
+            factoryState: "done",
+            pendingRunType: null,
+            issueUpdates: {
+                ...issueUpdates,
+                prIsDraft: false,
+            },
+        };
+    }
+    if (prState === "closed") {
+        return {
+            factoryState: "awaiting_input",
+            pendingRunType: null,
+            issueUpdates: {
+                ...issueUpdates,
+                prIsDraft: false,
+                ...buildClosedPrCleanupFields(),
+            },
+        };
+    }
+    if (remote.isCrossRepository) {
+        return {
+            factoryState: "awaiting_input",
+            pendingRunType: null,
+            issueUpdates,
+        };
+    }
+    if (remote.isDraft) {
+        return {
+            factoryState: "delegated",
+            pendingRunType: "implementation",
+            issueUpdates,
+        };
+    }
+    const reactiveIntent = deriveIssueSessionReactiveIntent({
+        delegatedToPatchRelay: true,
+        prNumber,
+        prState,
+        prReviewState: reviewState,
+        prCheckStatus: gateCheckStatus,
+        mergeConflictDetected,
+        downstreamOwned,
+    });
+    if (reactiveIntent) {
+        return {
+            factoryState: reactiveIntent.compatibilityFactoryState,
+            pendingRunType: reactiveIntent.runType,
+            ...(reactiveIntent.runType === "branch_upkeep"
+                ? {
+                    pendingRunContext: buildReviewFixBranchUpkeepContext(prNumber, project.github?.baseBranch ?? "main", remote),
+                }
+                : {}),
+            issueUpdates,
+        };
+    }
+    if (reviewState === "approved") {
+        return {
+            factoryState: "awaiting_queue",
+            pendingRunType: null,
+            issueUpdates,
+        };
+    }
+    return {
+        factoryState: "pr_open",
+        pendingRunType: null,
+        issueUpdates,
+    };
+}

package/dist/issue-session.js

@@ -49,6 +49,8 @@ export function deriveIssueSessionReactiveIntent(params) {
         return undefined;
     if (params.prState && params.prState !== "open")
         return undefined;
+    if (params.prIsDraft)
+        return undefined;
     if (params.latestFailureSource === "queue_eviction" || (params.mergeConflictDetected && params.downstreamOwned)) {
         return {
             runType: "queue_repair",

package/dist/linear-client.js

@@ -6,6 +6,14 @@ const LINEAR_ISSUE_SELECTION = `
   title
   description
   url
+  attachments {
+    nodes {
+      id
+      title
+      subtitle
+      url
+    }
+  }
   priority
   estimate
   delegate {
@@ -316,12 +324,21 @@ export class LinearGraphqlClient {
         const teamLabels = (issue.team?.labels?.nodes ?? []).map((label) => ({ id: label.id, name: label.name }));
         const blocksRelations = (issue.relations?.nodes ?? []).filter((relation) => relation.type?.trim().toLowerCase() === "blocks");
         const blockedByRelations = (issue.inverseRelations?.nodes ?? []).filter((relation) => relation.type?.trim().toLowerCase() === "blocks");
+        const attachments = (issue.attachments?.nodes ?? [])
+            .filter((attachment) => Boolean(attachment?.url))
+            .map((attachment) => ({
+            id: attachment.id,
+            ...(attachment.title ? { title: attachment.title } : {}),
+            ...(attachment.subtitle ? { subtitle: attachment.subtitle } : {}),
+            url: attachment.url,
+        }));
         return {
             id: issue.id,
             ...(issue.identifier ? { identifier: issue.identifier } : {}),
             ...(issue.title ? { title: issue.title } : {}),
             ...(issue.description ? { description: issue.description } : {}),
             ...(issue.url ? { url: issue.url } : {}),
+            ...(attachments.length > 0 ? { attachments } : {}),
             ...(issue.priority != null ? { priority: issue.priority } : {}),
             ...(issue.estimate != null ? { estimate: issue.estimate } : {}),
             ...(issue.state?.id ? { stateId: issue.state.id } : {}),

package/dist/linear-linked-pr-reconciliation.js

@@ -0,0 +1,44 @@
+const GITHUB_PR_URL_PATTERN = /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)(?:[/?#].*)?$/i;
+export function resolveLinkedPullRequest(attachments, repoFullName) {
+    if (!repoFullName || !attachments || attachments.length === 0) {
+        return { kind: "none" };
+    }
+    const matches = attachments
+        .map((attachment) => parseGitHubPullRequestUrl(attachment.url))
+        .filter((reference) => Boolean(reference))
+        .filter((reference) => reference.repoFullName.toLowerCase() === repoFullName.toLowerCase());
+    const unique = dedupeReferences(matches);
+    if (unique.length === 0) {
+        return { kind: "none" };
+    }
+    if (unique.length === 1) {
+        return { kind: "matched", reference: unique[0] };
+    }
+    return { kind: "ambiguous", references: unique };
+}
+function parseGitHubPullRequestUrl(url) {
+    const match = url.trim().match(GITHUB_PR_URL_PATTERN);
+    if (!match)
+        return undefined;
+    const [, owner, repo, prNumberRaw] = match;
+    const prNumber = Number(prNumberRaw);
+    if (!Number.isInteger(prNumber) || prNumber <= 0)
+        return undefined;
+    return {
+        repoFullName: `${owner}/${repo}`,
+        prNumber,
+        url,
+    };
+}
+function dedupeReferences(references) {
+    const seen = new Set();
+    const unique = [];
+    for (const reference of references) {
+        const key = `${reference.repoFullName.toLowerCase()}#${reference.prNumber}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        unique.push(reference);
+    }
+    return unique;
+}

package/dist/remote-pr-state.js

@@ -3,7 +3,7 @@ export async function readRemotePrState(repoFullName, prNumber) {
     const { stdout, exitCode } = await execCommand("gh", [
         "pr", "view", String(prNumber),
         "--repo", repoFullName,
-        "--json", "headRefOid,state,reviewDecision,mergeStateStatus",
+        "--json", "url,headRefName,headRefOid,isDraft,isCrossRepository,state,author,reviewDecision,mergeable,mergeStateStatus,statusCheckRollup",
     ], { timeoutMs: 10_000 });
     if (exitCode !== 0)
         return undefined;

package/dist/webhooks/decision-helpers.js

@@ -38,10 +38,17 @@ export function resolveReDelegationResume(p) {
     if (p.prState === "merged") {
         return { factoryState: "done", pendingRunType: null };
     }
+    if (p.prNumber !== undefined && (p.prState === undefined || p.prState === "open") && p.prIsDraft) {
+        return {
+            factoryState: "delegated",
+            pendingRunType: (p.unresolvedBlockers ?? 0) === 0 ? "implementation" : null,
+        };
+    }
     const reactiveIntent = deriveIssueSessionReactiveIntent({
         delegatedToPatchRelay: true,
         prNumber: p.prNumber,
         prState: p.prState,
+        prIsDraft: p.prIsDraft,
         prReviewState: p.prReviewState,
         prCheckStatus: p.prCheckStatus,
         latestFailureSource: p.latestFailureSource,
@@ -100,6 +107,7 @@ export function mergeIssueMetadata(issue, liveIssue) {
         ...(issue.identifier ? {} : liveIssue.identifier ? { identifier: liveIssue.identifier } : {}),
         ...(issue.title ? {} : liveIssue.title ? { title: liveIssue.title } : {}),
         ...(issue.url ? {} : liveIssue.url ? { url: liveIssue.url } : {}),
+        ...(issue.attachments && issue.attachments.length > 0 ? {} : liveIssue.attachments ? { attachments: liveIssue.attachments } : {}),
         ...(issue.teamId ? {} : liveIssue.teamId ? { teamId: liveIssue.teamId } : {}),
         ...(issue.teamKey ? {} : liveIssue.teamKey ? { teamKey: liveIssue.teamKey } : {}),
         ...(issue.stateId ? {} : liveIssue.stateId ? { stateId: liveIssue.stateId } : {}),

package/dist/webhooks/desired-stage-recorder.js

@@ -3,6 +3,9 @@ import { resolveAwaitingInputReason } from "../awaiting-input-reason.js";
 import { appendDelegationObservedEvent } from "../delegation-audit.js";
 import { decideActiveRunRelease, decideAgentSession, decideRunIntent, decideUnDelegation, isTerminalDelegationState, mergeIssueMetadata, resolveReDelegationResume, } from "./decision-helpers.js";
 import { buildOperatorRetryEvent } from "../operator-retry-event.js";
+import { resolveLinkedPullRequest } from "../linear-linked-pr-reconciliation.js";
+import { readRemotePrState } from "../remote-pr-state.js";
+import { deriveLinkedPrAdoptionOutcome } from "../delegation-linked-pr.js";
 export class DesiredStageRecorder {
     db;
     linearProvider;
@@ -40,6 +43,13 @@ export class DesiredStageRecorder {
             activeRunId: activeRun?.id,
         });
         const delegated = delegation.delegated;
+        const linkedPrAdoption = await this.resolveLinkedPrAdoption({
+            project: params.project,
+            issue: hydratedIssue,
+            existingIssue,
+            delegated,
+            triggerEvent: params.normalized.triggerEvent,
+        });
         const unresolvedBlockers = this.db.issues.countUnresolvedBlockers(params.project.id, normalizedIssue.id);
         const terminal = isTerminalDelegationState(existingIssue, hydratedIssue);
         const openPrExists = existingIssue?.prNumber !== undefined
@@ -48,16 +58,18 @@ export class DesiredStageRecorder {
         const blockerPausedImplementation = unresolvedBlockers > 0
             && activeRun?.runType === "implementation"
             && !openPrExists;
-        const desiredStage = decideRunIntent({
-            delegated,
-            triggerAllowed,
-            triggerEvent: params.normalized.triggerEvent,
-            unresolvedBlockers,
-            hasActiveRun: Boolean(activeRun),
-            hasPendingWake,
-            terminal,
-            currentState: existingIssue?.factoryState,
-        });
+        const desiredStage = linkedPrAdoption
+            ? undefined
+            : decideRunIntent({
+                delegated,
+                triggerAllowed,
+                triggerEvent: params.normalized.triggerEvent,
+                unresolvedBlockers,
+                hasActiveRun: Boolean(activeRun),
+                hasPendingWake,
+                terminal,
+                currentState: existingIssue?.factoryState,
+            });
         const runRelease = decideActiveRunRelease({
             hasActiveRun: Boolean(activeRun),
             terminal,
@@ -73,20 +85,31 @@ export class DesiredStageRecorder {
             currentState: existingIssue?.factoryState,
             hasPr: existingIssue?.prNumber !== undefined && existingIssue?.prState !== "merged",
         });
-        const reDelegationResume = resolveReDelegationResume({
-            delegated,
-            previouslyDelegated: existingIssue?.delegatedToPatchRelay,
-            currentState: existingIssue?.factoryState,
-            awaitingInputReason: existingIssue
-                ? resolveAwaitingInputReason({ issue: existingIssue, latestRun })
-                : undefined,
-            unresolvedBlockers,
-            prNumber: existingIssue?.prNumber,
-            prState: existingIssue?.prState,
-            prReviewState: existingIssue?.prReviewState,
-            prCheckStatus: existingIssue?.prCheckStatus,
-            latestFailureSource: existingIssue?.lastGitHubFailureSource,
-        });
+        const startupResume = linkedPrAdoption
+            ? {
+                factoryState: linkedPrAdoption.factoryState,
+                pendingRunType: linkedPrAdoption.pendingRunType,
+                pendingRunContext: linkedPrAdoption.pendingRunContext,
+                source: "linked_pr_adoption",
+            }
+            : {
+                ...resolveReDelegationResume({
+                    delegated,
+                    previouslyDelegated: existingIssue?.delegatedToPatchRelay,
+                    currentState: existingIssue?.factoryState,
+                    awaitingInputReason: existingIssue
+                        ? resolveAwaitingInputReason({ issue: existingIssue, latestRun })
+                        : undefined,
+                    unresolvedBlockers,
+                    prNumber: existingIssue?.prNumber,
+                    prState: existingIssue?.prState,
+                    prIsDraft: existingIssue?.prIsDraft,
+                    prReviewState: existingIssue?.prReviewState,
+                    prCheckStatus: existingIssue?.prCheckStatus,
+                    latestFailureSource: existingIssue?.lastGitHubFailureSource,
+                }),
+                source: "re_delegated",
+            };
         const existingWakeRunType = existingIssue
             ? params.peekPendingSessionWakeRunType(params.project.id, normalizedIssue.id)
             : undefined;
@@ -109,13 +132,19 @@ export class DesiredStageRecorder {
                 ...(hydratedIssue.estimate != null ? { estimate: hydratedIssue.estimate } : {}),
                 ...(hydratedIssue.stateName ? { currentLinearState: hydratedIssue.stateName } : {}),
                 ...(hydratedIssue.stateType ? { currentLinearStateType: hydratedIssue.stateType } : {}),
+                ...(linkedPrAdoption?.issueUpdates ?? {}),
                 delegatedToPatchRelay: delegated,
                 ...(!existingIssue && !delegated && incomingAgentSessionId ? { factoryState: "awaiting_input" } : {}),
-                ...(reDelegationResume.factoryState ? { factoryState: reDelegationResume.factoryState } : {}),
-                ...(reDelegationResume.pendingRunType !== undefined
-                    ? { pendingRunType: null, pendingRunContextJson: null }
+                ...(startupResume.factoryState ? { factoryState: startupResume.factoryState } : {}),
+                ...(startupResume.pendingRunType !== undefined
+                    ? {
+                        pendingRunType: null,
+                        pendingRunContextJson: startupResume.pendingRunContext
+                            ? JSON.stringify(startupResume.pendingRunContext)
+                            : null,
+                    }
                     : {}),
-                ...(!reDelegationResume.factoryState && desiredStage ? { pendingRunType: null, pendingRunContextJson: null, factoryState: "delegated" } : {}),
+                ...(!startupResume.factoryState && desiredStage ? { pendingRunType: null, pendingRunContextJson: null, factoryState: "delegated" } : {}),
                 ...(clearPending ? { pendingRunType: null, pendingRunContextJson: null } : {}),
                 ...(agentSessionId !== undefined ? { agentSessionId } : {}),
                 ...(effectiveRunRelease.release ? { activeRunId: null } : {}),
@@ -175,15 +204,15 @@ export class DesiredStageRecorder {
                 summary: `Implementation paused because ${issue.issueKey ?? normalizedIssue.id} is now blocked`,
             });
         }
-        else if (reDelegationResume.pendingRunType) {
+        else if (startupResume.pendingRunType) {
             this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(params.project.id, normalizedIssue.id, {
                 projectId: params.project.id,
                 linearIssueId: normalizedIssue.id,
-                ...buildOperatorRetryEvent(issue, reDelegationResume.pendingRunType, "re_delegated"),
+                ...buildOperatorRetryEvent(issue, startupResume.pendingRunType, startupResume.source),
             });
         }
-        else if (!reDelegationResume.factoryState
-            && !reDelegationResume.pendingRunType
+        else if (!startupResume.factoryState
+            && !startupResume.pendingRunType
             &&
                 desiredStage === "implementation"
             && params.normalized.triggerEvent !== "commentCreated"
@@ -281,4 +310,36 @@ export class DesiredStageRecorder {
         }
         return { issue: source, hydration };
     }
+    async resolveLinkedPrAdoption(params) {
+        if (!params.delegated)
+            return undefined;
+        if (params.triggerEvent !== "delegateChanged")
+            return undefined;
+        if (params.existingIssue?.prNumber !== undefined)
+            return undefined;
+        const resolution = resolveLinkedPullRequest(params.issue.attachments, params.project.github?.repoFullName);
+        if (resolution.kind === "none")
+            return undefined;
+        if (resolution.kind === "ambiguous") {
+            return {
+                factoryState: "awaiting_input",
+                pendingRunType: null,
+                pendingRunContext: undefined,
+                issueUpdates: {},
+            };
+        }
+        const remote = await readRemotePrState(resolution.reference.repoFullName, resolution.reference.prNumber);
+        if (!remote) {
+            return {
+                factoryState: "awaiting_input",
+                pendingRunType: null,
+                pendingRunContext: undefined,
+                issueUpdates: {
+                    prNumber: resolution.reference.prNumber,
+                    prUrl: resolution.reference.url,
+                },
+            };
+        }
+        return deriveLinkedPrAdoptionOutcome(params.project, resolution.reference.prNumber, remote);
+    }
 }

package/dist/worktree-manager.js

@@ -48,7 +48,7 @@ export class WorktreeManager {
         await execCommand(gitBin, ["-C", worktreePath, "reset", "--hard", "HEAD"], { timeoutMs: 30_000 });
         await execCommand(gitBin, ["-C", worktreePath, "clean", "-fd"], { timeoutMs: 30_000 });
         const checkoutTarget = hasRemoteBranch ? `origin/${branchName}` : branchName;
-        const checkoutResult = await execCommand(gitBin, ["-C", worktreePath, "checkout", "-B", branchName, checkoutTarget], { timeoutMs: 30_000 });
+        const checkoutResult = await execCommand(gitBin, ["-C", worktreePath, "checkout", "--ignore-other-worktrees", "-B", branchName, checkoutTarget], { timeoutMs: 30_000 });
         if (checkoutResult.exitCode !== 0) {
             throw new Error(`Failed to restore ${branchName} worktree state: ${checkoutResult.stderr?.slice(0, 300) ?? "git checkout failed"}`);
         }
@@ -84,12 +84,16 @@ export class WorktreeManager {
         // Fetch latest main so the branch forks from a clean, up-to-date base.
         // This prevents branch contamination when local HEAD has drifted.
         // freshenWorktree in run-orchestrator acts as a secondary safety net.
-        await execCommand(this.config.runner.gitBin, ["-C", repoPath, "fetch", "origin", "main"], {
+        const fetchResult = await execCommand(this.config.runner.gitBin, ["-C", repoPath, "fetch", "origin", "main"], {
             timeoutMs: 60_000,
         });
-        await execCommand(this.config.runner.gitBin, ["-C", repoPath, "worktree", "add", "--force", "-B", branchName, worktreePath, "origin/main"], {
-            timeoutMs: 120_000,
-        });
+        if (fetchResult.exitCode !== 0) {
+            throw new Error(`Failed to fetch origin/main before creating issue worktree: ${fetchResult.stderr?.slice(0, 300) ?? "git fetch failed"}`);
+        }
+        const addResult = await execCommand(this.config.runner.gitBin, ["-C", repoPath, "worktree", "add", "--detach", worktreePath, "origin/main"], { timeoutMs: 120_000 });
+        if (addResult.exitCode !== 0) {
+            throw new Error(`Failed to create issue worktree at ${worktreePath}: ${addResult.stderr?.slice(0, 300) ?? "git worktree add failed"}`);
+        }
     }
     async assertTrustedExistingWorktree(repoPath, worktreeRoot, worktreePath, options) {
         const worktreeStats = lstatSync(worktreePath);

package/package.json

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