paperclip-github-plugin 0.8.2 → 0.8.4

package/dist/worker.js

@@ -613,6 +613,7 @@ function requiresPaperclipBoardAccess(value) {
 }
 
 // src/worker.ts
+var GITHUB_SYNC_BASE_ORIGIN_KIND = `plugin:${GITHUB_SYNC_PLUGIN_ID}`;
 var GITHUB_ISSUE_ORIGIN_KIND = `plugin:${GITHUB_SYNC_PLUGIN_ID}:github-issue`;
 var GITHUB_PULL_REQUEST_ORIGIN_KIND = `plugin:${GITHUB_SYNC_PLUGIN_ID}:github-pull-request`;
 var SETTINGS_SCOPE = {
@@ -5020,6 +5021,29 @@ function getPaperclipIssueSyncContext(issue) {
     executionState: normalizePaperclipIssueExecutionState(record.executionState)
   };
 }
+function hasUnresolvedPaperclipIssueBlockerSummary(blockers) {
+  if (!Array.isArray(blockers)) {
+    return false;
+  }
+  return blockers.some((blocker) => {
+    if (!blocker || typeof blocker !== "object") {
+      return true;
+    }
+    const status = blocker.status;
+    return status !== "done" && status !== "cancelled";
+  });
+}
+async function hasUnresolvedPaperclipIssueBlocker(ctx, issue, companyId) {
+  const record = issue;
+  if (hasUnresolvedPaperclipIssueBlockerSummary(record.blockedBy)) {
+    return true;
+  }
+  if (typeof ctx.issues.relations?.get !== "function") {
+    return false;
+  }
+  const relations = await ctx.issues.relations.get(issue.id, companyId);
+  return hasUnresolvedPaperclipIssueBlockerSummary(relations.blockedBy);
+}
 function isSamePaperclipIssueAssigneePrincipal(left, right) {
   if (!left || !right) {
     return !left && !right;
@@ -5201,6 +5225,9 @@ function isHealthyMaintainerWaitTransition(params) {
   const { currentStatus, nextStatus, syncContext } = params;
   return nextStatus === "in_review" && (currentStatus === "done" || currentStatus === "in_review") && syncContext.executionState === null && syncContext.executionPolicy !== null;
 }
+function shouldPreserveImportedTriageAssignee(params) {
+  return params.wasImportedThisRun && params.maintainerAuthoredImportedIssue === true && params.currentStatus === "backlog" && params.nextStatus === "todo";
+}
 function doesPaperclipIssueAssigneeMatch(currentAssignee, nextAssignee) {
   return isSamePaperclipIssueAssigneePrincipal(currentAssignee, nextAssignee);
 }
@@ -5552,10 +5579,10 @@ function normalizeGitHubPullRequestReviewDecision(value) {
   }
 }
 function isGitHubPullRequestActionRequiredForSync(pullRequest) {
-  return pullRequest.reviewDecision === "changes_requested" || pullRequest.mergeability === "conflicting" || ACTION_REQUIRED_GITHUB_PULL_REQUEST_MERGE_STATE_STATUSES.has(pullRequest.mergeStateStatus);
+  return pullRequest.mergeability === "conflicting" || ACTION_REQUIRED_GITHUB_PULL_REQUEST_MERGE_STATE_STATUSES.has(pullRequest.mergeStateStatus);
 }
 function isGitHubPullRequestReviewReadyForSync(pullRequest) {
-  if (pullRequest.ciState !== "green" || pullRequest.hasUnresolvedReviewThreads || pullRequest.reviewDecision === "changes_requested") {
+  if (pullRequest.ciState !== "green" || pullRequest.hasUnresolvedReviewThreads) {
     return false;
   }
   return REVIEW_READY_GITHUB_PULL_REQUEST_MERGE_STATE_STATUSES.has(pullRequest.mergeStateStatus);
@@ -5588,9 +5615,6 @@ function listGitHubPullRequestSyncBlockingConditions(pullRequest) {
   if (pullRequest.hasUnresolvedReviewThreads) {
     conditions.push("unresolved review threads");
   }
-  if (pullRequest.reviewDecision === "changes_requested") {
-    conditions.push("requested changes");
-  }
   return conditions;
 }
 function tryBuildGitHubPullRequestStatusSnapshotFromBatchNode(node, repository) {
@@ -6365,6 +6389,18 @@ function extractImportedGitHubIssueUrlFromDescription(description) {
   }
   return normalizeGitHubIssueHtmlUrl(legacyMatch[1]);
 }
+function removeGitHubIssueLinkMetadataFromDescription(description) {
+  if (typeof description !== "string") {
+    return void 0;
+  }
+  let next = description;
+  const hiddenMarkerPattern = getHiddenGitHubImportMarkerPattern();
+  while (hiddenMarkerPattern.test(next)) {
+    next = next.replace(hiddenMarkerPattern, "");
+  }
+  next = next.replace(/^\*\s+GitHub issue:\s+\[[^\]]+\]\([^)]+\)\s*$/gm, "").replace(/^Imported from https:\/\/github\.com\/[^\s)]+\/[^\s)]+\/issues\/\d+\.?\s*$/gim, "").replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+  return next === description ? void 0 : next;
+}
 function compareImportedPaperclipIssueCreatedAt(left, right) {
   const leftTime = Date.parse(String(left.createdAt ?? ""));
   const rightTime = Date.parse(String(right.createdAt ?? ""));
@@ -6693,6 +6729,7 @@ async function listGitHubIssueLinkRecords(ctx, query = {}) {
       }
       records.push({
         paperclipIssueId: entry.scopeId,
+        ...typeof entry.externalId === "string" && entry.externalId.trim() ? { externalId: entry.externalId.trim() } : {},
         ...typeof entry.createdAt === "string" ? { createdAt: entry.createdAt } : {},
         ...typeof entry.updatedAt === "string" ? { updatedAt: entry.updatedAt } : {},
         ...typeof entry.title === "string" && entry.title.trim() ? { title: entry.title.trim() } : {},
@@ -6739,6 +6776,7 @@ async function listGitHubPullRequestLinkRecords(ctx, query = {}) {
       }
       records.push({
         paperclipIssueId: entry.scopeId,
+        ...typeof entry.externalId === "string" && entry.externalId.trim() ? { externalId: entry.externalId.trim() } : {},
         ...typeof entry.createdAt === "string" ? { createdAt: entry.createdAt } : {},
         ...typeof entry.updatedAt === "string" ? { updatedAt: entry.updatedAt } : {},
         ...typeof entry.title === "string" && entry.title.trim() ? { title: entry.title.trim() } : {},
@@ -7147,6 +7185,134 @@ async function linkPaperclipIssueToGitHubPullRequest(ctx, params) {
     githubPullRequestState: pullRequestState
   };
 }
+function invalidateGitHubLinkCachesForTarget(params) {
+  if (!params.companyId || !params.projectId || !params.repositoryUrl) {
+    return;
+  }
+  const repository = parseRepositoryReference(params.repositoryUrl);
+  if (!repository) {
+    return;
+  }
+  invalidateProjectPullRequestCaches({
+    companyId: params.companyId,
+    projectId: params.projectId,
+    repository
+  });
+}
+async function tombstoneGitHubIssueLinkRecord(ctx, record, unlinkedAt) {
+  await ctx.entities.upsert({
+    entityType: ISSUE_LINK_ENTITY_TYPE,
+    scopeKind: "issue",
+    scopeId: record.paperclipIssueId,
+    externalId: record.externalId ?? record.data.githubIssueUrl,
+    title: record.title ?? `GitHub issue #${record.data.githubIssueNumber}`,
+    status: "unlinked",
+    data: {
+      kind: "issue",
+      paperclipIssueId: record.paperclipIssueId,
+      repositoryUrl: record.data.repositoryUrl,
+      githubIssueNumber: record.data.githubIssueNumber,
+      githubIssueUrl: record.data.githubIssueUrl,
+      ...record.data.companyId ? { companyId: record.data.companyId } : {},
+      ...record.data.paperclipProjectId ? { paperclipProjectId: record.data.paperclipProjectId } : {},
+      unlinkedAt
+    }
+  });
+}
+async function tombstoneGitHubPullRequestLinkRecord(ctx, record, unlinkedAt) {
+  await ctx.entities.upsert({
+    entityType: PULL_REQUEST_LINK_ENTITY_TYPE,
+    scopeKind: "issue",
+    scopeId: record.paperclipIssueId,
+    externalId: record.externalId ?? record.data.githubPullRequestUrl,
+    title: record.title ?? `GitHub pull request #${record.data.githubPullRequestNumber}`,
+    status: "unlinked",
+    data: {
+      kind: "pull_request",
+      paperclipIssueId: record.paperclipIssueId,
+      repositoryUrl: record.data.repositoryUrl,
+      githubPullRequestNumber: record.data.githubPullRequestNumber,
+      githubPullRequestUrl: record.data.githubPullRequestUrl,
+      ...record.data.companyId ? { companyId: record.data.companyId } : {},
+      ...record.data.paperclipProjectId ? { paperclipProjectId: record.data.paperclipProjectId } : {},
+      unlinkedAt
+    }
+  });
+}
+async function unlinkPaperclipIssueFromGitHub(ctx, params) {
+  const companyId = normalizeCompanyId(params.companyId);
+  const issueId = normalizeOptionalString2(params.issueId);
+  if (!companyId || !issueId) {
+    throw new Error("companyId and issueId are required.");
+  }
+  const issue = await ctx.issues.get(issueId, companyId);
+  if (!issue) {
+    throw new Error("Paperclip issue was not found.");
+  }
+  const issueLinkRecords = (await listGitHubIssueLinkRecords(ctx, {
+    paperclipIssueId: issueId
+  })).filter((record) => !record.data.companyId || record.data.companyId === companyId);
+  const pullRequestLinkRecords = (await listGitHubPullRequestLinkRecords(ctx, {
+    paperclipIssueId: issueId
+  })).filter((record) => !record.data.companyId || record.data.companyId === companyId);
+  const importRegistry = normalizeImportRegistry(await ctx.state.get(IMPORT_REGISTRY_SCOPE));
+  const removedImportRegistryEntries = importRegistry.filter(
+    (entry) => entry.paperclipIssueId === issueId && (!entry.companyId || entry.companyId === companyId)
+  );
+  const nextImportRegistry = importRegistry.filter(
+    (entry) => !(entry.paperclipIssueId === issueId && (!entry.companyId || entry.companyId === companyId))
+  );
+  const unlinkedAt = (/* @__PURE__ */ new Date()).toISOString();
+  for (const record of issueLinkRecords) {
+    await tombstoneGitHubIssueLinkRecord(ctx, record, unlinkedAt);
+    invalidateGitHubLinkCachesForTarget({
+      companyId: record.data.companyId ?? companyId,
+      projectId: record.data.paperclipProjectId ?? issue.projectId ?? void 0,
+      repositoryUrl: record.data.repositoryUrl
+    });
+  }
+  for (const record of pullRequestLinkRecords) {
+    await tombstoneGitHubPullRequestLinkRecord(ctx, record, unlinkedAt);
+    invalidateGitHubLinkCachesForTarget({
+      companyId: record.data.companyId ?? companyId,
+      projectId: record.data.paperclipProjectId ?? issue.projectId ?? void 0,
+      repositoryUrl: record.data.repositoryUrl
+    });
+  }
+  for (const entry of removedImportRegistryEntries) {
+    invalidateGitHubLinkCachesForTarget({
+      companyId: entry.companyId ?? companyId,
+      projectId: entry.paperclipProjectId ?? issue.projectId ?? void 0,
+      repositoryUrl: entry.repositoryUrl
+    });
+  }
+  if (removedImportRegistryEntries.length > 0) {
+    await ctx.state.set(IMPORT_REGISTRY_SCOPE, nextImportRegistry);
+  }
+  const shouldClearGitHubOrigin = issue.originKind === GITHUB_ISSUE_ORIGIN_KIND || issue.originKind === GITHUB_PULL_REQUEST_ORIGIN_KIND;
+  const nextDescription = removeGitHubIssueLinkMetadataFromDescription(issue.description);
+  const issuePatch = {};
+  if (shouldClearGitHubOrigin) {
+    issuePatch.originKind = GITHUB_SYNC_BASE_ORIGIN_KIND;
+    issuePatch.originId = null;
+    issuePatch.originRunId = null;
+  }
+  if (nextDescription !== void 0) {
+    issuePatch.description = nextDescription;
+  }
+  if (Object.keys(issuePatch).length > 0) {
+    await ctx.issues.update(issueId, issuePatch, companyId);
+  }
+  return {
+    paperclipIssueId: issueId,
+    unlinked: issueLinkRecords.length > 0 || pullRequestLinkRecords.length > 0 || removedImportRegistryEntries.length > 0 || shouldClearGitHubOrigin || nextDescription !== void 0,
+    unlinkedIssueLinksCount: issueLinkRecords.length,
+    unlinkedPullRequestLinksCount: pullRequestLinkRecords.length,
+    removedImportRegistryEntriesCount: removedImportRegistryEntries.length,
+    clearedIssueOrigin: shouldClearGitHubOrigin,
+    removedDescriptionMetadata: nextDescription !== void 0
+  };
+}
 async function upsertStatusTransitionCommentAnnotation(ctx, params) {
   const { issueId, commentId, annotation } = params;
   await ctx.entities.upsert({
@@ -8450,6 +8616,261 @@ async function ensurePaperclipIssueImported(ctx, mapping, advancedSettings, issu
   }
   return createdIssue.id;
 }
+function getGitHubIssueRepositoryReference(issue) {
+  return parseGitHubIssueHtmlUrl(issue.htmlUrl);
+}
+function findTransferredIssueTargetMapping(mappings, params) {
+  const companyId = normalizeCompanyId(params.companyId);
+  const repository = parseRepositoryReference(params.repositoryUrl);
+  if (!companyId || !repository) {
+    return void 0;
+  }
+  return getSyncableMappings(mappings).find((mapping) => {
+    if (normalizeCompanyId(mapping.companyId) !== companyId) {
+      return false;
+    }
+    const mappingRepository = parseRepositoryReference(mapping.repositoryUrl);
+    return Boolean(mappingRepository && areRepositoriesEqual(mappingRepository, repository));
+  });
+}
+async function patchPaperclipIssueForGitHubIssueTransfer(ctx, params) {
+  const nextDescription = buildPaperclipIssueDescription(params.githubIssue, []);
+  const nextOriginId = normalizeGitHubIssueHtmlUrl(params.githubIssue.htmlUrl) ?? params.githubIssue.htmlUrl;
+  const descriptionUpdated = normalizeIssueDescriptionValue(params.currentDescription) !== nextDescription;
+  const patch = {
+    projectId: params.projectId,
+    originKind: GITHUB_ISSUE_ORIGIN_KIND,
+    originId: nextOriginId,
+    ...descriptionUpdated ? { description: nextDescription } : {}
+  };
+  let issueUpdated = false;
+  if (params.paperclipApiBaseUrl) {
+    try {
+      const response = await fetchPaperclipApi(
+        getPaperclipIssueEndpoint(params.paperclipApiBaseUrl, params.issueId),
+        {
+          method: "PATCH",
+          headers: {
+            accept: "application/json",
+            "content-type": "application/json"
+          },
+          body: JSON.stringify(patch)
+        },
+        {
+          companyId: params.companyId
+        }
+      );
+      const payloadResult = await readPaperclipApiJsonResponse(response, {
+        operationLabel: "issue update",
+        bodyRequired: false
+      });
+      issueUpdated = !payloadResult.failure;
+    } catch {
+      issueUpdated = false;
+    }
+  }
+  if (!issueUpdated) {
+    await ctx.issues.update(
+      params.issueId,
+      patch,
+      params.companyId
+    );
+  }
+  return {
+    descriptionUpdated
+  };
+}
+async function moveImportedIssueToTransferredGitHubMapping(ctx, params) {
+  const companyId = normalizeCompanyId(params.targetMapping.companyId);
+  const projectId = normalizeOptionalString2(params.targetMapping.paperclipProjectId);
+  if (!companyId || !projectId) {
+    return {
+      updatedDescriptionsCount: 0
+    };
+  }
+  const paperclipIssue = await ctx.issues.get(params.importedIssue.paperclipIssueId, companyId);
+  if (!paperclipIssue) {
+    return {
+      updatedDescriptionsCount: 0
+    };
+  }
+  const transferPatchResult = await patchPaperclipIssueForGitHubIssueTransfer(ctx, {
+    companyId,
+    issueId: params.importedIssue.paperclipIssueId,
+    projectId,
+    githubIssue: params.githubIssue,
+    currentDescription: paperclipIssue.description,
+    paperclipApiBaseUrl: params.paperclipApiBaseUrl
+  });
+  const nextGitHubIssueUrl = normalizeGitHubIssueHtmlUrl(params.githubIssue.htmlUrl) ?? params.githubIssue.htmlUrl;
+  const existingLinks = await listGitHubIssueLinkRecords(ctx, {
+    paperclipIssueId: params.importedIssue.paperclipIssueId
+  });
+  const unlinkedAt = (/* @__PURE__ */ new Date()).toISOString();
+  for (const link of existingLinks) {
+    if ((!link.data.companyId || link.data.companyId === companyId) && link.data.githubIssueUrl !== nextGitHubIssueUrl) {
+      await tombstoneGitHubIssueLinkRecord(ctx, link, unlinkedAt);
+    }
+  }
+  await upsertGitHubIssueLinkRecord(
+    ctx,
+    params.targetMapping,
+    params.importedIssue.paperclipIssueId,
+    params.githubIssue,
+    []
+  );
+  upsertImportedIssueRecord(
+    params.nextRegistry,
+    buildImportedIssueRecord(
+      params.targetMapping,
+      params.githubIssue,
+      params.importedIssue.paperclipIssueId,
+      params.importedIssue.importedAt
+    )
+  );
+  invalidateGitHubLinkCachesForTarget({
+    companyId,
+    projectId: params.sourceMapping.paperclipProjectId ?? paperclipIssue.projectId ?? void 0,
+    repositoryUrl: params.sourceMapping.repositoryUrl
+  });
+  invalidateGitHubLinkCachesForTarget({
+    companyId,
+    projectId,
+    repositoryUrl: params.targetMapping.repositoryUrl
+  });
+  return {
+    updatedDescriptionsCount: transferPatchResult.descriptionUpdated ? 1 : 0
+  };
+}
+function buildUnmappedTransferredIssueCancellationComment(params) {
+  return `GitHub Sync updated the status from \`${formatPaperclipIssueStatus(params.previousStatus)}\` to \`${formatPaperclipIssueStatus(params.nextStatus)}\` because the linked GitHub issue was transferred to \`${formatRepositoryLabel(params.transferredRepository)}\`, which is not mapped to a Paperclip project. The GitHub link was removed so sync will stop updating this Paperclip issue.`;
+}
+async function cancelUnmappedTransferredGitHubIssue(ctx, params) {
+  const companyId = normalizeCompanyId(params.mapping.companyId);
+  if (!companyId) {
+    return {
+      updatedStatusesCount: 0
+    };
+  }
+  const paperclipIssue = await ctx.issues.get(params.importedIssue.paperclipIssueId, companyId);
+  if (!paperclipIssue) {
+    return {
+      updatedStatusesCount: 0
+    };
+  }
+  await unlinkPaperclipIssueFromGitHub(ctx, {
+    companyId,
+    issueId: params.importedIssue.paperclipIssueId
+  });
+  const nextStatus = "cancelled";
+  await updatePaperclipIssueState(ctx, {
+    companyId,
+    issueId: params.importedIssue.paperclipIssueId,
+    currentStatus: paperclipIssue.status,
+    syncContext: getPaperclipIssueSyncContext(paperclipIssue),
+    nextStatus,
+    transitionComment: buildUnmappedTransferredIssueCancellationComment({
+      previousStatus: paperclipIssue.status,
+      nextStatus,
+      transferredRepository: params.transferredRepository
+    }),
+    paperclipApiBaseUrl: params.paperclipApiBaseUrl
+  });
+  return {
+    updatedStatusesCount: paperclipIssue.status === nextStatus ? 0 : 1
+  };
+}
+async function fetchTransferredGitHubIssueForImportedRecord(octokit, repository, importedIssue) {
+  if (importedIssue.githubIssueNumber === void 0) {
+    return null;
+  }
+  const response = await octokit.rest.issues.get({
+    owner: repository.owner,
+    repo: repository.repo,
+    issue_number: importedIssue.githubIssueNumber,
+    headers: {
+      accept: "application/vnd.github+json",
+      "X-GitHub-Api-Version": GITHUB_API_VERSION
+    }
+  });
+  const rawIssue = response.data;
+  if (rawIssue.pull_request) {
+    return null;
+  }
+  const githubIssue = normalizeGitHubIssueRecord(rawIssue);
+  const transferredIssueReference = getGitHubIssueRepositoryReference(githubIssue);
+  const transferredRepository = transferredIssueReference ? parseRepositoryReference(transferredIssueReference.repositoryUrl) : void 0;
+  if (!transferredRepository || areRepositoriesEqual(repository, transferredRepository)) {
+    return null;
+  }
+  return {
+    githubIssue,
+    transferredRepository
+  };
+}
+async function reconcileTransferredImportedIssues(ctx, params) {
+  let updatedStatusesCount = 0;
+  let updatedDescriptionsCount = 0;
+  for (const importedIssue of params.importedIssues) {
+    if (params.allIssuesById.has(importedIssue.githubIssueId)) {
+      continue;
+    }
+    try {
+      updateSyncFailureContext(params.syncFailureContext, {
+        phase: "evaluating_github_status",
+        repositoryUrl: params.sourceRepository.url,
+        githubIssueNumber: importedIssue.githubIssueNumber
+      });
+      const transfer = await fetchTransferredGitHubIssueForImportedRecord(
+        params.octokit,
+        params.sourceRepository,
+        importedIssue
+      );
+      if (!transfer) {
+        continue;
+      }
+      const targetMapping = findTransferredIssueTargetMapping(params.allMappings, {
+        companyId: params.sourceMapping.companyId,
+        repositoryUrl: transfer.transferredRepository.url
+      });
+      if (targetMapping) {
+        const moveResult = await moveImportedIssueToTransferredGitHubMapping(ctx, {
+          sourceMapping: params.sourceMapping,
+          targetMapping,
+          importedIssue,
+          githubIssue: transfer.githubIssue,
+          nextRegistry: params.nextRegistry,
+          paperclipApiBaseUrl: params.paperclipApiBaseUrl
+        });
+        updatedDescriptionsCount += moveResult.updatedDescriptionsCount;
+        continue;
+      }
+      const cancelResult = await cancelUnmappedTransferredGitHubIssue(ctx, {
+        mapping: params.sourceMapping,
+        importedIssue,
+        transferredRepository: transfer.transferredRepository,
+        paperclipApiBaseUrl: params.paperclipApiBaseUrl
+      });
+      for (let index = params.nextRegistry.length - 1; index >= 0; index -= 1) {
+        const entry = params.nextRegistry[index];
+        if (entry?.paperclipIssueId === importedIssue.paperclipIssueId && (!entry.companyId || entry.companyId === params.sourceMapping.companyId)) {
+          params.nextRegistry.splice(index, 1);
+        }
+      }
+      updatedStatusesCount += cancelResult.updatedStatusesCount;
+    } catch (error) {
+      if (isGitHubRateLimitError(error)) {
+        throw error;
+      }
+      recordRecoverableSyncFailure(ctx, params.failures, error, params.syncFailureContext);
+      continue;
+    }
+  }
+  return {
+    updatedStatusesCount,
+    updatedDescriptionsCount
+  };
+}
 async function synchronizePaperclipIssueStatuses(ctx, octokit, repository, mapping, advancedSettings, allIssuesById, importedIssues, createdIssueIds, availableLabels, paperclipApiBaseUrl, linkedPullRequestsByIssueNumber, issueStatusSnapshotCache, pullRequestStatusCache, repositoryMaintainerCache, syncFailureContext, failures, assertNotCancelled, onGitHubIssueClosed, onProgress) {
   if (!mapping.companyId || !ctx.issues || typeof ctx.issues.get !== "function" || typeof ctx.issues.update !== "function") {
     return {
@@ -8624,7 +9045,7 @@ async function synchronizePaperclipIssueStatuses(ctx, octokit, repository, mappi
         paperclipIssueSyncContext,
         advancedSettings
       );
-      const nextStatus = resolvePaperclipIssueStatus({
+      let nextStatus = resolvePaperclipIssueStatus({
         currentStatus: paperclipIssue.status,
         snapshot,
         hasTrustedNewComment,
@@ -8633,12 +9054,21 @@ async function synchronizePaperclipIssueStatuses(ctx, octokit, repository, mappi
         maintainerAuthoredImportedIssue,
         hasExecutorHandoffTarget: Boolean(executorTransitionAssignee)
       });
+      if (paperclipIssue.status === "blocked" && nextStatus !== "blocked" && await hasUnresolvedPaperclipIssueBlocker(ctx, paperclipIssue, mapping.companyId)) {
+        nextStatus = "blocked";
+      }
       const shouldPreserveMaintainerWaitRouting = isHealthyMaintainerWaitTransition({
         currentStatus: paperclipIssue.status,
         nextStatus,
         syncContext: paperclipIssueSyncContext
       });
-      const nextTransitionAssignee = resolveSyncTransitionAssignee({
+      const shouldPreserveImportedTriageRouting = shouldPreserveImportedTriageAssignee({
+        currentStatus: paperclipIssue.status,
+        nextStatus,
+        wasImportedThisRun,
+        maintainerAuthoredImportedIssue
+      });
+      const nextTransitionAssignee = shouldPreserveImportedTriageRouting ? null : resolveSyncTransitionAssignee({
         currentStatus: paperclipIssue.status,
         nextStatus,
         syncContext: paperclipIssueSyncContext,
@@ -8646,7 +9076,7 @@ async function synchronizePaperclipIssueStatuses(ctx, octokit, repository, mappi
       });
       const shouldClearTransitionAssignee = nextStatus === "in_review" && (nextTransitionAssignee === null || shouldPreserveMaintainerWaitRouting) && paperclipIssueSyncContext.assignee !== null;
       const nextAssigneeChanged = nextTransitionAssignee ? !doesPaperclipIssueAssigneeMatch(paperclipIssueSyncContext.assignee, nextTransitionAssignee.principal) : false;
-      const shouldWakeImportedAssignee = wasImportedThisRun && paperclipIssue.status === nextStatus && nextStatus === "todo" && paperclipIssueSyncContext.assignee?.kind === "agent";
+      const shouldWakeImportedAssignee = wasImportedThisRun && nextStatus === "todo" && (paperclipIssue.status === nextStatus || shouldPreserveImportedTriageRouting) && paperclipIssueSyncContext.assignee?.kind === "agent";
       const shouldWakeTransitionAssignee = paperclipIssue.status !== nextStatus && nextTransitionAssignee?.principal.kind === "agent" && isActionablePaperclipIssueStatus(nextStatus) && (nextAssigneeChanged || paperclipIssue.status !== nextStatus);
       importedIssue.githubIssueNumber = githubIssue.number;
       importedIssue.lastSeenCommentCount = snapshot.commentCount;
@@ -8708,6 +9138,14 @@ async function synchronizePaperclipIssueStatuses(ctx, octokit, repository, mappi
         paperclipApiBaseUrl
       });
       updatedStatusesCount += 1;
+      if (shouldWakeImportedAssignee) {
+        queuedIssueWakeups.push({
+          assigneeAgentId: paperclipIssueSyncContext.assignee?.kind === "agent" ? paperclipIssueSyncContext.assignee.id : null,
+          paperclipIssueId: importedIssue.paperclipIssueId,
+          reason: IMPORTED_ISSUE_WAKE_REASON,
+          mutation: "import"
+        });
+      }
       if (shouldWakeTransitionAssignee && nextTransitionAssignee?.principal.kind === "agent") {
         queuedIssueWakeups.push({
           assigneeAgentId: nextTransitionAssignee.principal.id,
@@ -8821,11 +9259,14 @@ async function synchronizePaperclipPullRequestIssueStatuses(ctx, octokit, mappin
         paperclipIssueSyncContext,
         advancedSettings
       );
-      const nextStatus = resolvePaperclipPullRequestIssueStatus({
+      let nextStatus = resolvePaperclipPullRequestIssueStatus({
         currentStatus: paperclipIssue.status,
         pullRequest,
         hasExecutorHandoffTarget: Boolean(executorTransitionAssignee)
       });
+      if (paperclipIssue.status === "blocked" && nextStatus !== "blocked" && await hasUnresolvedPaperclipIssueBlocker(ctx, paperclipIssue, mapping.companyId)) {
+        nextStatus = "blocked";
+      }
       const shouldPreserveMaintainerWaitRouting = isHealthyMaintainerWaitTransition({
         currentStatus: paperclipIssue.status,
         nextStatus,
@@ -12723,6 +13164,22 @@ async function performSync(ctx, trigger, options = {}) {
             await persistRunningProgress(issueIndex === issues.length - 1);
           }
         }
+        const transferReconciliationResult = await reconcileTransferredImportedIssues(ctx, {
+          octokit,
+          sourceMapping: mapping,
+          sourceRepository: repository,
+          allMappings: settings.mappings,
+          importedIssues: [...importRegistryByIssueId.values()].filter(
+            (importedIssue) => doesImportedIssueMatchTarget(importedIssue, options.target)
+          ),
+          allIssuesById,
+          nextRegistry,
+          paperclipApiBaseUrl,
+          syncFailureContext: failureContext,
+          failures: recoverableFailures
+        });
+        updatedStatusesCount += transferReconciliationResult.updatedStatusesCount;
+        updatedDescriptionsCount += transferReconciliationResult.updatedDescriptionsCount;
         const importedIssuesForSynchronization = [...importRegistryByIssueId.values()].filter(
           (importedIssue) => allIssuesById.has(importedIssue.githubIssueId) && doesImportedIssueMatchTarget(importedIssue, options.target)
         );
@@ -14008,6 +14465,18 @@ var plugin = definePlugin({
         requireUnlinked: true
       });
     });
+    ctx.actions.register("issue.unlinkGitHubItem", async (input) => {
+      const record = input && typeof input === "object" ? input : {};
+      const companyId = normalizeCompanyId(record.companyId);
+      const issueId = normalizeOptionalString2(record.issueId);
+      if (!companyId || !issueId) {
+        throw new Error("companyId and issueId are required.");
+      }
+      return unlinkPaperclipIssueFromGitHub(ctx, {
+        companyId,
+        issueId
+      });
+    });
     ctx.actions.register("settings.saveRegistration", async (input) => {
       const previous = normalizeSettings(await ctx.state.get(SETTINGS_SCOPE));
       const config = await getResolvedConfig(ctx);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paperclip-github-plugin",
-  "version": "0.8.2",
+  "version": "0.8.4",
   "description": "Paperclip plugin for synchronizing GitHub issues into Paperclip projects.",
   "license": "Apache-2.0",
   "type": "module",