diff --git a/backend/src/database/migrations/U1772043927__removeReposFromGithubSettings.sql b/backend/src/database/migrations/U1772043927__removeReposFromGithubSettings.sql
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/backend/src/database/migrations/V1772043927__removeReposFromGithubSettings.sql b/backend/src/database/migrations/V1772043927__removeReposFromGithubSettings.sql
new file mode 100644
index 0000000000..c1295f972d
--- /dev/null
+++ b/backend/src/database/migrations/V1772043927__removeReposFromGithubSettings.sql
@@ -0,0 +1,30 @@
+-- Backup settings before any modifications
+CREATE TABLE integration.integrations_settings_backup_02_28_2026 AS
+SELECT id, settings FROM integrations;
+
+-- Strip repos from orgs in settings for github and github-nango integrations
+-- Repos now live in public.repositories table and are populated into API responses
+-- via the compatibility layer in integrationRepository._populateRelations
+UPDATE integrations
+SET settings = jsonb_set(
+  settings,
+  '{orgs}',
+  (
+    SELECT coalesce(jsonb_agg(
+      org - 'repos'
+    ), '[]'::jsonb)
+    FROM jsonb_array_elements(settings->'orgs') org
+  )
+)
+WHERE platform IN ('github', 'github-nango')
+  AND settings->'orgs' IS NOT NULL
+  AND "deletedAt" IS NULL
+  AND status != 'mapping';
+
+-- Also clean up top-level repos/unavailableRepos if present
+UPDATE integrations
+SET settings = settings - 'repos' - 'unavailableRepos'
+WHERE platform IN ('github', 'github-nango')
+  AND (settings ? 'repos' OR settings ? 'unavailableRepos')
+  AND "deletedAt" IS NULL
+  AND status != 'mapping';
diff --git a/backend/src/database/repositories/integrationRepository.ts b/backend/src/database/repositories/integrationRepository.ts
index a70499a700..45ba7680d2 100644
--- a/backend/src/database/repositories/integrationRepository.ts
+++ b/backend/src/database/repositories/integrationRepository.ts
@@ -585,10 +585,9 @@ class IntegrationRepository {
 
     const output = record.get({ plain: true })
 
-    // For github-nango integrations, populate settings.nangoMapping from the dedicated table
-    // so the API contract remains unchanged for frontend consumers
+    // For github-nango integrations, populate settings.nangoMapping from dedicated table
     if (output.platform === PlatformType.GITHUB_NANGO) {
-      const rows = await record.sequelize.query(
+      const nangoRows = await record.sequelize.query(
         `SELECT "connectionId", owner, "repoName" FROM integration.nango_mapping WHERE "integrationId" = :integrationId`,
         {
           replacements: { integrationId: output.id },
@@ -596,15 +595,71 @@ class IntegrationRepository {
         },
       )
 
-      if (rows.length > 0) {
+      if (nangoRows.length > 0) {
         const nangoMapping: Record<string, { owner: string; repoName: string }> = {}
-        for (const row of rows as { connectionId: string; owner: string; repoName: string }[]) {
+        for (const row of nangoRows as {
+          connectionId: string
+          owner: string
+          repoName: string
+        }[]) {
           nangoMapping[row.connectionId] = { owner: row.owner, repoName: row.repoName }
         }
         output.settings = { ...output.settings, nangoMapping }
       }
     }
 
+    // For both github and github-nango, populate orgs[].repos from repositories table
+    if (
+      (output.platform === PlatformType.GITHUB || output.platform === PlatformType.GITHUB_NANGO) &&
+      output.settings?.orgs?.length > 0
+    ) {
+      const repoRows = (await record.sequelize.query(
+        `SELECT url, split_part(url, '/', -1) as name, split_part(url, '/', -2) as owner, "forkedFrom", "updatedAt"
+           FROM public.repositories
+           WHERE "sourceIntegrationId" = :integrationId AND "deletedAt" IS NULL
+           ORDER BY url`,
+        {
+          replacements: { integrationId: output.id },
+          type: QueryTypes.SELECT,
+        },
+      )) as {
+        url: string
+        name: string
+        owner: string
+        forkedFrom: string | null
+        updatedAt: string
+      }[]
+
+      // Only overwrite orgs[].repos from the repositories table if there are rows.
+      // During the 'mapping' phase (legacy github connect), repos live in settings
+      // before being written to the repositories table via mapGithubRepos.
+      if (repoRows.length > 0) {
+        const reposByOwner: Record<string, typeof repoRows> = {}
+        for (const repo of repoRows) {
+          if (!reposByOwner[repo.owner]) reposByOwner[repo.owner] = []
+          reposByOwner[repo.owner].push(repo)
+        }
+
+        output.settings = {
+          ...output.settings,
+          orgs: output.settings.orgs.map((org) => ({
+            ...org,
+            repos: (reposByOwner[org.name] || []).map((r) => ({
+              url: r.url,
+              name: r.name,
+              owner: r.owner,
+              forkedFrom: r.forkedFrom,
+              updatedAt: r.updatedAt,
+            })),
+          })),
+        }
+      }
+
+      // Strip legacy top-level keys that may still exist in the DB column
+      delete output.settings.repos
+      delete output.settings.unavailableRepos
+    }
+
     return output
   }
 }
diff --git a/backend/src/services/collectionService.ts b/backend/src/services/collectionService.ts
index 51be9693d1..74bfd1d84e 100644
--- a/backend/src/services/collectionService.ts
+++ b/backend/src/services/collectionService.ts
@@ -27,6 +27,7 @@ import {
 } from '@crowd/data-access-layer/src/collections'
 import { fetchIntegrationsForSegment } from '@crowd/data-access-layer/src/integrations'
 import { QueryFilter } from '@crowd/data-access-layer/src/query'
+import { getReposForGithubIntegration } from '@crowd/data-access-layer/src/repositories'
 import {
   ICreateRepositoryGroup,
   IRepositoryGroup,
@@ -533,13 +534,8 @@ export class CollectionService extends LoggerBase {
     return listRepositoryGroups(qx, { insightsProjectId })
   }
 
-  static isSingleRepoOrg(orgs: GithubIntegrationSettings['orgs']): boolean {
-    return (
-      Array.isArray(orgs) &&
-      orgs.length === 1 &&
-      Array.isArray(orgs[0]?.repos) &&
-      orgs[0].repos.length === 1
-    )
+  static isSingleRepoOrg(orgs: GithubIntegrationSettings['orgs'], repoCount: number): boolean {
+    return Array.isArray(orgs) && orgs.length === 1 && repoCount === 1
   }
 
   /**
@@ -613,13 +609,12 @@ export class CollectionService extends LoggerBase {
       const settings = githubIntegration.settings as GithubIntegrationSettings
 
       // The orgs must have at least one repo
-      if (
-        !settings?.orgs ||
-        !Array.isArray(settings.orgs) ||
-        settings.orgs.length === 0 ||
-        !Array.isArray(settings.orgs[0].repos) ||
-        settings.orgs[0].repos.length === 0
-      ) {
+      if (!settings?.orgs || !Array.isArray(settings.orgs) || settings.orgs.length === 0) {
+        return null
+      }
+
+      const repos = await getReposForGithubIntegration(qx, githubIntegration.id)
+      if (repos.length === 0) {
         return null
       }
 
@@ -633,11 +628,8 @@ export class CollectionService extends LoggerBase {
         return null
       }
 
-      const details = CollectionService.isSingleRepoOrg(settings.orgs)
-        ? await GithubIntegrationService.findRepoDetails(
-            mainOrg.name,
-            settings.orgs[0].repos[0].name,
-          )
+      const details = CollectionService.isSingleRepoOrg(settings.orgs, repos.length)
+        ? await GithubIntegrationService.findRepoDetails(mainOrg.name, repos[0].name)
         : {
             ...(await GithubIntegrationService.findOrgDetails(mainOrg.name)),
             topics: mainOrg.topics,
diff --git a/backend/src/services/integrationService.ts b/backend/src/services/integrationService.ts
index 570a36bd13..fac1822a88 100644
--- a/backend/src/services/integrationService.ts
+++ b/backend/src/services/integrationService.ts
@@ -21,11 +21,13 @@ import {
   IRepository,
   IRepositoryMapping,
   getIntegrationReposMapping,
+  getReposForGithubIntegration,
   getRepositoriesBySourceIntegrationId,
   getRepositoriesByUrl,
   insertRepositories,
   restoreRepositories,
   softDeleteRepositories,
+  stripReposFromGithubSettings,
 } from '@crowd/data-access-layer/src/repositories'
 import {
   getMappedAllWithSegmentName,
@@ -801,6 +803,24 @@ export default class IntegrationService {
     const txService = new IntegrationService(txOptions)
 
     try {
+      // Extract repos from orgs and build forkedFrom map, then store settings without repos
+      const forkedFromMap = new Map<string, string | null>()
+      if (settings?.orgs) {
+        for (const org of settings.orgs) {
+          for (const repo of org.repos || []) {
+            if (repo.url) {
+              forkedFromMap.set(repo.url, repo.forkedFrom || null)
+            }
+          }
+        }
+      }
+
+      // Strip repos from orgs before storing in settings
+      const settingsToStore = {
+        ...settings,
+        orgs: (settings?.orgs || []).map(({ repos: _repos, ...org }) => org),
+      }
+
       let integration
 
       if (!integrationId) {
@@ -808,26 +828,26 @@ export default class IntegrationService {
         integration = await txService.createOrUpdate(
           {
             platform: PlatformType.GITHUB_NANGO,
-            settings,
+            settings: settingsToStore,
             status: 'done',
           },
           transaction,
         )
 
         // create github mapping - this also creates git integration
-        await txService.mapGithubRepos(integration.id, mapping, false)
+        await txService.mapGithubRepos(integration.id, mapping, false, forkedFromMap)
       } else {
         // update existing integration
         integration = await txService.findById(integrationId)
 
         // create github mapping - this also creates git integration
-        await txService.mapGithubRepos(integrationId, mapping, false)
+        await txService.mapGithubRepos(integrationId, mapping, false, forkedFromMap)
 
         integration = await txService.createOrUpdate(
           {
             id: integrationId,
             platform: PlatformType.GITHUB_NANGO,
-            settings,
+            settings: settingsToStore,
           },
           transaction,
         )
@@ -858,7 +878,12 @@ export default class IntegrationService {
     }
   }
 
-  async mapGithubRepos(integrationId, mapping, fireOnboarding = true) {
+  async mapGithubRepos(
+    integrationId,
+    mapping,
+    fireOnboarding = true,
+    forkedFromMap?: Map<string, string | null>,
+  ) {
     this.options.log.info(`Mapping GitHub repos for integration ${integrationId}!`)
     const transaction = await SequelizeRepository.createTransaction(this.options)
 
@@ -866,6 +891,7 @@ export default class IntegrationService {
       ...this.options,
       transaction,
     }
+    let onboardingIntegration
     try {
       // add the repos to the git integration
       const repos: Record<string, string[]> = Object.entries(mapping).reduce(
@@ -880,9 +906,29 @@ export default class IntegrationService {
       )
       // Note: Repos are synced to public.repositories via mapUnifiedRepositories at the end of this method
 
-      // Get integration settings to access forkedFrom data from all orgs
       const integration = await IntegrationRepository.findById(integrationId, txOptions)
-      const allReposInSettings = integration.settings?.orgs?.flatMap((org) => org.repos || []) || []
+
+      // Build forkedFrom map from repositories table if not provided
+      if (!forkedFromMap) {
+        forkedFromMap = new Map<string, string | null>()
+        const qx = SequelizeRepository.getQueryExecutor(txOptions)
+        const existingRepos = await getReposForGithubIntegration(qx, integrationId)
+        if (existingRepos.length > 0) {
+          for (const repo of existingRepos) {
+            forkedFromMap.set(repo.url, repo.forkedFrom)
+          }
+        } else {
+          // On first mapping, repositories table is empty — read forkedFrom from settings
+          const orgs = integration.settings?.orgs || []
+          for (const org of orgs) {
+            for (const repo of org.repos || []) {
+              if (repo.url) {
+                forkedFromMap.set(repo.url, repo.forkedFrom || null)
+              }
+            }
+          }
+        }
+      }
 
       for (const [segmentId, urls] of Object.entries(repos)) {
         let isGitintegrationConfigured
@@ -904,6 +950,9 @@ export default class IntegrationService {
           isGitintegrationConfigured = false
         }
 
+        const buildRemotes = (urlList: string[]) =>
+          urlList.map((url) => ({ url, forkedFrom: forkedFromMap.get(url) || null }))
+
         if (isGitintegrationConfigured) {
           this.options.log.info(`Finding Git integration for segment ${segmentId}!`)
           const gitInfo = await this.gitGetRemotes(segmentOptions)
@@ -911,24 +960,14 @@ export default class IntegrationService {
           const allUrls = Array.from(new Set([...gitRemotes, ...urls]))
           this.options.log.info(`Updating Git integration for segment ${segmentId}!`)
           await this.gitConnectOrUpdate(
-            {
-              remotes: allUrls.map((url) => {
-                const repoInSettings = allReposInSettings.find((r) => r.url === url)
-                return { url, forkedFrom: repoInSettings?.forkedFrom || null }
-              }),
-            },
+            { remotes: buildRemotes(allUrls) },
             segmentOptions,
             PlatformType.GITHUB,
           )
         } else {
           this.options.log.info(`Updating Git integration for segment ${segmentId}!`)
           await this.gitConnectOrUpdate(
-            {
-              remotes: urls.map((url) => {
-                const repoInSettings = allReposInSettings.find((r) => r.url === url)
-                return { url, forkedFrom: repoInSettings?.forkedFrom || null }
-              }),
-            },
+            { remotes: buildRemotes(urls) },
             segmentOptions,
             PlatformType.GITHUB,
           )
@@ -937,19 +976,25 @@ export default class IntegrationService {
 
       // sync to public.repositories
       const txService = new IntegrationService(txOptions)
-      await txService.mapUnifiedRepositories(integration.platform, integrationId, mapping)
+      await txService.mapUnifiedRepositories(
+        integration.platform,
+        integrationId,
+        mapping,
+        true,
+        forkedFromMap,
+      )
+
+      // Now that repos are in the repositories table, strip them from settings
+      const qxTx = SequelizeRepository.getQueryExecutor(txOptions)
+      await stripReposFromGithubSettings(qxTx, integrationId)
 
       if (fireOnboarding) {
         this.options.log.info('Updating integration status to in-progress!')
-        const integration = await IntegrationRepository.update(
+        onboardingIntegration = await IntegrationRepository.update(
           integrationId,
           { status: 'in-progress' },
           txOptions,
         )
-
-        this.options.log.info('Sending GitHub message to int-run-worker!')
-        const emitter = await getIntegrationRunWorkerEmitter()
-        await emitter.triggerIntegrationRun(integration.platform, integration.id, true)
       }
 
       await SequelizeRepository.commitTransaction(transaction)
@@ -962,6 +1007,17 @@ export default class IntegrationService {
       }
       throw err
     }
+
+    // Trigger the run AFTER commit so the worker can see the repositories rows
+    if (onboardingIntegration) {
+      this.options.log.info('Sending GitHub message to int-run-worker!')
+      const emitter = await getIntegrationRunWorkerEmitter()
+      await emitter.triggerIntegrationRun(
+        onboardingIntegration.platform,
+        onboardingIntegration.id,
+        true,
+      )
+    }
   }
 
   /**
@@ -2388,13 +2444,8 @@ export default class IntegrationService {
 
       const githubToken = await getGithubInstallationToken()
 
-      const repos = integration.settings.orgs.flatMap((org) => org.repos) as {
-        url: string
-        name: string
-        updatedAt: string
-      }[]
-
       const qx = SequelizeRepository.getQueryExecutor(this.options)
+      const repos = await getReposForGithubIntegration(qx, integrationId)
       const githubRepos = await getRepositoriesBySourceIntegrationId(qx, integrationId)
       const mappedSegments = githubRepos.map((repo) => repo.segmentId)
 
@@ -2841,46 +2892,13 @@ export default class IntegrationService {
     const repos = await getInstalledRepositories(installToken)
     this.options.log.info(`Fetched ${repos.length} installed repositories`)
 
-    // Update integration settings
-    const currentSettings: {
-      orgs: Array<{
-        name: string
-        logo: string
-        url: string
-        fullSync: boolean
-        updatedAt: string
-        repos: Array<{
-          name: string
-          url: string
-          updatedAt: string
-        }>
-      }>
-    } = integration.settings || { orgs: [] }
-
-    if (currentSettings.orgs.length !== 1) {
-      throw new Error('Integration settings must have exactly one organization')
-    }
-
-    const currentRepos = currentSettings.orgs[0].repos || []
-    const newRepos = repos.filter((repo) => !currentRepos.some((r) => r.url === repo.url))
-    this.options.log.info(`Found ${newRepos.length} new repositories`)
+    // Get current repos from repositories table
+    const qx = SequelizeRepository.getQueryExecutor(this.options)
+    const currentRepoRows = await getReposForGithubIntegration(qx, integration.id)
+    const currentRepoUrls = new Set(currentRepoRows.map((r) => r.url))
 
-    const updatedSettings = {
-      ...currentSettings,
-      orgs: [
-        {
-          ...currentSettings.orgs[0],
-          repos: [
-            ...currentRepos,
-            ...newRepos.map((repo) => ({
-              name: repo.name,
-              url: repo.url,
-              updatedAt: repo.updatedAt || new Date().toISOString(),
-            })),
-          ],
-        },
-      ],
-    }
+    const newRepos = repos.filter((repo) => !currentRepoUrls.has(repo.url))
+    this.options.log.info(`Found ${newRepos.length} new repositories`)
 
     this.options = {
       ...this.options,
@@ -2891,20 +2909,17 @@ export default class IntegrationService {
       ],
     }
 
-    // Update the integration with new settings
-    await this.update(integration.id, { settings: updatedSettings })
-
-    this.options.log.info(`Updated integration settings for integration id: ${integration.id}`)
-
-    // Update GitHub repos mapping
+    // Update GitHub repos mapping — new repos are added to repositories table via mapGithubRepos
     const defaultSegmentId = integration.segmentId
     const mapping = {}
+    const forkedFromMap = new Map<string, string | null>()
     for (const repo of newRepos) {
       mapping[repo.url] = defaultSegmentId
+      forkedFromMap.set(repo.url, repo.forkedFrom || null)
     }
     if (Object.keys(mapping).length > 0) {
       // false - not firing onboarding
-      await this.mapGithubRepos(integration.id, mapping, false)
+      await this.mapGithubRepos(integration.id, mapping, false, forkedFromMap)
       this.options.log.info(`Updated GitHub repos mapping for integration id: ${integration.id}`)
     } else {
       this.options.log.info(`No new repos to map for integration id: ${integration.id}`)
@@ -3002,6 +3017,7 @@ export default class IntegrationService {
     sourcePlatform: PlatformType,
     sourceIntegrationId: string,
     txOptions: IRepositoryOptions,
+    existingForkedFromMap?: Map<string, string | null>,
   ): Promise<ICreateRepository[]> {
     if (urls.length === 0) {
       return []
@@ -3045,19 +3061,19 @@ export default class IntegrationService {
       }
     }
 
-    // Build forkedFrom map from integration settings (for GITHUB repositories)
-    const forkedFromMap = new Map<string, string | null>()
-    const isGitHubPlatform = [PlatformType.GITHUB, PlatformType.GITHUB_NANGO].includes(
-      sourcePlatform,
-    )
-    const sourceIntegration = isGitHubPlatform
-      ? await IntegrationRepository.findById(sourceIntegrationId, txOptions)
-      : null
-    if (sourceIntegration?.settings?.orgs) {
-      const allRepos = sourceIntegration.settings.orgs.flatMap((org: any) => org.repos || [])
-      for (const repo of allRepos) {
-        if (repo.url && repo.forkedFrom) {
-          forkedFromMap.set(repo.url, repo.forkedFrom)
+    // Build forkedFrom map from existing repositories (for GITHUB platforms)
+    // Use the passed map if available (on first mapping, repositories table is empty)
+    const forkedFromMap = existingForkedFromMap ?? new Map<string, string | null>()
+    if (!existingForkedFromMap) {
+      const isGitHubPlatform = [PlatformType.GITHUB, PlatformType.GITHUB_NANGO].includes(
+        sourcePlatform,
+      )
+      if (isGitHubPlatform) {
+        const existingRepos = await getReposForGithubIntegration(qx, sourceIntegrationId)
+        for (const repo of existingRepos) {
+          if (repo.forkedFrom) {
+            forkedFromMap.set(repo.url, repo.forkedFrom)
+          }
         }
       }
     }
@@ -3089,6 +3105,7 @@ export default class IntegrationService {
     sourceIntegrationId: string,
     mapping: { [url: string]: string },
     skipMirroredRepos = true,
+    forkedFromMap?: Map<string, string | null>,
   ) {
     // Check for existing transaction to support nested calls within outer transactions
     const existingTransaction = SequelizeRepository.getTransaction(this.options)
@@ -3155,6 +3172,7 @@ export default class IntegrationService {
           sourcePlatform,
           sourceIntegrationId,
           txOptions,
+          forkedFromMap,
         )
         if (payloads.length > 0) {
           await insertRepositories(qx, payloads)
@@ -3172,6 +3190,7 @@ export default class IntegrationService {
           sourcePlatform,
           sourceIntegrationId,
           txOptions,
+          forkedFromMap,
         )
         if (restorePayloads.length > 0) {
           await restoreRepositories(qx, restorePayloads)
diff --git a/frontend/src/modules/admin/modules/integration/pages/integration-list.page.vue b/frontend/src/modules/admin/modules/integration/pages/integration-list.page.vue
index bfb16905a9..efb44fb303 100644
--- a/frontend/src/modules/admin/modules/integration/pages/integration-list.page.vue
+++ b/frontend/src/modules/admin/modules/integration/pages/integration-list.page.vue
@@ -128,7 +128,22 @@ const { array, loadingFetch } = mapGetters('integration');
 
 const { id, grandparentId } = route.params;
 
-const useGitHubNango = ref(false); // true for v2, false for v1
+const authStore = useAuthStore();
+const userId = computed(() => authStore.user?.id);
+const teamUserIds = computed(() => config.permissions.teamUserIds);
+const env = computed(() => config.env);
+
+const isTeamUser = computed(() => env.value !== 'production' || teamUserIds.value?.includes(userId.value));
+
+const useGitHubNango = computed(() => {
+  const githubIntegration = array.value.find(
+    (integration: any) => integration.platform === 'github',
+  );
+  if (githubIntegration) {
+    return !!githubIntegration.isNango;
+  }
+  return !!isTeamUser.value;
+});
 
 const subproject = ref<any>();
 
@@ -153,34 +168,15 @@ const platformsByStatus = computed(() => {
   return all.filter((platform) => matching.includes(platform));
 });
 
-const authStore = useAuthStore();
-const userId = computed(() => authStore.user?.id);
-const teamUserIds = computed(() => config.permissions.teamUserIds);
-const env = computed(() => config.env);
-
-const isTeamUser = computed(() => env.value !== 'production' || teamUserIds.value?.includes(userId.value));
-
 onMounted(() => {
   localStorage.setItem('segmentId', id as string);
   localStorage.setItem('segmentGrandparentId', grandparentId as string);
 
-  doFetch().then(() => {
-    useGitHubNango.value = updateGithubVersion();
-  });
+  doFetch();
   findSubProject(id).then((res) => {
     subproject.value = res;
   });
 });
-
-const updateGithubVersion = () => {
-  const githubIntegration = array.value.find(
-    (integration: any) => integration.platform === 'github',
-  );
-  if (githubIntegration) {
-    return !!githubIntegration.isNango;
-  }
-  return !!isTeamUser.value;
-};
 </script>
 
 <script lang="ts">
diff --git a/scripts/cli b/scripts/cli
index ea17417248..63547ea3f3 100755
--- a/scripts/cli
+++ b/scripts/cli
@@ -816,6 +816,53 @@ function scaffold_reset() {
     post_up_scaffold
 }
 
+function get_running_services() {
+    # Detect which services are currently running and whether they use DEV mode
+    RUNNING_SERVICES=()
+    RUNNING_SERVICES_DEV=()
+
+    for service in $CONTAINERS; do
+        if [[ $(check_container_status "${service}-dev") ]]; then
+            RUNNING_SERVICES_DEV+=("$service")
+        elif [[ $(check_container_status "${service}") ]]; then
+            RUNNING_SERVICES+=("$service")
+        fi
+    done
+}
+
+function reset_and_restart() {
+    say "Detecting running services..."
+    get_running_services
+
+    if [[ ${#RUNNING_SERVICES[@]} -eq 0 && ${#RUNNING_SERVICES_DEV[@]} -eq 0 ]]; then
+        say "No services running."
+    else
+        if [[ ${#RUNNING_SERVICES_DEV[@]} -gt 0 ]]; then
+            say "Running services (dev): ${RUNNING_SERVICES_DEV[*]}"
+        fi
+        if [[ ${#RUNNING_SERVICES[@]} -gt 0 ]]; then
+            say "Running services: ${RUNNING_SERVICES[*]}"
+        fi
+    fi
+
+    nl
+    say "Resetting scaffold..."
+    scaffold_reset
+
+    say "Restarting previously running services..."
+    for service in "${RUNNING_SERVICES[@]}"; do
+        say "Starting service $service"
+        start_service "$service"
+    done
+
+    for service in "${RUNNING_SERVICES_DEV[@]}"; do
+        say "Starting service $service (dev)"
+        DEV=1 start_service "$service"
+    done
+
+    say "Done! All previously running services have been restarted."
+}
+
 function kill_all_containers() {
     for i in $CONTAINERS; do
         say "Killing service $i."
@@ -896,7 +943,24 @@ function start() {
     service_start
 }
 
-SCRIPT_USAGE="${YELLOW}${PROJECT_NAME} CLI ${RESET}\n\nExample usage: ./cli [ start, start-dev, clean-start, clean-start-dev, start-backend, start-backend-dev, clean-start-backend, clean-start-backend-dev, scaffold =>, service =>, build =>, build-and-push ]"
+SCRIPT_USAGE="${YELLOW}${PROJECT_NAME} CLI ${RESET}\n
+Usage: ./cli <command>\n
+${YELLOW}Scaffold:${RESET}
+  scaffold [up|down|destroy|reset|create-migration|create-product-migration|migrate-up|up-test]\n
+${YELLOW}Services:${RESET}
+  service <name> [up|down|restart|status|logs|id]
+  start | start-dev | start-be | start-e2e
+  clean-start | clean-start-dev | clean-start-backend | clean-start-backend-dev | clean-start-fe-dev
+  service-restart | service-restart-be | service-restart-dev | service-restart-fe-dev
+  reset-selected-services | reset-selected-services-dev
+  reset-and-restart\n
+${YELLOW}Build & Deploy:${RESET}
+  build <name> | build-and-push <name> | build-and-push-multiple <names...> | push <name>
+  deploy-staging | deploy-production\n
+${YELLOW}Database:${RESET}
+  db-backup <name> | db-restore <name> | migrate-env\n
+${YELLOW}Lint:${RESET}
+  lint-backend | lint-services\n"
 
 [[ -z "$1" ]] && say "$SCRIPT_USAGE" && exit 1
 while test $# -gt 0; do
@@ -1066,6 +1130,10 @@ while test $# -gt 0; do
         restore_db_backup $2
         exit
         ;;
+    reset-and-restart)
+        reset_and_restart
+        exit
+        ;;
     lint-backend)
         (cd $CLI_HOME/../backend && pnpm run lint && pnpm run format-check && pnpm run tsc-check)
         exit
diff --git a/services/apps/cron_service/src/jobs/nangoMonitoring.job.ts b/services/apps/cron_service/src/jobs/nangoMonitoring.job.ts
index 6c93069cf9..28ab30aacd 100644
--- a/services/apps/cron_service/src/jobs/nangoMonitoring.job.ts
+++ b/services/apps/cron_service/src/jobs/nangoMonitoring.job.ts
@@ -15,6 +15,7 @@ import {
   getNangoMappingsForIntegration,
 } from '@crowd/data-access-layer/src/integrations'
 import { pgpQx } from '@crowd/data-access-layer/src/queryExecutor'
+import { getReposForGithubIntegration } from '@crowd/data-access-layer/src/repositories'
 import {
   ALL_NANGO_INTEGRATIONS,
   NangoIntegration,
@@ -74,27 +75,23 @@ const job: IJobDefinition = {
         // Fetch nango mappings from the dedicated table
         const nangoMapping = await getNangoMappingsForIntegration(pgpQx(dbConnection), int.id)
 
-        // first go through all orgs and repos and check if they are connected to nango
-        for (const org of int.settings.orgs) {
-          const orgName = org.name
-          for (const repo of org.repos) {
-            const repoName = repo.name
-            totalRepos++
+        // Check which repos are connected to nango by comparing repositories table vs nango_mapping
+        const repoRows = await getReposForGithubIntegration(pgpQx(dbConnection), int.id)
+        for (const repo of repoRows) {
+          totalRepos++
 
-            let found = false
-
-            for (const mapping of Object.values(nangoMapping)) {
-              if (mapping.owner === orgName && mapping.repoName === repoName) {
-                found = true
-              }
+          let found = false
+          for (const mapping of Object.values(nangoMapping)) {
+            if (mapping.owner === repo.owner && mapping.repoName === repo.name) {
+              found = true
             }
+          }
 
-            if (!found) {
-              if (ghNotConnectedToNangoYet.has(int.id)) {
-                ghNotConnectedToNangoYet.set(int.id, ghNotConnectedToNangoYet.get(int.id) + 1)
-              } else {
-                ghNotConnectedToNangoYet.set(int.id, 1)
-              }
+          if (!found) {
+            if (ghNotConnectedToNangoYet.has(int.id)) {
+              ghNotConnectedToNangoYet.set(int.id, ghNotConnectedToNangoYet.get(int.id) + 1)
+            } else {
+              ghNotConnectedToNangoYet.set(int.id, 1)
             }
           }
         }
diff --git a/services/apps/integration_run_worker/src/bin/auto-heal-github-integration.ts b/services/apps/integration_run_worker/src/bin/auto-heal-github-integration.ts
index 0498684aaf..ef086aba3f 100644
--- a/services/apps/integration_run_worker/src/bin/auto-heal-github-integration.ts
+++ b/services/apps/integration_run_worker/src/bin/auto-heal-github-integration.ts
@@ -3,6 +3,8 @@ import axios from 'axios'
 import { IntegrationRunWorkerEmitter } from '@crowd/common_services'
 import { DbStore, getDbConnection } from '@crowd/data-access-layer/src/database'
 import IntegrationRunRepository from '@crowd/data-access-layer/src/old/apps/integration_run_worker/integrationRun.repo'
+import { dbStoreQx } from '@crowd/data-access-layer/src/queryExecutor'
+import { populateGithubSettingsWithRepos } from '@crowd/data-access-layer/src/repositories'
 import {
   GithubIntegrationSettings,
   GithubManualIntegrationSettings,
@@ -171,8 +173,11 @@ setImmediate(async () => {
     log.info(`Triggering integration run for ${integrationId}!`)
 
     // let's get current settings from integration
-    const currentSettings = (await repo.getIntegrationSettings(
+    const rawSettings = await repo.getIntegrationSettings(integrationId)
+    const currentSettings = (await populateGithubSettingsWithRepos(
+      dbStoreQx(store),
       integrationId,
+      rawSettings,
     )) as GithubIntegrationSettings
 
     const repos: Repo[] = []
diff --git a/services/apps/integration_run_worker/src/bin/process-repo.ts b/services/apps/integration_run_worker/src/bin/process-repo.ts
index 812e1cef0a..647324cd6a 100644
--- a/services/apps/integration_run_worker/src/bin/process-repo.ts
+++ b/services/apps/integration_run_worker/src/bin/process-repo.ts
@@ -1,6 +1,8 @@
 import { IntegrationRunWorkerEmitter } from '@crowd/common_services'
 import { DbStore, getDbConnection } from '@crowd/data-access-layer/src/database'
 import IntegrationRunRepository from '@crowd/data-access-layer/src/old/apps/integration_run_worker/integrationRun.repo'
+import { dbStoreQx } from '@crowd/data-access-layer/src/queryExecutor'
+import { populateGithubSettingsWithRepos } from '@crowd/data-access-layer/src/repositories'
 import {
   GithubIntegrationSettings,
   GithubManualIntegrationSettings,
@@ -97,8 +99,11 @@ setImmediate(async () => {
     log.info(`Triggering integration run for ${integrationId}!`)
 
     // let's get current settings from integration
-    const currentSettings = (await repo.getIntegrationSettings(
+    const rawSettings = await repo.getIntegrationSettings(integrationId)
+    const currentSettings = (await populateGithubSettingsWithRepos(
+      dbStoreQx(store),
       integrationId,
+      rawSettings,
     )) as GithubIntegrationSettings
 
     let repos = []
diff --git a/services/apps/integration_run_worker/src/service/integrationRunService.ts b/services/apps/integration_run_worker/src/service/integrationRunService.ts
index 3923729799..a67e9185ac 100644
--- a/services/apps/integration_run_worker/src/service/integrationRunService.ts
+++ b/services/apps/integration_run_worker/src/service/integrationRunService.ts
@@ -7,6 +7,8 @@ import {
 import { DbStore } from '@crowd/data-access-layer/src/database'
 import IntegrationRunRepository from '@crowd/data-access-layer/src/old/apps/integration_run_worker/integrationRun.repo'
 import MemberAttributeSettingsRepository from '@crowd/data-access-layer/src/old/apps/integration_run_worker/memberAttributeSettings.repo'
+import { dbStoreQx } from '@crowd/data-access-layer/src/queryExecutor'
+import { populateGithubSettingsWithRepos } from '@crowd/data-access-layer/src/repositories'
 import { IGenerateStreamsContext, INTEGRATION_SERVICES } from '@crowd/integrations'
 import { Logger, LoggerBase, getChildLogger } from '@crowd/logging'
 import { ApiPubSubEmitter, RedisCache, RedisClient } from '@crowd/redis'
@@ -223,6 +225,18 @@ export default class IntegrationRunService extends LoggerBase {
       return
     }
 
+    // Populate orgs[].repos from repositories table for github integrations
+    if (
+      runInfo.integrationType === PlatformType.GITHUB ||
+      runInfo.integrationType === PlatformType.GITHUB_NANGO
+    ) {
+      runInfo.integrationSettings = await populateGithubSettingsWithRepos(
+        dbStoreQx(this.store),
+        runInfo.integrationId,
+        runInfo.integrationSettings,
+      )
+    }
+
     // we can do this because this service instance is only used for one run
     this.log = getChildLogger('run-processor', this.log, {
       runId,
@@ -285,8 +299,6 @@ export default class IntegrationRunService extends LoggerBase {
         await cache.delete('default')
 
         await txRunRepo.updateIntegrationSettings(runId, {
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          ...(runInfo.integrationSettings as any),
           updateMemberAttributes: false,
         })
       })
diff --git a/services/apps/integration_stream_worker/src/service/integrationStreamService.ts b/services/apps/integration_stream_worker/src/service/integrationStreamService.ts
index a2f321d52b..d9028e20a9 100644
--- a/services/apps/integration_stream_worker/src/service/integrationStreamService.ts
+++ b/services/apps/integration_stream_worker/src/service/integrationStreamService.ts
@@ -8,6 +8,8 @@ import { DbConnection, DbStore, DbTransaction } from '@crowd/data-access-layer/s
 import IncomingWebhookRepository from '@crowd/data-access-layer/src/old/apps/integration_stream_worker/incomingWebhook.repo'
 import { IStreamData } from '@crowd/data-access-layer/src/old/apps/integration_stream_worker/integrationStream.data'
 import IntegrationStreamRepository from '@crowd/data-access-layer/src/old/apps/integration_stream_worker/integrationStream.repo'
+import { dbStoreQx } from '@crowd/data-access-layer/src/queryExecutor'
+import { populateGithubSettingsWithRepos } from '@crowd/data-access-layer/src/repositories'
 import {
   INTEGRATION_SERVICES,
   IProcessStreamContext,
@@ -38,7 +40,7 @@ export default class IntegrationStreamService extends LoggerBase {
     private readonly runWorkerEmitter: IntegrationRunWorkerEmitter,
     private readonly streamWorkerEmitter: IntegrationStreamWorkerEmitter,
     dataSinkWorkerEmitter: DataSinkWorkerEmitter,
-    store: DbStore,
+    private readonly store: DbStore,
     parentLog: Logger,
   ) {
     super(parentLog)
@@ -222,6 +224,18 @@ export default class IntegrationStreamService extends LoggerBase {
       return false
     }
 
+    // Populate orgs[].repos from repositories table for github integrations
+    if (
+      streamInfo.integrationType === PlatformType.GITHUB ||
+      streamInfo.integrationType === PlatformType.GITHUB_NANGO
+    ) {
+      streamInfo.integrationSettings = await populateGithubSettingsWithRepos(
+        dbStoreQx(this.store),
+        streamInfo.integrationId,
+        streamInfo.integrationSettings,
+      )
+    }
+
     if (streamInfo.runId) {
       this.log.warn({ streamId }, 'Stream is a regular stream! Processing as such!')
       return await this.processStream(streamId)
@@ -390,6 +404,18 @@ export default class IntegrationStreamService extends LoggerBase {
       return false
     }
 
+    // Populate orgs[].repos from repositories table for github integrations
+    if (
+      streamInfo.integrationType === PlatformType.GITHUB ||
+      streamInfo.integrationType === PlatformType.GITHUB_NANGO
+    ) {
+      streamInfo.integrationSettings = await populateGithubSettingsWithRepos(
+        dbStoreQx(this.store),
+        streamInfo.integrationId,
+        streamInfo.integrationSettings,
+      )
+    }
+
     if (streamInfo.webhookId) {
       this.log.warn({ streamId }, 'Stream is a webhook stream! Processing as such!')
       return await this.processWebhookStream(streamInfo.webhookId)
diff --git a/services/apps/nango_worker/src/activities/nangoActivities.ts b/services/apps/nango_worker/src/activities/nangoActivities.ts
index a2da5126a9..3687e18fbc 100644
--- a/services/apps/nango_worker/src/activities/nangoActivities.ts
+++ b/services/apps/nango_worker/src/activities/nangoActivities.ts
@@ -11,13 +11,16 @@ import {
   linkNangoMappingToRepository,
   removeGithubNangoConnection,
   removeNangoCursorsByConnection,
-  setGithubIntegrationSettingsOrgs,
   setNangoCursor,
   updateNangoCursorLastCheckedAt,
 } from '@crowd/data-access-layer/src/integrations'
 import IntegrationStreamRepository from '@crowd/data-access-layer/src/old/apps/integration_stream_worker/integrationStream.repo'
 import { dbStoreQx } from '@crowd/data-access-layer/src/queryExecutor'
-import { softDeleteRepositories, upsertRepository } from '@crowd/data-access-layer/src/repositories'
+import {
+  getReposForGithubIntegration,
+  softDeleteRepositories,
+  upsertRepository,
+} from '@crowd/data-access-layer/src/repositories'
 import { getChildLogger } from '@crowd/logging'
 import {
   ALL_NANGO_INTEGRATIONS,
@@ -294,46 +297,33 @@ export async function analyzeGithubIntegration(
   if (integration) {
     if (integration.platform === PlatformType.GITHUB_NANGO) {
       const settings = integration.settings
+      const qx = dbStoreQx(svc.postgres.writer)
+
+      // Build desired repos list from repositories table
+      const repoRows = await getReposForGithubIntegration(qx, integrationId)
+      const repoSet = new Map<string, IGithubRepoData>()
+      for (const row of repoRows) {
+        repoSet.set(`${row.owner}/${row.name}`, { owner: row.owner, repoName: row.name })
+      }
 
-      // check if we need to sync org repos
-      let added = 0
+      // For fullSync orgs, discover new repos from GitHub API
+      // New repos not yet in the repositories table will be added to the sync list
+      // (syncGithubRepo workflow will create the repositories row)
       for (const org of settings.orgs) {
         if (org.fullSync) {
           const results = await GithubIntegrationService.getOrgRepos(org.name)
           for (const result of results) {
-            // we didn't find the repo so we add it
-            if (!org.repos.some((r) => r.url === result.url)) {
-              org.repos.push(result)
-              added++
+            const parsed = parseGithubUrl(result.url)
+            const key = `${parsed.owner}/${parsed.repoName}`
+            if (!repoSet.has(key)) {
+              repoSet.set(key, parsed)
+              svc.log.info(`fullSync: discovered new repo ${result.url} for org ${org.name}`)
             }
           }
         }
       }
 
-      if (added > 0) {
-        // we need to update the integration settings in the database
-        await setGithubIntegrationSettingsOrgs(
-          dbStoreQx(svc.postgres.writer),
-          integrationId,
-          settings.orgs,
-        )
-      }
-
-      const repos = new Set<IGithubRepoData>()
-      if (settings.orgs) {
-        for (const org of settings.orgs) {
-          for (const repo of org.repos) {
-            repos.add(parseGithubUrl(repo.url))
-          }
-        }
-      }
-      if (settings.repos) {
-        for (const repo of settings.repos) {
-          repos.add(parseGithubUrl(repo.url))
-        }
-      }
-
-      const finalRepos = Array.from(repos)
+      const finalRepos = Array.from(repoSet.values())
 
       // fetch nango mappings from the dedicated table
       const nangoMapping = await getNangoMappingsForIntegration(
diff --git a/services/apps/nango_worker/src/bin/check-nango-mapping.ts b/services/apps/nango_worker/src/bin/check-nango-mapping.ts
index 008a77cd5f..d60bec840d 100644
--- a/services/apps/nango_worker/src/bin/check-nango-mapping.ts
+++ b/services/apps/nango_worker/src/bin/check-nango-mapping.ts
@@ -5,6 +5,7 @@ import {
   getNangoMappingsForIntegration,
 } from '@crowd/data-access-layer/src/integrations'
 import { pgpQx } from '@crowd/data-access-layer/src/queryExecutor'
+import { getReposForGithubIntegration } from '@crowd/data-access-layer/src/repositories'
 import { getServiceLogger } from '@crowd/logging'
 import { PlatformType } from '@crowd/types'
 
@@ -60,37 +61,31 @@ async function collectStats(): Promise<Stats> {
       }
     }
 
-    // Loop through orgs in settings
-    if (integration.settings?.orgs) {
-      for (const org of integration.settings.orgs) {
-        // Loop through repos in each org
-        if (org.repos) {
-          for (const repo of org.repos) {
-            totalRepos++
-
-            if (connectionIds.length === 0) {
-              missingConnectionCount++
-              integrationsWithoutConnections.add(integration.id)
-              continue
-            }
-
-            let found = false
-            for (const mapping of Object.values(nangoMapping)) {
-              if (mapping.owner === org.name && mapping.repoName === repo.name) {
-                found = true
-                break
-              }
-            }
-
-            if (!found) {
-              missingConnectionCount++
-              integrationsWithoutConnections.add(integration.id)
-            } else {
-              connectedRepos++
-            }
-          }
+    // Get repos from repositories table
+    const repos = await getReposForGithubIntegration(qx, integration.id)
+    for (const repo of repos) {
+      totalRepos++
+
+      if (connectionIds.length === 0) {
+        missingConnectionCount++
+        integrationsWithoutConnections.add(integration.id)
+        continue
+      }
+
+      let found = false
+      for (const mapping of Object.values(nangoMapping)) {
+        if (mapping.owner === repo.owner && mapping.repoName === repo.name) {
+          found = true
+          break
         }
       }
+
+      if (!found) {
+        missingConnectionCount++
+        integrationsWithoutConnections.add(integration.id)
+      } else {
+        connectedRepos++
+      }
     }
   }
 
diff --git a/services/libs/data-access-layer/src/integrations/index.ts b/services/libs/data-access-layer/src/integrations/index.ts
index 734543b757..3b0de9588c 100644
--- a/services/libs/data-access-layer/src/integrations/index.ts
+++ b/services/libs/data-access-layer/src/integrations/index.ts
@@ -2,6 +2,7 @@ import { getServiceChildLogger } from '@crowd/logging'
 import { IIntegration, PlatformType } from '@crowd/types'
 
 import { QueryExecutor } from '../queryExecutor'
+import { getReposForGithubIntegration } from '../repositories'
 import { getReposBySegmentGroupedByPlatform } from '../segments'
 
 const log = getServiceChildLogger('db.integrations')
@@ -300,24 +301,6 @@ export async function fetchIntegrationById(
   )
 }
 
-export async function setGithubIntegrationSettingsOrgs(
-  qx: QueryExecutor,
-  integrationId: string,
-  orgs: unknown,
-): Promise<void> {
-  await qx.result(
-    `
-      update integrations
-      set settings = jsonb_set(settings, '{orgs}', $(orgs))
-      where id = $(integrationId)
-    `,
-    {
-      integrationId,
-      orgs: JSON.stringify(orgs),
-    },
-  )
-}
-
 export async function fetchNangoIntegrationDataForCheck(
   qx: QueryExecutor,
   platforms: string[],
@@ -640,18 +623,6 @@ export async function addRepoToGitIntegration(
   log.info({ integrationId: gitIntegration.id, repoUrl }, 'Added repo to git integration settings!')
 }
 
-export function extractGithubRepoSlug(url: string): string {
-  const parsedUrl = new URL(url)
-  const pathname = parsedUrl.pathname
-  const parts = pathname.split('/').filter(Boolean)
-
-  if (parts.length >= 2) {
-    return `${parts[0]}/${parts[1]}`
-  }
-
-  throw new Error('Invalid GitHub URL format')
-}
-
 export async function findNangoRepositoriesToBeRemoved(
   qx: QueryExecutor,
   integrationId: string,
@@ -668,24 +639,11 @@ export async function findNangoRepositoriesToBeRemoved(
     return []
   }
 
-  const repoSlugs = new Set<string>()
-  const settings = integration.settings as any
-
-  if (settings.orgs) {
-    for (const org of settings.orgs) {
-      for (const repo of org.repos ?? []) {
-        repoSlugs.add(extractGithubRepoSlug(repo.url))
-      }
-    }
-  }
-
-  if (settings.repos) {
-    for (const repo of settings.repos) {
-      repoSlugs.add(extractGithubRepoSlug(repo.url))
-    }
-  }
+  // Get desired repos from repositories table
+  const repos = await getReposForGithubIntegration(qx, integrationId)
+  const repoSlugs = new Set<string>(repos.map((r) => `${r.owner}/${r.name}`))
 
-  // determine which connections to delete if needed
+  // Find nango mappings that aren't in the desired set
   const reposToBeRemoved: string[] = []
   for (const mappedRepo of Object.values(nangoMappings)) {
     if (!repoSlugs.has(`${mappedRepo.owner}/${mappedRepo.repoName}`)) {
diff --git a/services/libs/data-access-layer/src/repositories/index.ts b/services/libs/data-access-layer/src/repositories/index.ts
index 1608c3db28..25dd63381e 100644
--- a/services/libs/data-access-layer/src/repositories/index.ts
+++ b/services/libs/data-access-layer/src/repositories/index.ts
@@ -557,6 +557,111 @@ export async function findSegmentsForRepos(
   return results
 }
 
+export interface IGithubRepoForIntegration {
+  url: string
+  name: string
+  owner: string
+  forkedFrom: string | null
+  updatedAt: string
+}
+
+export async function getReposForGithubIntegration(
+  qx: QueryExecutor,
+  integrationId: string,
+): Promise<IGithubRepoForIntegration[]> {
+  return qx.select(
+    `
+    SELECT
+      r.url,
+      split_part(r.url, '/', -1) as name,
+      split_part(r.url, '/', -2) as owner,
+      r."forkedFrom",
+      r."updatedAt"
+    FROM public.repositories r
+    WHERE r."sourceIntegrationId" = $(integrationId)
+      AND r."deletedAt" IS NULL
+    ORDER BY r.url
+    `,
+    { integrationId },
+  )
+}
+
+export async function getReposGroupedByOrg(
+  qx: QueryExecutor,
+  integrationId: string,
+): Promise<Record<string, IGithubRepoForIntegration[]>> {
+  const repos = await getReposForGithubIntegration(qx, integrationId)
+  const grouped: Record<string, IGithubRepoForIntegration[]> = {}
+  for (const repo of repos) {
+    if (!grouped[repo.owner]) grouped[repo.owner] = []
+    grouped[repo.owner].push(repo)
+  }
+  return grouped
+}
+
+/**
+ * Populates `settings.orgs[].repos` from the repositories table for github/github-nango integrations.
+ * Used by worker services to inject repo data into settings before passing to stream processors.
+ */
+export async function populateGithubSettingsWithRepos(
+  qx: QueryExecutor,
+  integrationId: string,
+  settings: unknown,
+): Promise<unknown> {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const s = settings as any
+  if (!s?.orgs || !Array.isArray(s.orgs)) return settings
+
+  const reposByOrg = await getReposGroupedByOrg(qx, integrationId)
+
+  // Only overwrite orgs[].repos if the repositories table has data.
+  // During the 'mapping' phase (legacy github connect), repos live in settings
+  // before being written to the repositories table via mapGithubRepos.
+  const hasRepos = Object.keys(reposByOrg).length > 0
+  if (!hasRepos) return settings
+
+  return {
+    ...s,
+    orgs: s.orgs.map((org: { name: string; [key: string]: unknown }) => ({
+      ...org,
+      repos: (reposByOrg[org.name] || []).map((r) => ({
+        url: r.url,
+        name: r.name,
+        owner: r.owner,
+        updatedAt: r.updatedAt,
+        forkedFrom: r.forkedFrom,
+      })),
+    })),
+  }
+}
+
+/**
+ * Strips repos, unavailableRepos, and orgs[].repos from integration settings in the DB.
+ * Called after mapUnifiedRepositories has written repos to the repositories table,
+ * so they are no longer duplicated in both places.
+ */
+export async function stripReposFromGithubSettings(
+  qx: QueryExecutor,
+  integrationId: string,
+): Promise<void> {
+  await qx.result(
+    `
+    UPDATE integrations
+    SET settings = jsonb_set(
+      settings - 'repos' - 'unavailableRepos',
+      '{orgs}',
+      COALESCE(
+        (SELECT jsonb_agg(org - 'repos') FROM jsonb_array_elements(settings->'orgs') org),
+        '[]'::jsonb
+      )
+    )
+    WHERE id = $(integrationId)
+      AND settings->'orgs' IS NOT NULL
+    `,
+    { integrationId },
+  )
+}
+
 /**
  * Updates repositories.enabled based on the provided list of enabled URLs.
  * Called when user toggles repository enabled status in the UI.
diff --git a/services/libs/integrations/src/integrations/github/index.ts b/services/libs/integrations/src/integrations/github/index.ts
index 7b028eefda..827de8d4da 100644
--- a/services/libs/integrations/src/integrations/github/index.ts
+++ b/services/libs/integrations/src/integrations/github/index.ts
@@ -16,10 +16,6 @@ const descriptor: IIntegrationDescriptor = {
   processStream,
   processWebhookStream,
   processData,
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  postProcess: (settings: any) => {
-    return settings
-  },
 }
 
 export default descriptor
diff --git a/services/libs/integrations/src/integrations/github/processStream.ts b/services/libs/integrations/src/integrations/github/processStream.ts
index 474f50053d..447b4ba50f 100644
--- a/services/libs/integrations/src/integrations/github/processStream.ts
+++ b/services/libs/integrations/src/integrations/github/processStream.ts
@@ -327,12 +327,9 @@ const processRootStream: ProcessStreamHandler = async (ctx) => {
     }
   }
 
-  // update integration settings
-  // this settings will be avaliable in next streams
+  // Only persist unavailableRepos for next-run re-checking.
+  // Repos live in the repositories table — do not write them back to settings.
   await ctx.updateIntegrationSettings({
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    ...(ctx.integration.settings as any),
-    repos,
     unavailableRepos,
   })
 
diff --git a/services/libs/types/src/integrationSettings.ts b/services/libs/types/src/integrationSettings.ts
index 65fc1ef89d..fc20feb386 100644
--- a/services/libs/types/src/integrationSettings.ts
+++ b/services/libs/types/src/integrationSettings.ts
@@ -19,12 +19,16 @@ export interface IGithubOrg {
   url: string
   fullSync: boolean
   updatedAt: string
-  repos: IGithubRepo[]
+  /** @deprecated Repos are stored in public.repositories table for github-nango.
+   * Only used by the legacy github platform. */
+  repos?: IGithubRepo[]
 }
 
 export interface IGithubIntegrationSettings {
   orgs: IGithubOrg[]
+  /** @deprecated Only used by legacy github platform (processStream.ts) */
   repos?: IGithubRepo[]
+  /** @deprecated Only used by legacy github platform (processStream.ts) */
   unavailableRepos?: IGithubRepo[]
   updateMemberAttributes?: boolean
 }