@@ -0,0 +1,96 @@
+import { describe, expect, it } from "vitest";
+import { convertIssueToLink } from "./issue-sync";
+import type { GitHubIssueComment } from "./github";
+
+function makeIssue(overrides: Record<string, unknown> = {}) {
+  return {
+    number: 42,
+    title: "A bug",
+    body: "The description.",
+    html_url: "https://github.com/acme/web/issues/42",
+    created_at: "2026-07-01T00:00:00Z",
+    closed_at: null,
+    user: { id: 1, login: "octocat" },
+    assignees: [],
+    assignee: null,
+    ...overrides,
+  };
+}
+
+const comment = (id: number): GitHubIssueComment => ({
+  id,
+  body: `comment ${id}`,
+  created_at: "2026-07-02T00:00:00Z",
+  updated_at: "2026-07-02T00:00:00Z",
+  user: { id: 9, login: "commenter" },
+  html_url: "",
+});
+
+/** A page of `n` comments with ids starting at `base`. */
+const commentPage = (n: number, base: number) =>
+  Array.from({ length: n }, (_, i) => comment(base + i));
+
+/**
+ * Fake source serving a preconfigured list of comment pages keyed by the
+ * `page=` query param, recording every requested path.
+ */
+function makeIssueSource(commentPages: GitHubIssueComment[][]): {
+  source: any;
+  paths: string[];
+} {
+  const paths: string[] = [];
+  const source = {
+    userToContact: (user: { id: number; login: string }) => ({
+      email: `${user.id}+${user.login}@users.noreply.github.com`,
+      name: user.login,
+      source: { accountId: String(user.id) },
+    }),
+    githubFetch: async (_token: string, path: string) => {
+      paths.push(path);
+      const pageNum = Number(new URLSearchParams(path.split("?")[1]).get("page"));
+      const items = commentPages[pageNum - 1] ?? [];
+      return { ok: true, json: async () => items } as unknown as Response;
+    },
+  };
+  return { source, paths };
+}
+
+const commentNotes = (link: any) =>
+  link.notes.filter((n: any) => typeof n.key === "string" && n.key.startsWith("comment-"));
+
+describe("convertIssueToLink comment fetching", () => {
+  it("always emits a description note", async () => {
+    const { source } = makeIssueSource([[]]);
+    const link = await convertIssueToLink(source, "tok", "acme", "web", makeIssue(), "acme/web", false);
+    const description = link?.notes?.find((n: any) => n.key === "description");
+    expect(description?.content).toBe("The description.");
+  });
+
+  it("fetches every comment in a single request when under the page cap", async () => {
+    const { source, paths } = makeIssueSource([commentPage(30, 0)]);
+    const link = await convertIssueToLink(source, "tok", "acme", "web", makeIssue(), "acme/web", false);
+    expect(commentNotes(link)).toHaveLength(30);
+    expect(paths).toHaveLength(1);
+  });
+
+  it("caps at MAX_COMMENT_PAGES and never issues a request past the cap", async () => {
+    const { source, paths } = makeIssueSource([
+      commentPage(100, 0),
+      commentPage(100, 100),
+      commentPage(100, 200),
+      commentPage(100, 300),
+    ]);
+    const link = await convertIssueToLink(source, "tok", "acme", "web", makeIssue(), "acme/web", false);
+    // Keeps 3 pages (300 comments), never fetches the 4th full page.
+    expect(commentNotes(link)).toHaveLength(300);
+    expect(paths).toHaveLength(3);
+  });
+
+  it("requests comments newest-first so the retained pages are the most recent", async () => {
+    const { source, paths } = makeIssueSource([commentPage(10, 0)]);
+    await convertIssueToLink(source, "tok", "acme", "web", makeIssue(), "acme/web", false);
+    expect(paths[0]).toContain("/repos/acme/web/issues/42/comments");
+    expect(paths[0]).toContain("sort=created");
+    expect(paths[0]).toContain("direction=desc");
+  });
+});
@@ -5,6 +5,7 @@ import {
 } from "@plotday/twister";
 import type { GitHub, GitHubIssueComment } from "./github";
 import { parseRateLimit } from "./github";
