patchrelay 0.40.0 → 0.41.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.40.0",
-  "commit": "c1cef920f5e3",
-  "builtAt": "2026-04-11T22:19:02.944Z"
+  "version": "0.41.0",
+  "commit": "4ad3af5dce7c",
+  "builtAt": "2026-04-12T21:16:04.426Z"
 }

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 { formatClose, formatInspect, formatList, formatLive, formatOpen, formatRetry, formatSessionHistory, formatTranscriptSource, formatWorktree } from "../formatters/text.js";
+import { formatAudit, formatClose, formatInspect, formatList, formatLive, formatOpen, formatRetry, formatSessionHistory, formatTranscriptSource, formatWorktree } from "../formatters/text.js";
 import { buildOpenCommand } from "../interactive.js";
 import { writeOutput } from "../output.js";
 export async function handleIssueCommand(params) {
@@ -36,6 +36,8 @@ export async function handleIssueCommand(params) {
             return await handleOpenCommand(nested);
         case "sessions":
             return await handleSessionsCommand(nested);
+        case "audit":
+            return await handleAuditCommand(nested);
         case "transcript-source":
             return await handleTranscriptSourceCommand(nested);
         case "retry":
@@ -156,6 +158,18 @@ export async function handleSessionsCommand(params) {
         : formatSessionHistory(result, (threadId) => buildOpenCommand(params.config, result.worktreePath ?? "", threadId)));
     return 0;
 }
+export async function handleAuditCommand(params) {
+    const issueKey = params.commandArgs[0];
+    if (!issueKey) {
+        throw new Error("audit requires <issueKey>.");
+    }
+    const result = params.data.audit(issueKey);
+    if (!result) {
+        throw new Error(`Issue not found: ${issueKey}`);
+    }
+    writeOutput(params.stdout, params.json ? formatJson(result) : formatAudit(result));
+    return 0;
+}
 export async function handleRetryCommand(params) {
     const issueKey = params.commandArgs[0];
     if (!issueKey) {

package/dist/cli/data.js

@@ -7,6 +7,7 @@ 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 { parseDelegationObservedPayload, parseRunReleasedAuthorityPayload } from "../delegation-audit.js";
 import { CliOperatorApiClient } from "./operator-client.js";
 function safeJsonParse(value) {
     if (!value)
@@ -273,6 +274,50 @@ export class CliDataAccess extends CliOperatorApiClient {
             ...(run ? { releasedRunId: run.id } : {}),
         };
     }
+    audit(issueKey) {
+        const issue = this.db.getTrackedIssueByKey(issueKey);
+        if (!issue)
+            return undefined;
+        const events = this.db.issueSessions
+            .listIssueSessionEvents(issue.projectId, issue.linearIssueId)
+            .flatMap((event) => {
+            const delegationObserved = parseDelegationObservedPayload(event);
+            if (delegationObserved) {
+                return [{
+                        createdAt: event.createdAt,
+                        eventType: event.eventType,
+                        summary: [
+                            delegationObserved.source,
+                            `observed=${delegationObserved.observedDelegatedToPatchRelay ? "delegated" : "undelegated"}`,
+                            `applied=${delegationObserved.appliedDelegatedToPatchRelay ? "delegated" : "undelegated"}`,
+                            `hydration=${delegationObserved.hydration}`,
+                            delegationObserved.reason ? `reason=${delegationObserved.reason}` : undefined,
+                        ].filter(Boolean).join(" "),
+                        details: delegationObserved,
+                    }];
+            }
+            const authorityRelease = parseRunReleasedAuthorityPayload(event);
+            if (authorityRelease) {
+                return [{
+                        createdAt: event.createdAt,
+                        eventType: event.eventType,
+                        summary: `released run #${authorityRelease.runId} (${authorityRelease.runType}) via ${authorityRelease.source}: ${authorityRelease.reason}`,
+                        details: authorityRelease,
+                    }];
+            }
+            if (event.eventType === "delegated" || event.eventType === "undelegated") {
+                return [{
+                        createdAt: event.createdAt,
+                        eventType: event.eventType,
+                        summary: event.eventType === "delegated"
+                            ? "PatchRelay accepted delegation"
+                            : "PatchRelay recorded undelegation",
+                    }];
+            }
+            return [];
+        });
+        return { issue, events };
+    }
     transcriptSource(issueKey, runId) {
         const issue = this.db.getTrackedIssueByKey(issueKey);
         if (!issue)

package/dist/cli/formatters/text.js

@@ -84,6 +84,26 @@ export function formatRetry(result) {
         .filter(Boolean)
         .join("\n")}\n`;
 }
+export function formatAudit(result) {
+    const lines = [
+        `${result.issue.issueKey ?? result.issue.linearIssueId}${result.issue.currentLinearState ? `  ${result.issue.currentLinearState}` : ""}`,
+    ];
+    if (result.events.length === 0) {
+        lines.push("No delegation audit events recorded.");
+        return `${lines.join("\n")}\n`;
+    }
+    for (const event of result.events) {
+        lines.push("");
+        lines.push([event.createdAt, event.eventType].join("  "));
+        lines.push(event.summary);
+        if (event.details && Object.keys(event.details).length > 0) {
+            lines.push(Object.entries(event.details)
+                .map(([key, value]) => `${key}=${value === undefined ? "-" : typeof value === "string" ? value : JSON.stringify(value)}`)
+                .join(" "));
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}
 export function formatClose(result) {
     return `${[
         value("Issue", result.issue.issueKey ?? result.issue.linearIssueId),

package/dist/cli/help.js

@@ -34,6 +34,7 @@ export function rootHelpText() {
         "  issue list [--active] [--failed] [--repo <id>] [--json]",
         "                                                          List tracked issues",
         "  issue show <issueKey> [--json]                          Show the latest known issue state",
+        "  issue audit <issueKey> [--json]                         Show delegation/release audit events for one issue",
         "  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",
@@ -146,6 +147,7 @@ export function issueHelpText() {
         "",
         "Commands:",
         "  show <issueKey>                 Show the latest known issue state",
+        "  audit <issueKey>                Show delegation/release audit events",
         "  list                            List tracked issues",
         "  watch <issueKey>                Follow issue activity until it settles",
         "  path <issueKey>                 Print the issue worktree path",

package/dist/cli/watch/state-visualization.js

@@ -127,7 +127,7 @@ export function buildPatchRelayQueueObservations(issue, feedEvents) {
                 case "awaiting_queue":
                     observations.push({
                         tone: "info",
-                        text: "PatchRelay has finished active work and is waiting for downstream merge flow.",
+                        text: "PatchRelay has finished active work. Delivery now depends on downstream review and merge automation.",
                     });
                     break;
                 case "repairing_queue":

package/dist/db/issue-session-store.js

@@ -1,4 +1,4 @@
-import { deriveSessionWakePlan } from "../issue-session-events.js";
+import { deriveSessionWakePlan, isActionableIssueSessionEventType } from "../issue-session-events.js";
 import { isoNow } from "./shared.js";
 export class IssueSessionStore {
     connection;
@@ -90,13 +90,8 @@ export class IssueSessionStore {
     `).run(isoNow(), projectId, linearIssueId);
     }
     hasPendingIssueSessionEvents(projectId, linearIssueId) {
-        const row = this.connection.prepare(`
-      SELECT 1
-      FROM issue_session_events
-      WHERE project_id = ? AND linear_issue_id = ? AND processed_at IS NULL
-      LIMIT 1
-    `).get(projectId, linearIssueId);
-        return row !== undefined;
+        return this.listIssueSessionEvents(projectId, linearIssueId, { pendingOnly: true })
+            .some((event) => isActionableIssueSessionEventType(event.eventType));
     }
     peekIssueSessionWake(projectId, linearIssueId) {
         const issue = this.issues.getIssue(projectId, linearIssueId);

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

@@ -0,0 +1,39 @@
+export function appendDelegationObservedEvent(db, params) {
+    db.issueSessions.appendIssueSessionEventRespectingActiveLease(params.projectId, params.linearIssueId, {
+        projectId: params.projectId,
+        linearIssueId: params.linearIssueId,
+        eventType: "delegation_observed",
+        eventJson: JSON.stringify(params.payload),
+    });
+}
+export function appendRunReleasedAuthorityEvent(db, params) {
+    db.issueSessions.appendIssueSessionEventRespectingActiveLease(params.projectId, params.linearIssueId, {
+        projectId: params.projectId,
+        linearIssueId: params.linearIssueId,
+        eventType: "run_released_authority",
+        eventJson: JSON.stringify(params.payload),
+    });
+}
+export function parseDelegationObservedPayload(event) {
+    if (event.eventType !== "delegation_observed" || !event.eventJson) {
+        return undefined;
+    }
+    return parseObject(event.eventJson);
+}
+export function parseRunReleasedAuthorityPayload(event) {
+    if (event.eventType !== "run_released_authority" || !event.eventJson) {
+        return undefined;
+    }
+    return parseObject(event.eventJson);
+}
+function parseObject(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

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-overview-query.js

@@ -88,7 +88,7 @@ export class IssueOverviewQuery {
         const runCount = runs.length;
         const liveThread = await this.readLiveThread(activeRun);
         const failureContext = parseGitHubFailureContext(issueRecord?.lastGitHubFailureContextJson);
-        const waitingReason = session.waitingReason ?? derivePatchRelayWaitingReason({
+        const derivedWaitingReason = derivePatchRelayWaitingReason({
             delegatedToPatchRelay: issueRecord?.delegatedToPatchRelay,
             ...(activeRun ? { activeRunType: activeRun.runType } : {}),
             blockedByKeys,
@@ -102,6 +102,7 @@ export class IssueOverviewQuery {
             lastBlockingReviewHeadSha: issueRecord?.lastBlockingReviewHeadSha,
             latestFailureCheckName: issueRecord?.lastGitHubFailureCheckName,
         });
+        const waitingReason = derivedWaitingReason ?? session.waitingReason;
         const issue = {
             id: issueRecord?.id ?? session.id,
             projectId: session.projectId,

package/dist/issue-session-events.js

@@ -7,14 +7,19 @@ const TERMINAL_SESSION_EVENTS = new Set([
     "pr_closed",
     "pr_merged",
 ]);
+const NON_ACTIONABLE_SESSION_EVENTS = new Set([
+    "delegation_observed",
+    "run_released_authority",
+]);
 const RUN_TYPES = new Set(["implementation", "review_fix", "branch_upkeep", "ci_repair", "queue_repair"]);
 function parseRunType(value) {
     return typeof value === "string" && RUN_TYPES.has(value) ? value : undefined;
 }
 export function deriveSessionWakePlan(issue, events) {
-    if (events.length === 0)
+    const actionableEvents = events.filter((event) => !NON_ACTIONABLE_SESSION_EVENTS.has(event.eventType));
+    if (actionableEvents.length === 0)
         return undefined;
-    if (events.some((event) => TERMINAL_SESSION_EVENTS.has(event.eventType))) {
+    if (actionableEvents.some((event) => TERMINAL_SESSION_EVENTS.has(event.eventType))) {
         return undefined;
     }
     const context = {};
@@ -22,7 +27,7 @@ export function deriveSessionWakePlan(issue, events) {
     let wakeReason;
     let runType;
     let resumeThread = false;
-    for (const event of events) {
+    for (const event of actionableEvents) {
         const payload = parseEventJson(event.eventJson);
         switch (event.eventType) {
             case "merge_steward_incident":
@@ -128,6 +133,9 @@ export function deriveSessionWakePlan(issue, events) {
     }
     return { runType, wakeReason, resumeThread, context };
 }
+export function isActionableIssueSessionEventType(eventType) {
+    return !NON_ACTIONABLE_SESSION_EVENTS.has(eventType);
+}
 export function extractLatestAssistantSummary(run) {
     if (!run)
         return undefined;

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