paperclip-github-plugin 0.3.3 → 0.3.5

package/dist/worker.js

@@ -15,6 +15,10 @@ var repositoryProperty = {
   type: "string",
   description: "GitHub repository as owner/repo or https://github.com/owner/repo. Omit when the current Paperclip project has exactly one mapped repository."
 };
+var organizationProperty = {
+  type: "string",
+  description: "GitHub organization login that owns the Projects."
+};
 var paperclipIssueIdProperty = {
   type: "string",
   description: "Paperclip issue id used to infer the linked GitHub issue and repository when available."
@@ -29,6 +33,15 @@ var pullRequestNumberProperty = {
   minimum: 1,
   description: "GitHub pull request number."
 };
+var projectIdProperty = {
+  type: "string",
+  description: "GitHub ProjectV2 node id. You can use the id returned by list_organization_projects."
+};
+var projectNumberProperty = {
+  type: "integer",
+  minimum: 1,
+  description: "GitHub organization project number. Requires organization when projectId is not provided."
+};
 var llmModelProperty = {
   type: "string",
   description: "Exact LLM name used to draft the comment. Required so the plugin can append the mandatory AI-authorship footer."
@@ -53,6 +66,16 @@ var pullRequestTargetSchema = {
     }
   ]
 };
+var organizationProjectTargetSchema = {
+  anyOf: [
+    {
+      required: ["projectId"]
+    },
+    {
+      required: ["organization", "projectNumber"]
+    }
+  ]
+};
 var GITHUB_AGENT_TOOLS = [
   {
     name: "search_repository_items",
@@ -436,6 +459,51 @@ var GITHUB_AGENT_TOOLS = [
         }
       ]
     }
