diff --git a/packages/app/app/app.vue b/packages/app/app/app.vue
index ba445552..1cba544c 100644
--- a/packages/app/app/app.vue
+++ b/packages/app/app/app.vue
@@ -11,8 +11,7 @@ useHead({
 
 useSeoMeta({
   title: "pkg.pr.new",
-  description:
-    "Search repositories on GitHub to list their continuous releases.",
+  description: "Search repositories to list their continuous releases.",
 });
 </script>
 
diff --git a/packages/app/app/components/Commits.vue b/packages/app/app/components/Commits.vue
index f31a6241..606fae7f 100644
--- a/packages/app/app/components/Commits.vue
+++ b/packages/app/app/components/Commits.vue
@@ -12,18 +12,24 @@ const props = defineProps<{
   repo: string;
 }>();
 
-const data = await $fetch("/api/repo/commits", {
-  query: {
-    owner: props.owner,
-    repo: props.repo,
-  },
-});
+const requestFetch = useRequestFetch();
+
+const { data } = await useAsyncData(
+  `repo-commits:${props.owner}:${props.repo}:page:1`,
+  () =>
+    requestFetch("/api/repo/commits", {
+      query: {
+        owner: props.owner,
+        repo: props.repo,
+      },
+    }),
+);
 
-if (!data) {
+if (!data.value) {
   throw createError("Could not load Commits");
 }
 
-const branch = shallowReactive(data);
+const branch = shallowReactive(data.value);
 
 const commitsWithRelease = computed(() =>
   branch.target.history.nodes
@@ -113,58 +119,78 @@ onBeforeUnmount(() => {
 
 // Pagination
 const fetching = ref(false);
-const fetchMoreForceDisabled = ref(!commitsWithRelease.value.length);
+const currentPage = ref(branch.target.history.pageInfo.currentPage || 1);
+const totalPages = computed(
+  () => branch.target.history.pageInfo.totalPages || 1,
+);
+const hasNextPage = computed(() => currentPage.value < totalPages.value);
+const hasPrevPage = computed(() => currentPage.value > 1);
 
-async function fetchMore() {
-  if (!branch.target.history.pageInfo.hasNextPage) {
-    return;
+const paginationItems = computed<(number | "...")[]>(() => {
+  const total = totalPages.value;
+  const page = currentPage.value;
+  if (total <= 7) {
+    return Array.from({ length: total }, (_, i) => i + 1);
+  }
+
+  const items: (number | "...")[] = [1];
+  const start = Math.max(2, page - 1);
+  const end = Math.min(total - 1, page + 1);
+
+  if (start > 2) {
+    items.push("...");
   }
+  for (let i = start; i <= end; i++) {
+    items.push(i);
+  }
+  if (end < total - 1) {
+    items.push("...");
+  }
+  items.push(total);
+  return items;
+});
 
+async function fetchPage(page: number) {
   if (fetching.value) {
     return;
   }
 
   try {
     fetching.value = true;
-
-    const cursor = branch.target.history.pageInfo.endCursor;
-
     const result = await $fetch("/api/repo/commits", {
       query: {
         owner: props.owner,
         repo: props.repo,
-        cursor,
+        page: String(page),
       },
     });
 
-    const count = commitsWithRelease.value.length;
-
-    branch.target = {
-      ...branch.target,
-      history: {
-        ...branch.target.history,
-        nodes: [...branch.target.history.nodes, ...result.target.history.nodes],
-        pageInfo: result.target.history.pageInfo,
-      },
-    };
-
-    if (count === commitsWithRelease.value.length) {
-      fetchMoreForceDisabled.value = true;
-    }
+    currentPage.value = result.target.history.pageInfo.currentPage || page;
+    branch.id = result.id;
+    branch.name = result.name;
+    branch.target = result.target;
   } finally {
     fetching.value = false;
   }
 }
+
+async function goNextPage() {
+  if (!hasNextPage.value) {
+    return;
+  }
+  await fetchPage(currentPage.value + 1);
+}
+
+async function goPrevPage() {
+  if (!hasPrevPage.value) {
+    return;
+  }
+  await fetchPage(currentPage.value - 1);
+}
 </script>
 
 <template>
   <div class="flex flex-col gap-6">
-    <div class="text-center flex justify-center items-center gap-1 opacity-80">
-      Continuous Releases from
-      <UIcon name="i-ph-git-branch" />
-      {{ branch.name }}
-    </div>
-
     <div class="flex flex-col gap-2">
       <div
         v-for="commit of commitsWithRelease"
@@ -176,13 +202,42 @@ async function fetchMore() {
         aria-role="button"
         @click="selectedCommit = commit"
       >
-        <div class="flex items-center gap-2">
+        <div class="flex items-center gap-2 min-w-0">
           <UIcon name="i-ph-git-commit" class="opacity-50 flex-none" />
-          <span class="truncate">{{ commit.message }}</span>
-          <span class="opacity-50 flex-none">
+          <span class="truncate min-w-0 flex-1">{{ commit.message }}</span>
+          <span class="opacity-50 flex-none whitespace-nowrap">
             {{ useTimeAgo(commit.authoredDate) }}
           </span>
-          <span class="flex-1" />
+          <UIcon
+            v-if="commit.pinned"
+            name="i-ph-push-pin"
+            class="opacity-70 flex-none"
+            aria-label="Pinned release"
+          />
+          <UButton
+            v-if="commit.unverified && !commit.branch && !commit.pinned"
+            color="neutral"
+            variant="subtle"
+            size="xs"
+            :ui="{
+              base: 'font-mono pointer-events-none whitespace-nowrap',
+            }"
+          >
+            External
+          </UButton>
+          <UButton
+            v-if="commit.branch"
+            color="neutral"
+            variant="subtle"
+            size="xs"
+            :ui="{
+              base: 'font-mono pointer-events-none whitespace-nowrap shrink-0 inline-flex items-center',
+            }"
+          >
+            <span class="block max-w-48 truncate whitespace-nowrap">
+              {{ commit.branch }}
+            </span>
+          </UButton>
           <UButton
             :to="commit.url"
             target="_blank"
@@ -191,7 +246,7 @@ async function fetchMore() {
             size="xs"
             aria-label="View Commit"
             :ui="{
-              base: 'font-mono',
+              base: 'font-mono whitespace-nowrap shrink-0 inline-flex items-center',
             }"
             @click.stop
           >
@@ -202,18 +257,42 @@ async function fetchMore() {
     </div>
 
     <div
-      v-if="
-        branch.target.history.pageInfo.hasNextPage && !fetchMoreForceDisabled
-      "
-      class="flex justify-center"
+      v-if="commitsWithRelease.length"
+      class="flex justify-center items-center gap-1 flex-wrap"
     >
       <UButton
         color="neutral"
         variant="subtle"
+        icon="i-ph-caret-left"
+        :disabled="!hasPrevPage"
+        :loading="fetching"
+        @click="goPrevPage()"
+      >
+        Prev
+      </UButton>
+
+      <template v-for="(item, index) in paginationItems" :key="`page-${index}`">
+        <span v-if="item === '...'" class="px-2 text-sm opacity-60">…</span>
+        <UButton
+          v-else
+          :color="item === currentPage ? 'primary' : 'neutral'"
+          :variant="item === currentPage ? 'solid' : 'subtle'"
+          :disabled="fetching"
+          @click="fetchPage(item)"
+        >
+          {{ item }}
+        </UButton>
+      </template>
+
+      <UButton
+        color="neutral"
+        variant="subtle"
+        icon="i-ph-caret-right"
+        :disabled="!hasNextPage"
         :loading="fetching"
-        @click="fetchMore()"
+        @click="goNextPage()"
       >
-        Load More
+        Next
       </UButton>
     </div>
 
diff --git a/packages/app/nuxt.config.ts b/packages/app/nuxt.config.ts
index 441744f0..eb8159f4 100644
--- a/packages/app/nuxt.config.ts
+++ b/packages/app/nuxt.config.ts
@@ -45,6 +45,15 @@ export default defineNuxtConfig({
     },
   },
 
+  routeRules: {
+    "/~/**": {
+      headers: {
+        "cache-control":
+          "public, max-age=30, s-maxage=120, stale-while-revalidate=300",
+      },
+    },
+  },
+
   runtimeConfig: {
     nitro: {
       envPrefix: "NITRO_",
diff --git a/packages/app/server/api/repo/commits.get.ts b/packages/app/server/api/repo/commits.get.ts
index 249d5ed2..52a9c54b 100644
--- a/packages/app/server/api/repo/commits.get.ts
+++ b/packages/app/server/api/repo/commits.get.ts
@@ -1,4 +1,13 @@
+import type { H3Event } from "h3";
 import { z } from "zod";
+import type { PackageManager } from "@pkg-pr-new/utils";
+import { generateCommitPublishMessage } from "../../utils/markdown";
+import {
+  useBinding,
+  useCursorsBucket,
+  usePackagesBucket,
+} from "../../utils/bucket";
+import { useOctokitInstallation } from "../../utils/octokit";
 
 const querySchema = z.object({
   owner: z.string(),
@@ -8,131 +17,301 @@ const querySchema = z.object({
   per_page: z.string().optional().default("10"),
 });
 
+interface ReleaseRow {
+  sha: string;
+  uploadedAt: number;
+  packages: Set<string>;
+}
+
+interface CommitMeta {
+  message: string | null;
+  branch: string | null;
+}
+
+async function getCommitMetadata(
+  installation: Awaited<ReturnType<typeof useOctokitInstallation>>,
+  owner: string,
+  repo: string,
+  shas: string[],
+) {
+  async function fetchCommitMeta(sha: string): Promise<CommitMeta> {
+    let message: string | null = null;
+    let branch: string | null = null;
+
+    try {
+      const { data } = await installation.rest.repos.getCommit({
+        owner,
+        repo,
+        ref: sha,
+      });
+      const rawMessage = data.commit?.message?.trim();
+      const title = rawMessage?.split("\n")[0]?.trim();
+      if (title) {
+        message = title;
+      }
+    } catch {}
+
+    try {
+      const { data } = await installation.request(
+        "GET /repos/{owner}/{repo}/commits/{commit_sha}/branches-where-head",
+        {
+          owner,
+          repo,
+          commit_sha: sha,
+        },
+      );
+      const branchName = (data as Array<{ name?: string }>)[0]?.name?.trim();
+      if (branchName) {
+        branch = branchName;
+      }
+    } catch {}
+
+    if (!branch) {
+      try {
+        const { data } =
+          await installation.rest.repos.listPullRequestsAssociatedWithCommit({
+            owner,
+            repo,
+            commit_sha: sha,
+          });
+        const prBranch = data
+          .slice()
+          .sort(
+            (a, b) =>
+              new Date(b.updated_at ?? 0).getTime() -
+              new Date(a.updated_at ?? 0).getTime(),
+          )[0]?.head?.ref;
+        if (prBranch?.trim()) {
+          branch = prBranch.trim();
+        }
+      } catch {}
+    }
+
+    return {
+      message,
+      branch,
+    };
+  }
+
+  const entries = await Promise.all(
+    shas.map(async (sha) => {
+      const meta = await fetchCommitMeta(sha);
+      return [sha, meta] as const;
+    }),
+  );
+
+  return new Map(entries);
+}
+
+async function getDefaultBranchInfo(
+  event: H3Event,
+  installation: Awaited<ReturnType<typeof useOctokitInstallation>>,
+  owner: string,
+  repo: string,
+) {
+  const {
+    data: { default_branch: defaultBranch },
+  } = await installation.rest.repos.get({
+    owner,
+    repo,
+  });
+
+  const cursorBucket = useCursorsBucket(
+    event as Parameters<typeof useCursorsBucket>[0],
+  );
+  const cursor = await cursorBucket.getItem(
+    `${owner}:${repo}:${defaultBranch}`,
+  );
+  return {
+    defaultBranch,
+    pinnedSha: cursor?.sha ?? null,
+  };
+}
+
+function makeReleaseText(
+  origin: string,
+  owner: string,
+  repo: string,
+  sha: string,
+  packages: string[],
+) {
+  return generateCommitPublishMessage(
+    origin,
+    {},
+    packages,
+    {
+      owner,
+      repo,
+      sha,
+      ref: sha,
+    },
+    false,
+    "npm" satisfies PackageManager,
+    false,
+    false,
+  ).trim();
+}
+
 export default defineEventHandler(async (event) => {
   try {
     const query = await getValidatedQuery(event, (data) =>
       querySchema.parse(data),
     );
+
+    const perPage = Number.parseInt(query.per_page, 10);
+    const page = query.page
+      ? Number.parseInt(query.page, 10)
+      : query.cursor
+        ? Number.parseInt(query.cursor, 10)
+        : 1;
+
+    const binding = useBinding(event as Parameters<typeof useBinding>[0]);
+    const prefix = `${usePackagesBucket.base}:${query.owner}:${query.repo}:`;
+    const rows = new Map<string, ReleaseRow>();
+    let listCursor: string | undefined;
+
+    do {
+      const response = await binding.list({
+        cursor: listCursor,
+        limit: 1000,
+        prefix,
+      } as any);
+
+      for (const object of response.objects) {
+        const key = object.key;
+        const trimmed = key.slice(prefix.length);
+        const [sha, ...packageNameParts] = trimmed.split(":");
+        if (!sha || packageNameParts.length === 0) {
+          continue;
+        }
+        const packageName = packageNameParts.join(":");
+        const uploadedAt = new Date(object.uploaded).getTime();
+
+        const row = rows.get(sha);
+        if (row) {
+          row.packages.add(packageName);
+          row.uploadedAt = Math.max(row.uploadedAt, uploadedAt);
+        } else {
+          rows.set(sha, {
+            sha,
+            uploadedAt,
+            packages: new Set([packageName]),
+          });
+        }
+      }
+
+      listCursor = response.truncated ? response.cursor : undefined;
+    } while (listCursor);
+
     const installation = await useOctokitInstallation(
       event,
       query.owner,
       query.repo,
     );
-
-    const { data: repo } = await installation.request(
-      "GET /repos/{owner}/{repo}",
-      {
-        owner: query.owner,
-        repo: query.repo,
-      },
-    );
-
-    const defaultBranch = repo.default_branch;
-
-    const page = query.page
-      ? Number.parseInt(query.page)
-      : query.cursor
-        ? Number.parseInt(query.cursor)
-        : 1;
-    const per_page = Number.parseInt(query.per_page);
-
-    const { data: commits } = await installation.request(
-      "GET /repos/{owner}/{repo}/commits",
-      {
-        owner: query.owner,
-        repo: query.repo,
-        sha: defaultBranch,
-        page,
-        per_page,
-      },
+    const { pinnedSha, defaultBranch } = await getDefaultBranchInfo(
+      event,
+      installation,
+      query.owner,
+      query.repo,
     );
 
-    const commitsWithStatuses = await Promise.all(
-      commits.map(async (commit) => {
-        try {
-          const { data: checkRuns } = await installation.request(
-            "GET /repos/{owner}/{repo}/commits/{ref}/check-runs",
-            {
-              owner: query.owner,
-              repo: query.repo,
-              ref: commit.sha,
-            },
-          );
-
-          return {
-            id: commit.node_id || commit.sha,
-            oid: commit.sha,
-            abbreviatedOid: commit.sha.substring(0, 7),
-            message: commit.commit.message,
-            authoredDate: commit.commit.author?.date || "",
-            url: commit.html_url,
-            statusCheckRollup:
-              checkRuns.check_runs.length > 0
-                ? {
-                    id: `status-${commit.sha}`,
-                    state: checkRuns.check_runs.some(
-                      (check) => check.conclusion === "failure",
-                    )
-                      ? "FAILURE"
-                      : checkRuns.check_runs.some(
-                            (check) => check.conclusion === "success",
-                          )
-                        ? "SUCCESS"
-                        : "PENDING",
-                    contexts: {
-                      nodes: checkRuns.check_runs.map((check) => ({
-                        id: check.id.toString(),
-                        status: check.status,
-                        name: check.name,
-                        title: check.name,
-                        summary: check.output?.summary || "",
-                        text: check.output?.text || "",
-                        detailsUrl: check.details_url || "",
-                        url: check.url || check.html_url || "",
-                      })),
-                    },
-                  }
-                : null,
-          };
-        } catch (error) {
-          console.warn(
-            `Could not fetch check runs for commit ${commit.sha}:`,
-            error,
-          );
-          return {
-            id: commit.node_id || commit.sha,
-            oid: commit.sha,
-            abbreviatedOid: commit.sha.substring(0, 7),
-            message: commit.commit.message,
-            authoredDate: commit.commit.author?.date || "",
-            url: commit.html_url,
-            statusCheckRollup: null,
-          };
+    // Server-side ordering guarantees pagination consistency.
+    const releases = [...rows.values()].sort((a, b) => {
+      if (pinnedSha) {
+        if (a.sha === pinnedSha && b.sha !== pinnedSha) {
+          return -1;
         }
-      }),
+        if (b.sha === pinnedSha && a.sha !== pinnedSha) {
+          return 1;
+        }
+      }
+      if (b.uploadedAt !== a.uploadedAt) {
+        return b.uploadedAt - a.uploadedAt;
+      }
+      return b.sha.localeCompare(a.sha);
+    });
+    const start = Math.max(0, (page - 1) * perPage);
+    const end = start + perPage;
+    const pageItems = releases.slice(start, end);
+    const hasNextPage = end < releases.length;
+    const nextCursor = hasNextPage ? String(page + 1) : null;
+    const totalCount = releases.length;
+    const totalPages = Math.max(1, Math.ceil(totalCount / perPage));
+    const origin = getRequestURL(event).origin;
+    const commitMetadata = await getCommitMetadata(
+      installation,
+      query.owner,
+      query.repo,
+      pageItems.map((row) => row.sha),
     );
 
-    // Check if there are more commits (GitHub API doesn't provide this directly)
-    // We'll need to check if we got a full page of results
-    const hasNextPage = commits.length === per_page;
-    const nextPage = hasNextPage ? (page + 1).toString() : null;
+    setHeader(
+      event,
+      "Cache-Control",
+      "public, max-age=30, s-maxage=120, stale-while-revalidate=300",
+    );
 
     return {
-      id: `branch-${defaultBranch}`,
-      name: defaultBranch,
+      id: `releases-${query.owner}-${query.repo}`,
+      name: "all refs",
       target: {
-        id: `target-${defaultBranch}`,
+        id: `releases-target-${query.owner}-${query.repo}`,
         history: {
-          nodes: commitsWithStatuses,
+          nodes: pageItems.map((row) => {
+            const abbreviatedOid = row.sha.slice(0, 7);
+            const sortedPackages = [...row.packages].sort();
+            const meta = commitMetadata.get(row.sha);
+            const commitTitle = meta?.message ?? null;
+            const pinned = pinnedSha === row.sha;
+            return {
+              id: row.sha,
+              oid: row.sha,
+              abbreviatedOid,
+              message: commitTitle ?? row.sha,
+              unverified: !commitTitle,
+              pinned,
+              branch: pinned ? defaultBranch : (meta?.branch ?? null),
+              authoredDate: new Date(row.uploadedAt).toISOString(),
+              url: `https://github.com/${query.owner}/${query.repo}/commit/${row.sha}`,
+              statusCheckRollup: {
+                id: `status-${row.sha}`,
+                state: "SUCCESS",
+                contexts: {
+                  nodes: [
+                    {
+                      id: `release-${row.sha}`,
+                      status: "completed",
+                      name: "Continuous Releases",
+                      title: "Continuous Releases",
+                      summary: `Published ${sortedPackages.length} package(s)`,
+                      text: makeReleaseText(
+                        origin,
+                        query.owner,
+                        query.repo,
+                        row.sha,
+                        sortedPackages,
+                      ),
+                      detailsUrl: `https://github.com/${query.owner}/${query.repo}/commit/${row.sha}`,
+                      url: `https://github.com/${query.owner}/${query.repo}/commit/${row.sha}`,
+                    },
+                  ],
+                },
+              },
+            };
+          }),
           pageInfo: {
             hasNextPage,
-            endCursor: nextPage,
+            endCursor: nextCursor,
+            currentPage: page,
+            perPage,
+            totalCount,
+            totalPages,
           },
         },
       },
     };
   } catch (error) {
-    console.error("Error fetching repository commits:", error);
+    console.error("Error fetching repository releases:", error);
 
     return {
       id: "error",
diff --git a/packages/app/server/api/repo/index.get.ts b/packages/app/server/api/repo/index.get.ts
index 0eb88fc2..a2aeb672 100644
--- a/packages/app/server/api/repo/index.get.ts
+++ b/packages/app/server/api/repo/index.get.ts
@@ -10,26 +10,19 @@ const querySchema = z.object({
 const getRepoInfo = defineCachedFunction(
   async (owner: string, repo: string, event: H3Event) => {
     try {
-      const installation = await useOctokitInstallation(event, owner, repo);
-
-      const { data } = await installation.request("GET /repos/{owner}/{repo}", {
-        owner,
-        repo,
-      });
-
-      const releaseCount = 0;
+      const releaseCount = await getRepoReleaseCount(event as any, owner, repo);
 
       return {
-        id: data.id.toString(),
-        name: data.name,
+        id: `${owner}/${repo}`,
+        name: repo,
         owner: {
-          id: data.owner.id.toString(),
-          avatarUrl: data.owner.avatar_url,
-          login: data.owner.login,
+          id: owner,
+          avatarUrl: `https://github.com/${owner}.png`,
+          login: owner,
         },
-        url: data.html_url,
-        homepageUrl: data.homepage || "",
-        description: data.description || "",
+        url: `https://github.com/${owner}/${repo}`,
+        homepageUrl: "",
+        description: "",
         releaseCount,
       };
     } catch (error) {
diff --git a/packages/app/server/api/repo/search.get.ts b/packages/app/server/api/repo/search.get.ts
index 19789d89..ca9cd565 100644
--- a/packages/app/server/api/repo/search.get.ts
+++ b/packages/app/server/api/repo/search.get.ts
@@ -2,7 +2,7 @@ import type { H3Event } from "h3";
 import stringSimilarity from "string-similarity";
 import { z } from "zod";
 import { useBucket } from "../../utils/bucket";
-import { useOctokitApp } from "../../utils/octokit";
+import { useBinding, usePackagesBucket } from "../../utils/bucket";
 
 const querySchema = z.object({
   text: z.string(),
@@ -12,11 +12,8 @@ const REPO_INDEX_CACHE_KEY = "repo-search:index";
 const REPO_INDEX_CACHE_TTL_MS = 5 * 60 * 1000;
 
 interface RepoSearchIndexItem {
-  id: number;
   name: string;
   ownerLogin: string;
-  ownerAvatarUrl: string;
-  stars: number;
 }
 
 interface RepoSearchIndexCache {
@@ -29,41 +26,38 @@ type CacheStatus = "hit" | "stale" | "miss";
 let revalidateRepoIndexPromise: Promise<void> | null = null;
 
 async function fetchInstalledRepos(event: H3Event) {
-  const app = useOctokitApp(event);
-  const seen = new Set<number>();
+  const binding = useBinding(event as any);
+  const seen = new Set<string>();
   const repos: RepoSearchIndexItem[] = [];
-
-  for await (const { installation } of app.eachInstallation.iterator()) {
-    try {
-      const octokit = await app.getInstallationOctokit(installation.id);
-      const installationRepos = [];
-      for await (const { data } of (octokit as any).paginate.iterator(
-        "GET /installation/repositories",
-        { per_page: 100 },
-      )) {
-        installationRepos.push(
-          ...(Array.isArray(data) ? data : (data.repositories ?? [])),
-        );
+  const prefix = `${usePackagesBucket.base}:`;
+  let cursor: string | undefined;
+
+  do {
+    const response = await binding.list({
+      cursor,
+      limit: 1000,
+      prefix,
+    } as any);
+
+    for (const { key } of response.objects) {
+      const trimmed = key.slice(prefix.length);
+      const [owner, repo] = trimmed.split(":");
+      if (!owner || !repo) {
+        continue;
       }
-
-      for (const repo of installationRepos) {
-        if (repo.private || seen.has(repo.id)) {
-          continue;
-        }
-
-        seen.add(repo.id);
-        repos.push({
-          id: repo.id,
-          name: repo.name,
-          ownerLogin: repo.owner.login,
-          ownerAvatarUrl: repo.owner.avatar_url,
-          stars: repo.stargazers_count || 0,
-        });
+      const fullName = `${owner}/${repo}`;
+      if (seen.has(fullName)) {
+        continue;
       }
-    } catch {
-      // Skip suspended installations
+      seen.add(fullName);
+      repos.push({
+        name: repo,
+        ownerLogin: owner,
+      });
     }
-  }
+
+    cursor = response.truncated ? response.cursor : undefined;
+  } while (cursor);
 
   return repos;
 }
@@ -149,13 +143,13 @@ function findMatches(repos: RepoSearchIndexItem[], text: string) {
       }
 
       return {
-        id: repo.id,
+        id: `${repo.ownerLogin}/${repo.name}`,
         name: repo.name,
         owner: {
           login: repo.ownerLogin,
-          avatarUrl: repo.ownerAvatarUrl,
+          avatarUrl: `https://github.com/${repo.ownerLogin}.png`,
         },
-        stars: repo.stars,
+        stars: 0,
         score,
       };
     })
diff --git a/packages/app/server/utils/octokit.ts b/packages/app/server/utils/octokit.ts
index 44525a40..0b167bc7 100644
--- a/packages/app/server/utils/octokit.ts
+++ b/packages/app/server/utils/octokit.ts
@@ -3,6 +3,37 @@ import type { App as AppType } from "octokit";
 import { paginateRest } from "@octokit/plugin-paginate-rest";
 import { App, Octokit } from "octokit";
 
+function createNoopApp(): AppType {
+  return {
+    octokit: { request: async () => ({ data: { id: 0 } }) },
+    eachInstallation: {
+      iterator: async function* () {
+        // no-op: no installations available
+      },
+    },
+    getInstallationOctokit: async () =>
+      ({
+        request: async () => ({ data: {} }),
+        paginate: { iterator: null },
+        rest: {
+          repos: {
+            get: async () => ({ data: { default_branch: "main" } }),
+            getCommit: async () => ({ data: { commit: { message: "" } } }),
+          },
+        },
+      }) as any,
+    webhooks: {
+      on: () => {},
+      removeListener: () => {},
+      receive: async () => {},
+      verifyAndReceive: async () => {},
+    },
+    log: {
+      error: (...args: unknown[]) => console.error(...args),
+    },
+  } as any;
+}
+
 export function useOctokitApp(event: H3Event): AppType {
   try {
     const config = useRuntimeConfig(event);
@@ -10,10 +41,7 @@ export function useOctokitApp(event: H3Event): AppType {
 
     if (!appId || !privateKey || !webhookSecret) {
       console.warn("Missing required GitHub App credentials in runtime config");
-      return {
-        octokit: { request: async () => ({ data: { id: 0 } }) },
-        getInstallationOctokit: async () => ({}),
-      } as any;
+      return createNoopApp();
     }
 
     return new App({
@@ -27,10 +55,7 @@ export function useOctokitApp(event: H3Event): AppType {
     }) as unknown as AppType;
   } catch (error) {
     console.error("Error initializing GitHub App:", error);
-    return {
-      octokit: { request: async () => ({ data: { id: 0 } }) },
-      getInstallationOctokit: async () => ({}),
-    } as any;
+    return createNoopApp();
   }
 }
 
diff --git a/packages/app/server/utils/types.ts b/packages/app/server/utils/types.ts
index 57daf833..3e92d668 100644
--- a/packages/app/server/utils/types.ts
+++ b/packages/app/server/utils/types.ts
@@ -16,7 +16,7 @@ export interface Cursor {
 }
 
 export type RepoNode = {
-  id: number;
+  id: number | string;
   name: string;
   owner: { login: string; avatarUrl: string };
   stars: number;