refactor: drop listOrgsPrefetched — listOrganizations() is SQLite-cached

Since PR #446 (listOrganizations SQLite caching) and PR #490 (post-login
cache warming), listOrganizations() returns from cache instantly on warm
starts.  The separate listOrgsPrefetched() wrapper no longer adds value.

Keep only the resolveOrg prefetch (DSN scanning, 2-5s on cold starts),
which is the actual latency win of this PR.

Author: BYK

src/lib/init/local-ops.ts

@@ -9,7 +9,12 @@ import { spawn } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { isCancel, select } from "@clack/prompts";
-import { createProject, getProject, tryGetPrimaryDsn } from "../api-client.js";
+import {
+  createProject,
+  getProject,
+  listOrganizations,
+  tryGetPrimaryDsn,
+} from "../api-client.js";
 import { ApiError } from "../errors.js";
 import { resolveOrCreateTeam } from "../resolve-team.js";
 import { buildProjectUrl } from "../sentry-urls.js";
@@ -19,7 +24,7 @@ import {
   MAX_FILE_BYTES,
   MAX_OUTPUT_BYTES,
 } from "./constants.js";
-import { listOrgsPrefetched, resolveOrgPrefetched } from "./prefetch.js";
+import { resolveOrgPrefetched } from "./prefetch.js";
 import type {
   ApplyPatchsetPayload,
   CreateSentryProjectPayload,
@@ -654,10 +659,13 @@ function applyPatchset(
  * Resolve the org slug from local config, env vars, or by listing the user's
  * organizations from the API as a fallback.
  *
- * Uses the prefetch-aware helpers from `./prefetch.ts` — if
- * {@link warmOrgDetection} was called earlier (by `init.ts`), the results are
- * already cached and this function returns near-instantly.  Otherwise it falls
- * back to live calls transparently.
+ * DSN scanning uses the prefetch-aware helper from `./prefetch.ts` — if
+ * {@link warmOrgDetection} was called earlier (by `init.ts`), the result is
+ * already cached and returns near-instantly.
+ *
+ * `listOrganizations()` uses SQLite caching for near-instant warm lookups
+ * (populated after `sentry login` or the first API call), so it does not
+ * need background prefetching.
  *
  * @returns The org slug on success, or a {@link LocalOpResult} error to return early.
  */
@@ -670,8 +678,8 @@ async function resolveOrgSlug(
     return resolved.org;
   }
 
-  // Fallback: list user's organizations from API (prefetch-aware)
-  const orgs = await listOrgsPrefetched();
+  // Fallback: list user's organizations (SQLite-cached after login/first call)
+  const orgs = await listOrganizations();
   if (orgs.length === 0) {
     return {
       ok: false,

src/lib/init/prefetch.ts

@@ -3,28 +3,30 @@
  *
  * Provides a warm/consume pattern for org resolution during `sentry init`.
  * Call {@link warmOrgDetection} early (before the preamble) to start DSN
- * scanning and org-list fetching in the background.  Later, call
- * {@link resolveOrgPrefetched} or {@link listOrgsPrefetched} — they return
- * the cached result instantly if the background work has finished, or
- * fall back to a live call if it hasn't been warmed.
+ * scanning in the background.  Later, call {@link resolveOrgPrefetched} —
+ * it returns the cached result instantly if the background work has
+ * finished, or falls back to a live call if it hasn't been warmed.
+ *
+ * `listOrganizations()` does NOT need prefetching because it has its own
+ * SQLite cache layer (PR #446).  After `sentry login`, the org cache is
+ * pre-populated (PR #490), so subsequent calls return from cache instantly
+ * without any HTTP requests.  Only `resolveOrg()` (DSN scanning) benefits
+ * from background prefetching since it performs filesystem I/O.
  *
  * This keeps the hot path (inside the wizard's `createSentryProject`)
  * free of explicit promise-threading — callers just swap in the
  * prefetch-aware functions.
  */
 
-import { listOrganizations } from "../api-client.js";
 import type { ResolvedOrg } from "../resolve-target.js";
 import { resolveOrg } from "../resolve-target.js";
 
 type OrgResult = ResolvedOrg | null;
-type OrgListResult = Array<{ id: string; slug: string; name: string }>;
 
 let orgPromise: Promise<OrgResult> | undefined;
-let orgListPromise: Promise<OrgListResult> | undefined;
 
 /**
- * Kick off background org detection and org-list fetching.
+ * Kick off background DSN scanning + env var / config checks.
  *
  * Safe to call multiple times — subsequent calls are no-ops.
  * Errors are silently swallowed so the foreground path can retry.
@@ -33,9 +35,6 @@ export function warmOrgDetection(cwd: string): void {
   if (!orgPromise) {
     orgPromise = resolveOrg({ cwd }).catch(() => null);
   }
-  if (!orgListPromise) {
-    orgListPromise = listOrganizations().catch(() => []);
-  }
 }
 
 /**
@@ -49,21 +48,9 @@ export function resolveOrgPrefetched(cwd: string): Promise<OrgResult> {
   return resolveOrg({ cwd }).catch(() => null);
 }
 
-/**
- * List organizations, using the prefetched result if available.
- * Falls back to a live call when {@link warmOrgDetection} was not called.
- */
-export function listOrgsPrefetched(): Promise<OrgListResult> {
-  if (orgListPromise) {
-    return orgListPromise;
-  }
-  return listOrganizations().catch(() => []);
-}
-
 /**
  * Reset prefetch state.  Used by tests to prevent cross-test leakage.
  */
 export function resetPrefetch(): void {
   orgPromise = undefined;
-  orgListPromise = undefined;
 }