+  },
+  {
+    name: "list_organization_projects",
+    displayName: "List Organization Projects",
+    description: "List GitHub organization-level Projects so an agent can choose where to associate pull requests.",
+    parametersSchema: {
+      type: "object",
+      additionalProperties: false,
+      required: ["organization"],
+      properties: {
+        organization: organizationProperty,
+        includeClosed: {
+          type: "boolean",
+          description: "Include closed Projects in the results. Defaults to false."
+        },
+        query: {
+          type: "string",
+          description: "Optional free-text filter matched against project titles and descriptions after loading the organization projects."
+        },
+        limit: {
+          type: "integer",
+          minimum: 1,
+          maximum: 100,
+          description: "Maximum number of projects to return."
+        }
+      }
+    }
+  },
+  {
+    name: "add_pull_request_to_project",
+    displayName: "Add Pull Request To Project",
+    description: "Associate a GitHub pull request with an organization-level GitHub Project.",
+    parametersSchema: {
+      type: "object",
+      additionalProperties: false,
+      allOf: [pullRequestTargetSchema, organizationProjectTargetSchema],
+      properties: {
+        repository: repositoryProperty,
+        pullRequestNumber: pullRequestNumberProperty,
+        paperclipIssueId: paperclipIssueIdProperty,
+        projectId: projectIdProperty,
+        organization: organizationProperty,
+        projectNumber: projectNumberProperty
+      }
+    }
   }
 ];
 function getGitHubAgentToolDeclaration(name) {
@@ -560,6 +628,8 @@ var ISSUE_LINK_ENTITY_TYPE = "paperclip-github-plugin.issue-link";
 var PULL_REQUEST_LINK_ENTITY_TYPE = "paperclip-github-plugin.pull-request-link";
 var COMMENT_ANNOTATION_ENTITY_TYPE = "paperclip-github-plugin.comment-annotation";
 var AI_AUTHORED_COMMENT_FOOTER_PREFIX = "Created by a Paperclip AI agent using ";
+var HIDDEN_GITHUB_IMPORT_MARKER_PREFIX = "<!-- paperclip-github-plugin-imported-from: ";
+var HIDDEN_GITHUB_IMPORT_MARKER_SUFFIX = " -->";
 function normalizeCompanyId(value) {
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
@@ -638,6 +708,7 @@ var FAILED_CHECK_RUN_CONCLUSIONS = /* @__PURE__ */ new Set([
 var SUCCESSFUL_STATUS_CONTEXT_STATES = /* @__PURE__ */ new Set(["SUCCESS"]);
 var FAILED_STATUS_CONTEXT_STATES = /* @__PURE__ */ new Set(["ERROR", "FAILURE"]);
 var PENDING_STATUS_CONTEXT_STATES = /* @__PURE__ */ new Set(["EXPECTED", "PENDING"]);
+var GITHUB_REPOSITORY_MAINTAINER_WARMUP_CONCURRENCY = 4;
 var GITHUB_REPOSITORY_MAINTAINER_ROLE_NAMES = /* @__PURE__ */ new Set(["admin", "maintain"]);
 var GITHUB_ISSUE_STATUS_SNAPSHOT_QUERY = `
   query GitHubIssueStatusSnapshot($owner: String!, $repo: String!, $issueNumber: Int!, $after: String) {
@@ -1037,6 +1108,114 @@ var GITHUB_PULL_REQUEST_REVIEW_THREADS_DETAILED_QUERY = `
     }
   }
 `;
+var GITHUB_ORGANIZATION_PROJECTS_QUERY = `
+  query GitHubOrganizationProjects($organization: String!, $after: String, $first: Int!) {
+    organization(login: $organization) {
+      projectsV2(first: $first, after: $after, orderBy: { field: UPDATED_AT, direction: DESC }) {
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+        nodes {
+          id
+          number
+          title
+          shortDescription
+          url
+          closed
+          updatedAt
+        }
+      }
+    }
+  }
+`;
+var GITHUB_ORGANIZATION_PROJECT_BY_NUMBER_QUERY = `
+  query GitHubOrganizationProjectByNumber($organization: String!, $projectNumber: Int!) {
+    organization(login: $organization) {
+      projectV2(number: $projectNumber) {
+        id
+        number
+        title
+        url
+        closed
+        owner {
+          __typename
+          ... on Organization {
+            login
+          }
+          ... on User {
+            login
+          }
+        }
+      }
+    }
+  }
+`;
+var GITHUB_PULL_REQUEST_PROJECT_ITEMS_QUERY = `
+  query GitHubPullRequestProjectItems($owner: String!, $repo: String!, $pullRequestNumber: Int!, $after: String) {
+    repository(owner: $owner, name: $repo) {
+      pullRequest(number: $pullRequestNumber) {
+        id
+        number
+        title
+        url
+        projectItems(first: 100, after: $after) {
+          pageInfo {
+            hasNextPage
+            endCursor
+          }
+          nodes {
+            id
+            project {
+              id
+              number
+              title
+              url
+              closed
+              owner {
+                __typename
+                ... on Organization {
+                  login
+                }
+                ... on User {
+                  login
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+var GITHUB_ADD_PULL_REQUEST_TO_PROJECT_MUTATION = `
+  mutation GitHubAddPullRequestToProject($projectId: ID!, $contentId: ID!) {
+    addProjectV2ItemById(input: {
+      projectId: $projectId
+      contentId: $contentId
+    }) {
+      item {
+        id
+        project {
+          id
+          number
+          title
+          url
+          closed
+          owner {
+            __typename
+            ... on Organization {
+              login
+            }
+            ... on User {
+              login
+            }
+          }
+        }
+      }
+    }
+  }
+`;
 var GITHUB_ADD_PULL_REQUEST_REVIEW_THREAD_REPLY_MUTATION = `
   mutation GitHubAddPullRequestReviewThreadReply($pullRequestReviewThreadId: ID!, $body: String!) {
     addPullRequestReviewThreadReply(input: {
@@ -1990,8 +2169,8 @@ function doesImportedIssueMatchTarget(issue, target) {
   }
   return target.issueId !== void 0 && issue.paperclipIssueId === target.issueId || target.githubIssueId !== void 0 && issue.githubIssueId === target.githubIssueId || target.githubIssueNumber !== void 0 && issue.githubIssueNumber === target.githubIssueNumber;
 }
-async function resolvePaperclipIssueGitHubLink(ctx, issueId, companyId) {
-  const linkRecords = await listGitHubIssueLinkRecords(ctx, {
+async function resolvePaperclipIssueGitHubLink(ctx, issueId, companyId, options = {}) {
+  const linkRecords = options.linkRecords ?? await listGitHubIssueLinkRecords(ctx, {
     paperclipIssueId: issueId
   });
   const entityMatch = linkRecords.find((record) => !record.data.companyId || record.data.companyId === companyId);
@@ -2004,7 +2183,8 @@ async function resolvePaperclipIssueGitHubLink(ctx, issueId, companyId) {
       githubIssueId: entityMatch.data.githubIssueId,
       githubIssueNumber: entityMatch.data.githubIssueNumber,
       githubIssueUrl: entityMatch.data.githubIssueUrl,
-      linkedPullRequestNumbers: entityMatch.data.linkedPullRequestNumbers
+      linkedPullRequestNumbers: entityMatch.data.linkedPullRequestNumbers,
+      entityRecord: entityMatch
     };
   }
   const importRegistry = normalizeImportRegistry(await ctx.state.get(IMPORT_REGISTRY_SCOPE));
@@ -2017,7 +2197,7 @@ async function resolvePaperclipIssueGitHubLink(ctx, issueId, companyId) {
       registryMatch.githubIssueNumber
     );
     if (githubIssueUrl2) {
-      return {
+      const fallbackLink2 = {
         source: "import_registry",
         companyId: registryMatch.companyId,
         paperclipProjectId: registryMatch.paperclipProjectId,
@@ -2027,15 +2207,16 @@ async function resolvePaperclipIssueGitHubLink(ctx, issueId, companyId) {
         githubIssueUrl: githubIssueUrl2,
         linkedPullRequestNumbers: []
       };
+      return await hydrateRecoveredPaperclipIssueGitHubLink(ctx, issueId, fallbackLink2) ?? fallbackLink2;
     }
   }
-  const issue = await ctx.issues.get(issueId, companyId);
+  const issue = options.paperclipIssue ?? await ctx.issues.get(issueId, companyId);
   const githubIssueUrl = extractImportedGitHubIssueUrlFromDescription(issue?.description);
   const githubIssueReference = githubIssueUrl ? parseGitHubIssueHtmlUrl(githubIssueUrl) : null;
   if (!githubIssueReference) {
     return null;
   }
-  return {
+  const fallbackLink = {
     source: "description",
     companyId,
     paperclipProjectId: issue?.projectId ?? void 0,
@@ -2044,6 +2225,73 @@ async function resolvePaperclipIssueGitHubLink(ctx, issueId, companyId) {
     githubIssueUrl: githubIssueReference.issueUrl,
     linkedPullRequestNumbers: []
   };
+  return await hydrateRecoveredPaperclipIssueGitHubLink(ctx, issueId, fallbackLink) ?? fallbackLink;
+}
+async function hydrateRecoveredPaperclipIssueGitHubLink(ctx, issueId, fallbackLink) {
+  const repository = parseRepositoryReference(fallbackLink.repositoryUrl);
+  if (!repository) {
+    return null;
+  }
+  let octokit;
+  try {
+    octokit = await createGitHubToolOctokit(ctx);
+  } catch {
+    return null;
+  }
+  try {
+    const response = await octokit.rest.issues.get({
+      owner: repository.owner,
+      repo: repository.repo,
+      issue_number: fallbackLink.githubIssueNumber,
+      headers: {
+        "X-GitHub-Api-Version": GITHUB_API_VERSION
+      }
+    });
+    const githubIssue = normalizeGitHubIssueRecord(response.data);
+    const linkedPullRequests = await listLinkedPullRequestsForIssue(octokit, repository, githubIssue.number);
+    const linkedPullRequestNumbers = linkedPullRequests.map((pullRequest) => pullRequest.number);
+    const entityRecord = buildGitHubIssueLinkRecord(
+      {
+        companyId: fallbackLink.companyId,
+        paperclipProjectId: fallbackLink.paperclipProjectId,
+        repositoryUrl: fallbackLink.repositoryUrl
+      },
+      issueId,
+      githubIssue,
+      linkedPullRequestNumbers
+    );
+    await upsertGitHubIssueLinkRecord(
+      ctx,
+      {
+        companyId: fallbackLink.companyId,
+        paperclipProjectId: fallbackLink.paperclipProjectId,
+        repositoryUrl: fallbackLink.repositoryUrl
+      },
+      issueId,
+      githubIssue,
+      linkedPullRequestNumbers
+    );
+    return {
+      source: "entity",
+      companyId: fallbackLink.companyId,
+      paperclipProjectId: fallbackLink.paperclipProjectId,
+      repositoryUrl: fallbackLink.repositoryUrl,
+      githubIssueId: githubIssue.id,
+      githubIssueNumber: githubIssue.number,
+      githubIssueUrl: normalizeGitHubIssueHtmlUrl(githubIssue.htmlUrl) ?? githubIssue.htmlUrl,
+      linkedPullRequestNumbers,
+      entityRecord
+    };
+  } catch (error) {
+    ctx.logger.warn("Unable to hydrate recovered GitHub issue metadata for a Paperclip issue fallback link.", {
+      issueId,
+      companyId: fallbackLink.companyId,
+      repositoryUrl: fallbackLink.repositoryUrl,
+      githubIssueNumber: fallbackLink.githubIssueNumber,
+      error: getErrorMessage(error)
+    });
+    return null;
+  }
 }
 async function resolveManualSyncTarget(ctx, settings, input) {
   if (input.issueId) {
@@ -2232,7 +2480,13 @@ async function buildIssueGitHubDetails(ctx, input) {
   const linkRecords = await listGitHubIssueLinkRecords(ctx, {
     paperclipIssueId: issueId
   });
-  const entityMatch = linkRecords.find((record) => !record.data.companyId || record.data.companyId === companyId);
+  const link = await resolvePaperclipIssueGitHubLink(ctx, issueId, companyId, {
+    linkRecords
+  });
+  if (!link) {
+    return null;
+  }
+  const entityMatch = link.entityRecord;
   if (entityMatch) {
     return {
       paperclipIssueId: issueId,
@@ -2248,17 +2502,13 @@ async function buildIssueGitHubDetails(ctx, input) {
       syncedAt: entityMatch.data.syncedAt
     };
   }
-  const fallbackLink = await resolvePaperclipIssueGitHubLink(ctx, issueId, companyId);
-  if (!fallbackLink) {
-    return null;
-  }
   return {
     paperclipIssueId: issueId,
-    source: fallbackLink.source,
-    githubIssueNumber: fallbackLink.githubIssueNumber,
-    githubIssueUrl: fallbackLink.githubIssueUrl,
-    repositoryUrl: fallbackLink.repositoryUrl,
-    linkedPullRequestNumbers: fallbackLink.linkedPullRequestNumbers
+    source: link.source,
+    githubIssueNumber: link.githubIssueNumber,
+    githubIssueUrl: link.githubIssueUrl,
+    repositoryUrl: link.repositoryUrl,
+    linkedPullRequestNumbers: link.linkedPullRequestNumbers
   };
 }
 async function resolveIssueByIdentifier(ctx, input) {
@@ -3542,7 +3792,7 @@ function normalizePaperclipIssueStatus(value) {
   return PAPERCLIP_ISSUE_STATUSES.includes(value) ? value : void 0;
 }
 function describeGitHubStatusTransitionReason(params) {
-  const { snapshot, previousCommentCount, hasTrustedNewComment } = params;
+  const { snapshot, previousCommentCount, hasTrustedNewComment, maintainerAuthoredImportedIssue } = params;
   if (snapshot.state === "closed") {
     switch (snapshot.stateReason) {
       case "duplicate":
@@ -3558,6 +3808,9 @@ function describeGitHubStatusTransitionReason(params) {
     return "a new GitHub comment from the issue author or a repository maintainer was added";
   }
   if (snapshot.linkedPullRequests.length === 0) {
+    if (maintainerAuthoredImportedIssue) {
+      return "the GitHub issue is open with no linked pull requests and was created by a repository maintainer";
+    }
     return "the GitHub issue is open with no linked pull requests";
   }
   const linkedPullRequestSubject = snapshot.linkedPullRequests.length === 1 ? "the linked pull request" : "linked pull requests";
@@ -3596,11 +3849,20 @@ function buildStatusTransitionCommentAnnotation(params) {
   };
 }
 function buildPaperclipIssueStatusTransitionComment(params) {
-  const { previousStatus, nextStatus, repository, snapshot, previousCommentCount, hasTrustedNewComment } = params;
+  const {
+    previousStatus,
+    nextStatus,
+    repository,
+    snapshot,
+    previousCommentCount,
+    hasTrustedNewComment,
+    maintainerAuthoredImportedIssue
+  } = params;
   const reason = describeGitHubStatusTransitionReason({
     snapshot,
     previousCommentCount,
-    hasTrustedNewComment
+    hasTrustedNewComment,
+    maintainerAuthoredImportedIssue
   });
   return {
     body: `GitHub Sync updated the status from \`${formatPaperclipIssueStatus(previousStatus)}\` to \`${formatPaperclipIssueStatus(nextStatus)}\` because ${reason}.`,
@@ -3620,7 +3882,8 @@ function resolvePaperclipIssueStatus(params) {
     previousCommentCount,
     hasTrustedNewComment,
     wasImportedThisRun,
-    defaultImportedStatus
+    defaultImportedStatus,
+    maintainerAuthoredImportedIssue
   } = params;
   if (snapshot.state === "closed") {
     return snapshot.stateReason === "duplicate" || snapshot.stateReason === "not_planned" ? "cancelled" : "done";
@@ -3636,10 +3899,10 @@ function resolvePaperclipIssueStatus(params) {
     return resolvePaperclipStatusFromLinkedPullRequests(snapshot.linkedPullRequests);
   }
   if (wasImportedThisRun) {
-    return defaultImportedStatus;
+    return maintainerAuthoredImportedIssue ? "todo" : defaultImportedStatus;
   }
   if (currentStatus === "done" || currentStatus === "cancelled") {
-    return "backlog";
+    return "todo";
   }
   return currentStatus;
 }
@@ -4043,6 +4306,40 @@ async function hasTrustedNewGitHubIssueComment(params) {
   }
   return false;
 }
+async function isMaintainerAuthoredGitHubIssue(params) {
+  const authorLogin = normalizeGitHubUserLogin(params.githubIssue.authorLogin);
+  if (!authorLogin) {
+    return false;
+  }
+  return isGitHubUserRepositoryMaintainer(
+    params.octokit,
+    params.repository,
+    authorLogin,
+    params.maintainerCache
+  );
+}
+async function warmGitHubRepositoryMaintainerCache(params) {
+  const uniqueAuthorLogins = [...new Set(
+    params.githubIssues.map((issue) => normalizeGitHubUserLogin(issue.authorLogin)).filter((authorLogin) => Boolean(authorLogin))
+  )].filter((authorLogin) => !params.maintainerCache.has(buildGitHubRepositoryActorCacheKey(params.repository, authorLogin)));
+  if (uniqueAuthorLogins.length === 0) {
+    return;
+  }
+  await mapWithConcurrency(uniqueAuthorLogins, GITHUB_REPOSITORY_MAINTAINER_WARMUP_CONCURRENCY, async (authorLogin) => {
+    try {
+      await isGitHubUserRepositoryMaintainer(
+        params.octokit,
+        params.repository,
+        authorLogin,
+        params.maintainerCache
+      );
+    } catch (error) {
+      if (isGitHubRateLimitError(error)) {
+        throw error;
+      }
+    }
+  });
+}
 function parseGitHubIssueHtmlUrl(value) {
   try {
     const url = new URL(value.trim());
@@ -4068,6 +4365,15 @@ function parseGitHubIssueHtmlUrl(value) {
 function normalizeGitHubIssueHtmlUrl(value) {
   return parseGitHubIssueHtmlUrl(value)?.issueUrl;
 }
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function getHiddenGitHubImportMarkerPattern() {
+  return new RegExp(
+    `${escapeRegExp(HIDDEN_GITHUB_IMPORT_MARKER_PREFIX)}(\\S+?)${escapeRegExp(HIDDEN_GITHUB_IMPORT_MARKER_SUFFIX)}`,
+    "i"
+  );
+}
 function normalizeLinkedPullRequestNumbers(values) {
   return [...new Set(
     values.filter((pullRequestNumber) => Number.isInteger(pullRequestNumber) && pullRequestNumber > 0)
@@ -4077,6 +4383,10 @@ function extractImportedGitHubIssueUrlFromDescription(description) {
   if (typeof description !== "string") {
     return void 0;
   }
+  const hiddenMarkerMatch = description.match(getHiddenGitHubImportMarkerPattern());
+  if (hiddenMarkerMatch) {
+    return normalizeGitHubIssueHtmlUrl(hiddenMarkerMatch[1]);
+  }
   const markdownMetadataMatch = description.match(/^\*\s+GitHub issue:\s+\[[^\]]+\]\(([^)]+)\)/m);
   if (markdownMetadataMatch) {
     return normalizeGitHubIssueHtmlUrl(markdownMetadataMatch[1]);
@@ -4219,8 +4529,27 @@ ${markdownImage}
 }
 function buildPaperclipIssueDescription(issue, linkedPullRequestNumbers = []) {
   const normalizedBody = normalizeGitHubIssueBodyForPaperclip(issue.body);
+  const hiddenImportMarker = buildHiddenGitHubImportMarker(issue.htmlUrl);
   void linkedPullRequestNumbers;
-  return normalizedBody ?? "";
+  if (!hiddenImportMarker) {
+    return normalizedBody ?? "";
+  }
+  if (!normalizedBody) {
+    return hiddenImportMarker;
+  }
+  return `${normalizedBody}
+
+${hiddenImportMarker}`;
+}
+function buildHiddenGitHubImportMarker(githubIssueUrl) {
+  if (typeof githubIssueUrl !== "string") {
+    return void 0;
+  }
+  const normalizedIssueUrl = normalizeGitHubIssueHtmlUrl(githubIssueUrl);
+  if (!normalizedIssueUrl) {
+    return void 0;
+  }
+  return `${HIDDEN_GITHUB_IMPORT_MARKER_PREFIX}${normalizedIssueUrl}${HIDDEN_GITHUB_IMPORT_MARKER_SUFFIX}`;
 }
 function normalizeIssueDescriptionValue(value) {
   return typeof value === "string" ? value : "";
@@ -4467,19 +4796,17 @@ async function findStoredStatusTransitionCommentAnnotation(ctx, params) {
   }
   return null;
 }
-async function upsertGitHubIssueLinkRecord(ctx, mapping, issueId, githubIssue, linkedPullRequestNumbers) {
+function buildGitHubIssueLinkRecord(target, issueId, githubIssue, linkedPullRequestNumbers) {
   const githubIssueUrl = normalizeGitHubIssueHtmlUrl(githubIssue.htmlUrl) ?? githubIssue.htmlUrl;
-  await ctx.entities.upsert({
-    entityType: ISSUE_LINK_ENTITY_TYPE,
-    scopeKind: "issue",
-    scopeId: issueId,
-    externalId: githubIssueUrl,
+  const repositoryUrl = parseRepositoryReference(target.repositoryUrl)?.url ?? target.repositoryUrl.trim();
+  return {
+    paperclipIssueId: issueId,
     title: `GitHub issue #${githubIssue.number}`,
     status: githubIssue.state,
     data: {
-      ...mapping.companyId ? { companyId: mapping.companyId } : {},
-      ...mapping.paperclipProjectId ? { paperclipProjectId: mapping.paperclipProjectId } : {},
-      repositoryUrl: getNormalizedMappingRepositoryUrl(mapping),
+      ...target.companyId ? { companyId: target.companyId } : {},
+      ...target.paperclipProjectId ? { paperclipProjectId: target.paperclipProjectId } : {},
+      repositoryUrl,
       githubIssueId: githubIssue.id,
       githubIssueNumber: githubIssue.number,
       githubIssueUrl,
@@ -4490,6 +4817,18 @@ async function upsertGitHubIssueLinkRecord(ctx, mapping, issueId, githubIssue, l
       labels: githubIssue.labels,
       syncedAt: (/* @__PURE__ */ new Date()).toISOString()
     }
+  };
+}
+async function upsertGitHubIssueLinkRecord(ctx, target, issueId, githubIssue, linkedPullRequestNumbers) {
+  const record = buildGitHubIssueLinkRecord(target, issueId, githubIssue, linkedPullRequestNumbers);
+  await ctx.entities.upsert({
+    entityType: ISSUE_LINK_ENTITY_TYPE,
+    scopeKind: "issue",
+    scopeId: issueId,
+    externalId: record.data.githubIssueUrl,
+    ...record.title ? { title: record.title } : {},
+    ...record.status ? { status: record.status } : {},
+    data: record.data
   });
 }
 async function upsertGitHubPullRequestLinkRecord(ctx, params) {
@@ -5795,13 +6134,21 @@ async function synchronizePaperclipIssueStatuses(ctx, octokit, repository, mappi
         currentCommentCount: snapshot.commentCount,
         maintainerCache: repositoryMaintainerCache
       });
+      const wasImportedThisRun = createdIssueIds.has(importedIssue.githubIssueId);
+      const maintainerAuthoredImportedIssue = wasImportedThisRun && advancedSettings.defaultStatus !== "todo" && snapshot.state === "open" && snapshot.linkedPullRequests.length === 0 ? await isMaintainerAuthoredGitHubIssue({
+        octokit,
+        repository,
+        githubIssue,
+        maintainerCache: repositoryMaintainerCache
+      }) : false;
       const nextStatus = resolvePaperclipIssueStatus({
         currentStatus: paperclipIssue.status,
         snapshot,
         previousCommentCount,
         hasTrustedNewComment,
-        wasImportedThisRun: createdIssueIds.has(importedIssue.githubIssueId),
-        defaultImportedStatus: advancedSettings.defaultStatus
+        wasImportedThisRun,
+        defaultImportedStatus: advancedSettings.defaultStatus,
+        maintainerAuthoredImportedIssue
       });
       importedIssue.githubIssueNumber = githubIssue.number;
       importedIssue.lastSeenCommentCount = snapshot.commentCount;
@@ -5814,7 +6161,8 @@ async function synchronizePaperclipIssueStatuses(ctx, octokit, repository, mappi
         repository,
         snapshot,
         previousCommentCount,
-        hasTrustedNewComment
+        hasTrustedNewComment,
+        maintainerAuthoredImportedIssue
       });
       updateSyncFailureContext(syncFailureContext, {
         phase: "updating_paperclip_status",
@@ -6381,6 +6729,170 @@ async function resolveGitHubPullRequestToolTarget(ctx, runCtx, input) {
     pullRequestNumber
   };
 }
+function normalizeGitHubProjectRecord(project, fallbackOwnerLogin) {
+  const id = normalizeOptionalString2(project?.id);
+  const title = normalizeOptionalString2(project?.title);
+  const url = normalizeOptionalString2(project?.url);
+  const number = typeof project?.number === "number" && Number.isInteger(project.number) && project.number > 0 ? Math.floor(project.number) : null;
+  if (!id || !title || !url || number === null) {
+    return null;
+  }
+  const shortDescription = normalizeOptionalString2(project?.shortDescription);
+  const updatedAt = normalizeOptionalString2(project?.updatedAt);
+  const ownerLogin = normalizeOptionalString2(project?.owner?.login) ?? fallbackOwnerLogin;
+  return {
+    id,
+    number,
+    title,
+    url,
+    closed: project?.closed === true,
+    ...shortDescription ? { shortDescription } : {},
+    ...updatedAt ? { updatedAt } : {},
+    ...ownerLogin ? { ownerLogin } : {}
+  };
+}
+function buildGitHubProjectToolData(project, options) {
+  return {
+    id: project.id,
+    number: project.number,
+    title: project.title,
+    ...project.shortDescription ? { shortDescription: project.shortDescription } : {},
+    url: project.url,
+    closed: project.closed,
+    ...project.updatedAt ? { updatedAt: project.updatedAt } : {},
+    ...options?.includeOwnerLogin && project.ownerLogin ? { ownerLogin: project.ownerLogin } : {}
+  };
+}
+function matchesGitHubProjectFilter(project, query) {
+  const normalizedQuery = normalizeOptionalString2(query)?.toLowerCase();
+  if (!normalizedQuery) {
+    return true;
+  }
+  return [project.title, project.shortDescription].filter((value) => Boolean(value)).some((value) => value.toLowerCase().includes(normalizedQuery));
+}
+async function listGitHubOrganizationProjects(octokit, organization, options) {
+  const normalizedOrganization = normalizeOptionalString2(organization);
+  if (!normalizedOrganization) {
+    throw new Error("organization is required.");
+  }
+  const includeClosed = options?.includeClosed === true;
+  const limit = Math.min(normalizeToolPositiveInteger(options?.limit) ?? 20, 100);
+  const projects = [];
+  let after;
+  do {
+    const response = await octokit.graphql(
+      GITHUB_ORGANIZATION_PROJECTS_QUERY,
+      {
+        organization: normalizedOrganization,
+        first: Math.min(50, Math.max(1, limit)),
+        after
+      }
+    );
+    if (!response.organization) {
+      throw new Error(`GitHub organization ${normalizedOrganization} was not found or is not visible to the configured token.`);
+    }
+    const connection = response.organization.projectsV2;
+    for (const node of connection?.nodes ?? []) {
+      const project = normalizeGitHubProjectRecord(node, normalizedOrganization);
+      if (!project) {
+        continue;
+      }
+      if (!includeClosed && project.closed) {
+        continue;
+      }
+      if (!matchesGitHubProjectFilter(project, options?.query)) {
+        continue;
+      }
+      projects.push(project);
+      if (projects.length >= limit) {
+        return projects;
+      }
+    }
+    after = getPageCursor(connection?.pageInfo);
+  } while (after);
+  return projects;
+}
+async function resolveGitHubProjectToolTarget(octokit, input) {
+  const explicitProjectId = normalizeOptionalString2(input.projectId);
+  if (explicitProjectId) {
+    return {
+      projectId: explicitProjectId
+    };
+  }
+  const organization = normalizeOptionalToolString(input.organization);
+  const projectNumber = normalizeToolPositiveInteger(input.projectNumber);
+  if (!organization || projectNumber === void 0) {
+    throw new Error("Provide either projectId or both organization and projectNumber.");
+  }
+  const response = await octokit.graphql(
+    GITHUB_ORGANIZATION_PROJECT_BY_NUMBER_QUERY,
+    {
+      organization,
+      projectNumber
+    }
+  );
+  const project = normalizeGitHubProjectRecord(response.organization?.projectV2, organization);
+  if (!project) {
+    throw new Error(`GitHub organization project #${projectNumber} was not found in ${organization}.`);
+  }
+  return {
+    projectId: project.id,
+    project
+  };
+}
+async function getGitHubPullRequestProjectItems(octokit, repository, pullRequestNumber) {
+  const projectItems = [];
+  let after;
+  let pullRequestId;
+  let pullRequestTitle;
+  let pullRequestUrl;
+  do {
+    const response = await octokit.graphql(
+      GITHUB_PULL_REQUEST_PROJECT_ITEMS_QUERY,
+      {
+        owner: repository.owner,
+        repo: repository.repo,
+        pullRequestNumber,
+        after
+      }
+    );
+    const pullRequest = response.repository?.pullRequest;
+    const currentPullRequestId = normalizeOptionalString2(pullRequest?.id);
+    const currentPullRequestTitle = normalizeOptionalString2(pullRequest?.title);
+    const currentPullRequestUrl = normalizeOptionalString2(pullRequest?.url);
+    if (!currentPullRequestId || !currentPullRequestTitle || !currentPullRequestUrl) {
+      throw new Error(`GitHub pull request #${pullRequestNumber} was not found in ${formatRepositoryLabel(repository)}.`);
+    }
+    pullRequestId ??= currentPullRequestId;
+    pullRequestTitle ??= currentPullRequestTitle;
+    pullRequestUrl ??= currentPullRequestUrl;
+    const connection = response.repository?.pullRequest?.projectItems;
+    for (const node of connection?.nodes ?? []) {
+      const itemId = normalizeOptionalString2(node?.id);
+      const project = normalizeGitHubProjectRecord(node?.project);
+      if (!itemId || !project) {
+        continue;
+      }
+      projectItems.push({
+        id: itemId,
+        project
+      });
+    }
+    after = getPageCursor(connection?.pageInfo);
+  } while (after);
+  if (!pullRequestId || !pullRequestTitle || !pullRequestUrl) {
+    throw new Error(`GitHub pull request #${pullRequestNumber} was not found in ${formatRepositoryLabel(repository)}.`);
+  }
+  return {
+    pullRequestId,
+    pullRequest: {
+      number: pullRequestNumber,
+      title: pullRequestTitle,
+      url: pullRequestUrl
+    },
+    projectItems
+  };
+}
 function formatAiAuthorshipFooter(llmModel) {
   return `
 
@@ -9029,6 +9541,22 @@ async function performSync(ctx, trigger, options = {}) {
         const importedIssuesForSynchronization = [...importRegistryByIssueId.values()].filter(
           (importedIssue) => allIssuesById.has(importedIssue.githubIssueId) && doesImportedIssueMatchTarget(importedIssue, options.target)
         );
+        const newlyImportedIssuesForMaintainerWarmup = advancedSettings.defaultStatus === "todo" ? [] : importedIssuesForSynchronization.filter((importedIssue) => createdIssueIds.has(importedIssue.githubIssueId)).map((importedIssue) => allIssuesById.get(importedIssue.githubIssueId)).filter(
+          (githubIssue) => githubIssue !== void 0 && githubIssue.state === "open"
+        ).filter(
+          (githubIssue) => !(linkedPullRequestsByIssueNumber.get(githubIssue.number) ?? []).some(
+            (pullRequest) => pullRequest.state === "OPEN"
+          )
+        );
+        if (newlyImportedIssuesForMaintainerWarmup.length > 0) {
+          await warmGitHubRepositoryMaintainerCache({
+            octokit,
+            repository,
+            githubIssues: newlyImportedIssuesForMaintainerWarmup,
+            maintainerCache: repositoryMaintainerCache
+          });
+          await throwIfSyncCancelled();
+        }
         currentProgress = {
           phase: "syncing",
           totalRepositoryCount: mappings.length,
@@ -9928,6 +10456,91 @@ function registerGitHubAgentTools(ctx) {
       );
     })
   );
+  ctx.tools.register(
+    "list_organization_projects",
+    getGitHubAgentToolDeclaration("list_organization_projects"),
+    async (params) => executeGitHubTool(async () => {
+      const input = getToolInputRecord(params);
+      const organization = normalizeOptionalToolString(input.organization);
+      if (!organization) {
+        throw new Error("organization is required.");
+      }
+      const octokit = await createGitHubToolOctokit(ctx);
+      const projects = await listGitHubOrganizationProjects(octokit, organization, {
+        includeClosed: input.includeClosed === true,
+        query: normalizeOptionalToolString(input.query),
+        limit: normalizeToolPositiveInteger(input.limit)
+      });
+      return buildToolSuccessResult(
+        `Loaded ${projects.length} GitHub organization ${projects.length === 1 ? "project" : "projects"} from ${organization}.`,
+        {
+          organization,
+          projects: projects.map((project) => buildGitHubProjectToolData(project))
+        }
+      );
+    })
+  );
+  ctx.tools.register(
+    "add_pull_request_to_project",
+    getGitHubAgentToolDeclaration("add_pull_request_to_project"),
+    async (params, runCtx) => executeGitHubTool(async () => {
+      const input = getToolInputRecord(params);
+      const target = await resolveGitHubPullRequestToolTarget(ctx, runCtx, input);
+      const octokit = await createGitHubToolOctokit(ctx);
+      const projectTarget = await resolveGitHubProjectToolTarget(octokit, input);
+      const pullRequest = await getGitHubPullRequestProjectItems(
+        octokit,
+        target.repository,
+        target.pullRequestNumber
+      );
+      const existingProjectItem = pullRequest.projectItems.find((item) => item.project.id === projectTarget.projectId);
+      if (existingProjectItem) {
+        return buildToolSuccessResult(
+          `Pull request #${target.pullRequestNumber} is already associated with GitHub project #${existingProjectItem.project.number}.`,
+          {
+            repository: target.repository.url,
+            pullRequest: pullRequest.pullRequest,
+            project: buildGitHubProjectToolData(existingProjectItem.project, {
+              includeOwnerLogin: true
+            }),
+            projectItem: {
+              id: existingProjectItem.id
+            },
+            alreadyAssociated: true
+          }
+        );
+      }
+      const response = await octokit.graphql(
+        GITHUB_ADD_PULL_REQUEST_TO_PROJECT_MUTATION,
+        {
+          projectId: projectTarget.projectId,
+          contentId: pullRequest.pullRequestId
+        }
+      );
+      const projectItemId = normalizeOptionalString2(response.addProjectV2ItemById?.item?.id);
+      const project = normalizeGitHubProjectRecord(
+        response.addProjectV2ItemById?.item?.project,
+        projectTarget.project?.ownerLogin
+      ) ?? projectTarget.project;
+      if (!projectItemId || !project) {
+        throw new Error("GitHub did not return the created project item.");
+      }
+      return buildToolSuccessResult(
+        `Added pull request #${target.pullRequestNumber} to GitHub project #${project.number}.`,
+        {
+          repository: target.repository.url,
+          pullRequest: pullRequest.pullRequest,
+          project: buildGitHubProjectToolData(project, {
+            includeOwnerLogin: true
+          }),
+          projectItem: {
+            id: projectItemId
+          },
+          alreadyAssociated: false
+        }
+      );
+    })
+  );
 }
 function shouldStartWorkerHost(moduleUrl, entry = process.argv[1]) {
   if (typeof entry !== "string" || !entry.trim()) {