+import { fetchPagedList } from "./pagination";
 
 /** Issues per page for batch sync */
 const PAGE_SIZE = 50;
@@ -187,32 +188,25 @@ export async function convertIssueToLink(
     author: authorContact,
   });
 
-  // Fetch comments
+  // Fetch comments, newest-first and bounded to MAX_COMMENT_PAGES so an issue
+  // with thousands of comments can't exhaust the per-execution request budget
+  // (see pagination.ts). Items under the cap fetch everything; items over it
+  // keep their most recent 300 comments (the description note is always kept).
   try {
-    let commentPage = 1;
-    let hasMoreComments = true;
-
-    while (hasMoreComments) {
-      const commentsResponse = await source.githubFetch(
-        token,
-        `/repos/${owner}/${repo}/issues/${issue.number}/comments?per_page=100&page=${commentPage}`,
-      );
-
-      if (!commentsResponse.ok) break;
-
-      const comments: GitHubIssueComment[] = await commentsResponse.json();
-      for (const comment of comments) {
-        const commentAuthor = source.userToContact(comment.user);
-        notes.push({
-          key: `comment-${comment.id}`,
-          content: comment.body ?? null,
-          created: new Date(comment.created_at),
-          author: commentAuthor,
-        });
-      }
-
-      hasMoreComments = comments.length === 100;
-      commentPage++;
+    const comments = await fetchPagedList<GitHubIssueComment>(
+      source,
+      token,
+      (page) =>
+        `/repos/${owner}/${repo}/issues/${issue.number}/comments?per_page=100&sort=created&direction=desc&page=${page}`,
+    );
+    for (const comment of comments) {
+      const commentAuthor = source.userToContact(comment.user);
+      notes.push({
+        key: `comment-${comment.id}`,
+        content: comment.body ?? null,
+        created: new Date(comment.created_at),
+        author: commentAuthor,
+      });
     }
   } catch (error) {
     console.error("Error fetching issue comments:", error);
 
@@ -0,0 +1,79 @@
+import { describe, expect, it } from "vitest";
+import { fetchPagedList, MAX_COMMENT_PAGES } from "./pagination";
+
+/** Build a page of `n` placeholder items. */
+const page = (n: number) => Array.from({ length: n }, (_, i) => ({ id: i }));
+
+/**
+ * Fake source whose `githubFetch` serves a preconfigured list of pages,
+ * indexed by the `page=` query param. An entry of `{ ok: false }` models a
+ * non-OK response; anything else is served as a JSON array. Records the paths
+ * requested so tests can assert the exact number of requests issued.
+ */
+function makeSource(pages: (unknown[] | { ok: false })[]): {
+  source: { githubFetch(token: string, path: string): Promise<Response> };
+  paths: string[];
+} {
+  const paths: string[] = [];
+  const source = {
+    githubFetch: async (_token: string, path: string) => {
+      paths.push(path);
+      const pageNum = Number(new URLSearchParams(path.split("?")[1]).get("page"));
+      const entry = pages[pageNum - 1];
+      if (!entry || (entry as { ok?: boolean }).ok === false) {
+        return { ok: false, status: 403, json: async () => [] } as unknown as Response;
+      }
+      return { ok: true, json: async () => entry } as unknown as Response;
+    },
+  };
+  return { source, paths };
+}
+
+describe("fetchPagedList", () => {
+  it("exposes a comment-page cap of 3 (300 items per list)", () => {
+    expect(MAX_COMMENT_PAGES).toBe(3);
+  });
+
+  it("returns everything and stops after one request when the first page is short", async () => {
+    const { source, paths } = makeSource([page(30)]);
+    const items = await fetchPagedList(source, "tok", (p) => `/x?per_page=100&page=${p}`);
+    expect(items).toHaveLength(30);
+    expect(paths).toEqual(["/x?per_page=100&page=1"]);
+  });
+
+  it("returns an empty list (one request) when the first page is empty", async () => {
+    const { source, paths } = makeSource([[]]);
+    const items = await fetchPagedList(source, "tok", (p) => `/x?page=${p}`);
+    expect(items).toEqual([]);
+    expect(paths).toHaveLength(1);
+  });
+
+  it("stops early on the first short page even below the cap", async () => {
+    const { source, paths } = makeSource([page(100), page(50)]);
+    const items = await fetchPagedList(source, "tok", (p) => `/x?page=${p}`);
+    expect(items).toHaveLength(150);
+    expect(paths).toEqual(["/x?page=1", "/x?page=2"]);
+  });
+
+  it("caps at MAX_COMMENT_PAGES and never requests past it when every page is full", async () => {
+    const { source, paths } = makeSource([page(100), page(100), page(100), page(100)]);
+    const items = await fetchPagedList(source, "tok", (p) => `/x?page=${p}`);
+    expect(items).toHaveLength(300);
+    // Never issued a 4th request despite a full 3rd page.
+    expect(paths).toEqual(["/x?page=1", "/x?page=2", "/x?page=3"]);
+  });
+
+  it("respects an explicit maxPages argument", async () => {
+    const { source, paths } = makeSource([page(100), page(100), page(100)]);
+    const items = await fetchPagedList(source, "tok", (p) => `/x?page=${p}`, 2);
+    expect(items).toHaveLength(200);
+    expect(paths).toHaveLength(2);
+  });
+
+  it("returns the pages fetched so far (best-effort) when a later page is non-OK", async () => {
+    const { source, paths } = makeSource([page(100), { ok: false }]);
+    const items = await fetchPagedList(source, "tok", (p) => `/x?page=${p}`);
+    expect(items).toHaveLength(100);
+    expect(paths).toEqual(["/x?page=1", "/x?page=2"]);
+  });
+});
@@ -0,0 +1,53 @@
+/**
+ * Bounded pagination for GitHub list endpoints (issue/PR comments, reviews).
+ *
+ * A single item conversion (`convertIssueToLink` / `convertPRToThread`) can be
+ * invoked up to 50 times per connector execution (a full channel-sync batch or
+ * a full followed-items notifications page), and every `githubFetch` counts
+ * against the runtime's per-execution request budget (~1000 requests; see
+ * `twister/docs/RUNTIME.md`). An item with thousands of comments must therefore
+ * not fetch one request per 100 comments unbounded — a handful of such items
+ * would exhaust the budget and kill the execution.
+ *
+ * `fetchPagedList` caps the pages fetched per list at `MAX_COMMENT_PAGES`. Items
+ * under the cap fetch everything (the loop stops on the first short page, so the
+ * common case — well under 100 comments — is a single request). Items over it
+ * keep the first `MAX_COMMENT_PAGES` pages; callers order the endpoint
+ * newest-first (`sort=created&direction=desc`) where the API supports it so the
+ * retained pages are the most recent, most relevant comments.
+ */
+
+/**
+ * Max pages (100 items each) fetched per comment/review list, per item. 3 → up
+ * to 300 of each list type. This bounds a single execution's request count:
+ * worst case 50 items × (3 lists × 3 pages) ≈ 450 comment requests for PRs,
+ * well under the ~1000 budget.
+ */
+export const MAX_COMMENT_PAGES = 3;
+
+/**
+ * Fetch up to `maxPages` pages (100 items each) from a GitHub list endpoint,
+ * concatenated in fetch order. `pathForPage(page)` builds the request path for
+ * a given 1-based page number.
+ *
+ * Stops early on the first short page (fewer than 100 items = the last page).
+ * On a non-OK response, returns the items gathered so far — partial comments
+ * are better than none, matching the converters' pre-existing best-effort
+ * behavior when a comment fetch fails mid-item.
+ */
+export async function fetchPagedList<T>(
+  source: { githubFetch(token: string, path: string): Promise<Response> },
+  token: string,
+  pathForPage: (page: number) => string,
+  maxPages: number = MAX_COMMENT_PAGES,
+): Promise<T[]> {
+  const items: T[] = [];
+  for (let page = 1; page <= maxPages; page++) {
+    const response = await source.githubFetch(token, pathForPage(page));
+    if (!response.ok) break;
+    const batch: T[] = await response.json();
+    items.push(...batch);
+    if (batch.length < 100) break;
+  }
+  return items;
+}