diff --git a/frontend/src/api/modpack.ts b/frontend/src/api/modpack.ts
new file mode 100644
index 0000000..214b753
--- /dev/null
+++ b/frontend/src/api/modpack.ts
@@ -0,0 +1,60 @@
+import apiClient from './client'
+import type { Modpack, ModpackState, PublicModpack } from '@/types'
+
+export async function getModpackState(): Promise<ModpackState> {
+  const response = await apiClient.get('/api/modpack')
+  return response.data.data
+}
+
+export async function saveModpackDraft(payload: {
+  name: string
+  version: string
+  modList: string[]
+  description: string | null
+}): Promise<Modpack> {
+  const response = await apiClient.put('/api/modpack', payload)
+  return response.data.data
+}
+
+export async function buildModpack(): Promise<Modpack> {
+  const response = await apiClient.post('/api/modpack/build')
+  return response.data.data
+}
+
+export async function publishModpack(): Promise<Modpack> {
+  const response = await apiClient.post('/api/modpack/publish')
+  return response.data.data
+}
+
+export async function archiveModpack(): Promise<Modpack> {
+  const response = await apiClient.post('/api/modpack/archive')
+  return response.data.data
+}
+
+export async function unarchiveModpack(): Promise<Modpack> {
+  const response = await apiClient.post('/api/modpack/unarchive')
+  return response.data.data
+}
+
+export async function deleteModpack(): Promise<void> {
+  await apiClient.delete('/api/modpack')
+}
+
+/**
+ * Public metadata for the currently-published modpack. Returns null if none
+ * is published. Doesn't require auth — used by the login page to decide
+ * whether to show the download CTA.
+ */
+export async function getPublishedModpack(): Promise<PublicModpack | null> {
+  try {
+    const response = await apiClient.get('/api/modpack/public')
+    const env = response.data
+    if (env?.code !== 200) return null
+    return env.data as PublicModpack
+  } catch {
+    return null
+  }
+}
+
+/** Public download URL — anchor href, not fetched programmatically. */
+export const publicModpackDownloadUrl = '/api/modpack/public/download'
diff --git a/frontend/src/i18n/locales/de.ts b/frontend/src/i18n/locales/de.ts
index 043b583..7bf9e43 100644
--- a/frontend/src/i18n/locales/de.ts
+++ b/frontend/src/i18n/locales/de.ts
@@ -1037,6 +1037,53 @@ const de = {
     modsFound: 'Mods gefunden',
   },
 
+  modpack: {
+    tabLabel: 'Modpack',
+    intro: 'Bündeln Sie installierte Mods in eine einzelne ZIP-Datei, die Spieler von der Anmeldeseite herunterladen können. Nur das veröffentlichte Paket ist öffentlich verfügbar — Entwürfe und archivierte Pakete bleiben privat.',
+    status: {
+      draft: 'Entwurf',
+      published: 'Veröffentlicht',
+      archived: 'Archiviert',
+    },
+    modCount: '{n} Mod(s)',
+    downloadsCount: '{n} Download(s)',
+    publicDownloadLink: 'Öffentlichen Download-Link öffnen',
+    fields: {
+      name: 'Paketname',
+      version: 'Version',
+      modList: 'Enthaltene Mods',
+      description: 'Beschreibung',
+    },
+    placeholders: {
+      name: 'z. B. KitsuneDen Client Pack',
+      modList: 'Mods zum Einschließen auswählen...',
+      description: 'Optional — was im Paket ist, für wen, Versions-Notizen.',
+    },
+    modListHint: 'Nur Mods, die derzeit auf dem Server installiert sind, erscheinen hier. Fügen Sie zuerst ein Mod über die Registerkarte „Installiert“ hinzu, dann kehren Sie zurück.',
+    actions: {
+      saveDraft: 'Entwurf speichern',
+      build: 'ZIP erstellen',
+      publish: 'Veröffentlichen',
+      archive: 'Archivieren',
+      unarchive: 'Aus Archiv wiederherstellen',
+      delete: 'Paket löschen',
+    },
+    confirmDelete: 'Modpack-Datensatz und ZIP-Datei löschen? Spieler verlieren den Download-Link, bis Sie ein neues veröffentlichen.',
+    ctaTooltip: '{size} · {n} Mod(s)',
+    saved: 'Modpack als Entwurf gespeichert',
+    built: 'Modpack-ZIP erstellt',
+    published: 'Modpack veröffentlicht — Download ist jetzt auf der Anmeldeseite verfügbar',
+    archived: 'Modpack archiviert',
+    unarchived: 'Modpack als Entwurf wiederhergestellt',
+    deleted: 'Modpack gelöscht',
+    failedToLoad: 'Modpack konnte nicht geladen werden',
+    failedToSave: 'Modpack konnte nicht gespeichert werden',
+    failedToBuild: 'Modpack-ZIP konnte nicht erstellt werden',
+    failedToPublish: 'Modpack konnte nicht veröffentlicht werden',
+    failedToArchive: 'Modpack konnte nicht archiviert werden',
+    failedToDelete: 'Modpack konnte nicht gelöscht werden',
+  },
+
   backups: {
     title: 'Sicherungen',
     createNow: 'Sicherung erstellen',
diff --git a/frontend/src/i18n/locales/en.ts b/frontend/src/i18n/locales/en.ts
index 1fc4df3..a16434c 100644
--- a/frontend/src/i18n/locales/en.ts
+++ b/frontend/src/i18n/locales/en.ts
@@ -1034,6 +1034,53 @@ const en = {
     modsFound: 'mods found',
   },
 
+  modpack: {
+    tabLabel: 'Modpack',
+    intro: 'Bundle installed mods into a single zip players can download from the login page. Only the published pack is publicly downloadable — drafts and archived packs stay private.',
+    status: {
+      draft: 'Draft',
+      published: 'Published',
+      archived: 'Archived',
+    },
+    modCount: '{n} mod(s)',
+    downloadsCount: '{n} download(s)',
+    publicDownloadLink: 'Open public download link',
+    fields: {
+      name: 'Pack name',
+      version: 'Version',
+      modList: 'Included mods',
+      description: 'Description',
+    },
+    placeholders: {
+      name: 'e.g. KitsuneDen Client Pack',
+      modList: 'Pick mods to include...',
+      description: 'Optional — what\'s in this pack, who it\'s for, version notes.',
+    },
+    modListHint: 'Only mods currently installed on the server appear here. Add a mod via the Installed tab first, then come back to include it.',
+    actions: {
+      saveDraft: 'Save Draft',
+      build: 'Build Zip',
+      publish: 'Publish',
+      archive: 'Archive',
+      unarchive: 'Restore from Archive',
+      delete: 'Delete Pack',
+    },
+    confirmDelete: 'Delete the modpack record and its zip file? Players will lose the download link until you publish a new one.',
+    ctaTooltip: '{size} · {n} mod(s)',
+    saved: 'Modpack saved as draft',
+    built: 'Modpack zip built',
+    published: 'Modpack published — download is now live on the login page',
+    archived: 'Modpack archived',
+    unarchived: 'Modpack restored to draft',
+    deleted: 'Modpack deleted',
+    failedToLoad: 'Failed to load modpack',
+    failedToSave: 'Failed to save modpack',
+    failedToBuild: 'Failed to build modpack zip',
+    failedToPublish: 'Failed to publish modpack',
+    failedToArchive: 'Failed to archive modpack',
+    failedToDelete: 'Failed to delete modpack',
+  },
+
   backups: {
     title: 'Backups',
     createNow: 'Create Backup',
diff --git a/frontend/src/i18n/locales/es.ts b/frontend/src/i18n/locales/es.ts
index 6f90f63..0a7c67d 100644
--- a/frontend/src/i18n/locales/es.ts
+++ b/frontend/src/i18n/locales/es.ts
@@ -1037,6 +1037,53 @@ const es = {
     modsFound: 'mods encontrados',
   },
 
+  modpack: {
+    tabLabel: 'Modpack',
+    intro: 'Agrupe los mods instalados en un único archivo ZIP que los jugadores pueden descargar desde la página de inicio de sesión. Solo el pack publicado se puede descargar públicamente — los borradores y los packs archivados permanecen privados.',
+    status: {
+      draft: 'Borrador',
+      published: 'Publicado',
+      archived: 'Archivado',
+    },
+    modCount: '{n} mod(s)',
+    downloadsCount: '{n} descarga(s)',
+    publicDownloadLink: 'Abrir enlace de descarga pública',
+    fields: {
+      name: 'Nombre del pack',
+      version: 'Versión',
+      modList: 'Mods incluidos',
+      description: 'Descripción',
+    },
+    placeholders: {
+      name: 'p. ej. KitsuneDen Client Pack',
+      modList: 'Elija mods para incluir...',
+      description: 'Opcional — qué contiene este pack, a quién va dirigido, notas de versión.',
+    },
+    modListHint: 'Solo aparecen aquí los mods actualmente instalados en el servidor. Añada primero un mod desde la pestaña Instalados, y luego regrese para incluirlo.',
+    actions: {
+      saveDraft: 'Guardar borrador',
+      build: 'Construir ZIP',
+      publish: 'Publicar',
+      archive: 'Archivar',
+      unarchive: 'Restaurar desde archivo',
+      delete: 'Eliminar pack',
+    },
+    confirmDelete: '¿Eliminar el registro del modpack y su archivo ZIP? Los jugadores perderán el enlace de descarga hasta que publique uno nuevo.',
+    ctaTooltip: '{size} · {n} mod(s)',
+    saved: 'Modpack guardado como borrador',
+    built: 'ZIP del modpack construido',
+    published: 'Modpack publicado — la descarga está activa en la página de inicio de sesión',
+    archived: 'Modpack archivado',
+    unarchived: 'Modpack restaurado a borrador',
+    deleted: 'Modpack eliminado',
+    failedToLoad: 'No se pudo cargar el modpack',
+    failedToSave: 'No se pudo guardar el modpack',
+    failedToBuild: 'No se pudo construir el ZIP del modpack',
+    failedToPublish: 'No se pudo publicar el modpack',
+    failedToArchive: 'No se pudo archivar el modpack',
+    failedToDelete: 'No se pudo eliminar el modpack',
+  },
+
   backups: {
     title: 'Copias de seguridad',
     createNow: 'Crear copia de seguridad',
diff --git a/frontend/src/i18n/locales/fr.ts b/frontend/src/i18n/locales/fr.ts
index 4794ed2..321db8b 100644
--- a/frontend/src/i18n/locales/fr.ts
+++ b/frontend/src/i18n/locales/fr.ts
@@ -1037,6 +1037,53 @@ const fr = {
     modsFound: 'mods trouvés',
   },
 
+  modpack: {
+    tabLabel: 'Modpack',
+    intro: 'Regroupez les mods installés dans une seule archive ZIP que les joueurs peuvent télécharger depuis la page de connexion. Seul le pack publié est téléchargeable publiquement — les brouillons et les packs archivés restent privés.',
+    status: {
+      draft: 'Brouillon',
+      published: 'Publié',
+      archived: 'Archivé',
+    },
+    modCount: '{n} mod(s)',
+    downloadsCount: '{n} téléchargement(s)',
+    publicDownloadLink: 'Ouvrir le lien de téléchargement public',
+    fields: {
+      name: 'Nom du pack',
+      version: 'Version',
+      modList: 'Mods inclus',
+      description: 'Description',
+    },
+    placeholders: {
+      name: 'p. ex. KitsuneDen Client Pack',
+      modList: 'Choisissez les mods à inclure...',
+      description: 'Optionnel — ce qui est dans ce pack, à qui il s\'adresse, notes de version.',
+    },
+    modListHint: 'Seuls les mods actuellement installés sur le serveur apparaissent ici. Ajoutez d\'abord un mod via l\'onglet Installés, puis revenez pour l\'inclure.',
+    actions: {
+      saveDraft: 'Enregistrer le brouillon',
+      build: 'Construire le ZIP',
+      publish: 'Publier',
+      archive: 'Archiver',
+      unarchive: 'Restaurer depuis l\'archive',
+      delete: 'Supprimer le pack',
+    },
+    confirmDelete: 'Supprimer l\'enregistrement du modpack et son fichier ZIP ? Les joueurs perdront le lien de téléchargement jusqu\'à ce que vous publiiez un nouveau pack.',
+    ctaTooltip: '{size} · {n} mod(s)',
+    saved: 'Modpack enregistré comme brouillon',
+    built: 'ZIP du modpack construit',
+    published: 'Modpack publié — le téléchargement est désormais actif sur la page de connexion',
+    archived: 'Modpack archivé',
+    unarchived: 'Modpack restauré en brouillon',
+    deleted: 'Modpack supprimé',
+    failedToLoad: 'Impossible de charger le modpack',
+    failedToSave: 'Impossible d\'enregistrer le modpack',
+    failedToBuild: 'Impossible de construire le ZIP du modpack',
+    failedToPublish: 'Impossible de publier le modpack',
+    failedToArchive: 'Impossible d\'archiver le modpack',
+    failedToDelete: 'Impossible de supprimer le modpack',
+  },
+
   backups: {
     title: 'Sauvegardes',
     createNow: 'Créer une sauvegarde',
diff --git a/frontend/src/i18n/locales/ja.ts b/frontend/src/i18n/locales/ja.ts
index e5ba366..05647a8 100644
--- a/frontend/src/i18n/locales/ja.ts
+++ b/frontend/src/i18n/locales/ja.ts
@@ -1022,6 +1022,45 @@ const ja: Messages = {
     modsFound: '件のMODが見つかりました',
   },
 
+  modpack: {
+    // English placeholders — translations TBD
+    tabLabel: 'Modpack',
+    intro: 'Bundle installed mods into a single zip players can download from the login page. Only the published pack is publicly downloadable — drafts and archived packs stay private.',
+    status: { draft: 'Draft', published: 'Published', archived: 'Archived' },
+    modCount: '{n} mod(s)',
+    downloadsCount: '{n} download(s)',
+    publicDownloadLink: 'Open public download link',
+    fields: { name: 'Pack name', version: 'Version', modList: 'Included mods', description: 'Description' },
+    placeholders: {
+      name: 'e.g. KitsuneDen Client Pack',
+      modList: 'Pick mods to include...',
+      description: 'Optional — what\'s in this pack, who it\'s for, version notes.',
+    },
+    modListHint: 'Only mods currently installed on the server appear here. Add a mod via the Installed tab first, then come back to include it.',
+    actions: {
+      saveDraft: 'Save Draft',
+      build: 'Build Zip',
+      publish: 'Publish',
+      archive: 'Archive',
+      unarchive: 'Restore from Archive',
+      delete: 'Delete Pack',
+    },
+    confirmDelete: 'Delete the modpack record and its zip file? Players will lose the download link until you publish a new one.',
+    ctaTooltip: '{size} · {n} mod(s)',
+    saved: 'Modpack saved as draft',
+    built: 'Modpack zip built',
+    published: 'Modpack published — download is now live on the login page',
+    archived: 'Modpack archived',
+    unarchived: 'Modpack restored to draft',
+    deleted: 'Modpack deleted',
+    failedToLoad: 'Failed to load modpack',
+    failedToSave: 'Failed to save modpack',
+    failedToBuild: 'Failed to build modpack zip',
+    failedToPublish: 'Failed to publish modpack',
+    failedToArchive: 'Failed to archive modpack',
+    failedToDelete: 'Failed to delete modpack',
+  },
+
   backups: {
     title: 'バックアップ',
     createNow: 'バックアップを作成',
diff --git a/frontend/src/i18n/locales/ko.ts b/frontend/src/i18n/locales/ko.ts
index 19c7893..e5c668e 100644
--- a/frontend/src/i18n/locales/ko.ts
+++ b/frontend/src/i18n/locales/ko.ts
@@ -1038,6 +1038,45 @@ const ko: Messages = {
     modsFound: '개의 모드를 찾았습니다',
   },
 
+  modpack: {
+    // English placeholders — translations TBD
+    tabLabel: 'Modpack',
+    intro: 'Bundle installed mods into a single zip players can download from the login page. Only the published pack is publicly downloadable — drafts and archived packs stay private.',
+    status: { draft: 'Draft', published: 'Published', archived: 'Archived' },
+    modCount: '{n} mod(s)',
+    downloadsCount: '{n} download(s)',
+    publicDownloadLink: 'Open public download link',
+    fields: { name: 'Pack name', version: 'Version', modList: 'Included mods', description: 'Description' },
+    placeholders: {
+      name: 'e.g. KitsuneDen Client Pack',
+      modList: 'Pick mods to include...',
+      description: 'Optional — what\'s in this pack, who it\'s for, version notes.',
+    },
+    modListHint: 'Only mods currently installed on the server appear here. Add a mod via the Installed tab first, then come back to include it.',
+    actions: {
+      saveDraft: 'Save Draft',
+      build: 'Build Zip',
+      publish: 'Publish',
+      archive: 'Archive',
+      unarchive: 'Restore from Archive',
+      delete: 'Delete Pack',
+    },
+    confirmDelete: 'Delete the modpack record and its zip file? Players will lose the download link until you publish a new one.',
+    ctaTooltip: '{size} · {n} mod(s)',
+    saved: 'Modpack saved as draft',
+    built: 'Modpack zip built',
+    published: 'Modpack published — download is now live on the login page',
+    archived: 'Modpack archived',
+    unarchived: 'Modpack restored to draft',
+    deleted: 'Modpack deleted',
+    failedToLoad: 'Failed to load modpack',
+    failedToSave: 'Failed to save modpack',
+    failedToBuild: 'Failed to build modpack zip',
+    failedToPublish: 'Failed to publish modpack',
+    failedToArchive: 'Failed to archive modpack',
+    failedToDelete: 'Failed to delete modpack',
+  },
+
   backups: {
     title: '백업',
     createNow: '백업 생성',
diff --git a/frontend/src/i18n/locales/zh-CN.ts b/frontend/src/i18n/locales/zh-CN.ts
index 5dbc766..175d091 100644
--- a/frontend/src/i18n/locales/zh-CN.ts
+++ b/frontend/src/i18n/locales/zh-CN.ts
@@ -1038,6 +1038,45 @@ const zhCN: Messages = {
     modsFound: '个模组',
   },
 
+  modpack: {
+    // English placeholders — translations TBD
+    tabLabel: 'Modpack',
+    intro: 'Bundle installed mods into a single zip players can download from the login page. Only the published pack is publicly downloadable — drafts and archived packs stay private.',
+    status: { draft: 'Draft', published: 'Published', archived: 'Archived' },
+    modCount: '{n} mod(s)',
+    downloadsCount: '{n} download(s)',
+    publicDownloadLink: 'Open public download link',
+    fields: { name: 'Pack name', version: 'Version', modList: 'Included mods', description: 'Description' },
+    placeholders: {
+      name: 'e.g. KitsuneDen Client Pack',
+      modList: 'Pick mods to include...',
+      description: 'Optional — what\'s in this pack, who it\'s for, version notes.',
+    },
+    modListHint: 'Only mods currently installed on the server appear here. Add a mod via the Installed tab first, then come back to include it.',
+    actions: {
+      saveDraft: 'Save Draft',
+      build: 'Build Zip',
+      publish: 'Publish',
+      archive: 'Archive',
+      unarchive: 'Restore from Archive',
+      delete: 'Delete Pack',
+    },
+    confirmDelete: 'Delete the modpack record and its zip file? Players will lose the download link until you publish a new one.',
+    ctaTooltip: '{size} · {n} mod(s)',
+    saved: 'Modpack saved as draft',
+    built: 'Modpack zip built',
+    published: 'Modpack published — download is now live on the login page',
+    archived: 'Modpack archived',
+    unarchived: 'Modpack restored to draft',
+    deleted: 'Modpack deleted',
+    failedToLoad: 'Failed to load modpack',
+    failedToSave: 'Failed to save modpack',
+    failedToBuild: 'Failed to build modpack zip',
+    failedToPublish: 'Failed to publish modpack',
+    failedToArchive: 'Failed to archive modpack',
+    failedToDelete: 'Failed to delete modpack',
+  },
+
   backups: {
     title: '备份',
     createNow: '创建备份',
diff --git a/frontend/src/i18n/locales/zh-TW.ts b/frontend/src/i18n/locales/zh-TW.ts
index 67bd012..0d32452 100644
--- a/frontend/src/i18n/locales/zh-TW.ts
+++ b/frontend/src/i18n/locales/zh-TW.ts
@@ -1038,6 +1038,45 @@ const zhTW: Messages = {
     modsFound: '個模組',
   },
 
+  modpack: {
+    // English placeholders — translations TBD
+    tabLabel: 'Modpack',
+    intro: 'Bundle installed mods into a single zip players can download from the login page. Only the published pack is publicly downloadable — drafts and archived packs stay private.',
+    status: { draft: 'Draft', published: 'Published', archived: 'Archived' },
+    modCount: '{n} mod(s)',
+    downloadsCount: '{n} download(s)',
+    publicDownloadLink: 'Open public download link',
+    fields: { name: 'Pack name', version: 'Version', modList: 'Included mods', description: 'Description' },
+    placeholders: {
+      name: 'e.g. KitsuneDen Client Pack',
+      modList: 'Pick mods to include...',
+      description: 'Optional — what\'s in this pack, who it\'s for, version notes.',
+    },
+    modListHint: 'Only mods currently installed on the server appear here. Add a mod via the Installed tab first, then come back to include it.',
+    actions: {
+      saveDraft: 'Save Draft',
+      build: 'Build Zip',
+      publish: 'Publish',
+      archive: 'Archive',
+      unarchive: 'Restore from Archive',
+      delete: 'Delete Pack',
+    },
+    confirmDelete: 'Delete the modpack record and its zip file? Players will lose the download link until you publish a new one.',
+    ctaTooltip: '{size} · {n} mod(s)',
+    saved: 'Modpack saved as draft',
+    built: 'Modpack zip built',
+    published: 'Modpack published — download is now live on the login page',
+    archived: 'Modpack archived',
+    unarchived: 'Modpack restored to draft',
+    deleted: 'Modpack deleted',
+    failedToLoad: 'Failed to load modpack',
+    failedToSave: 'Failed to save modpack',
+    failedToBuild: 'Failed to build modpack zip',
+    failedToPublish: 'Failed to publish modpack',
+    failedToArchive: 'Failed to archive modpack',
+    failedToDelete: 'Failed to delete modpack',
+  },
+
   backups: {
     title: '備份',
     createNow: '建立備份',
diff --git a/frontend/src/types/index.ts b/frontend/src/types/index.ts
index 76c3876..acce5e7 100644
--- a/frontend/src/types/index.ts
+++ b/frontend/src/types/index.ts
@@ -265,6 +265,47 @@ export interface ChatCommandSettings {
   voteCooldownSeconds: number
 }
 
+// ─── Modpack Types ───────────────────────────────────
+
+export type ModpackStatus = 'draft' | 'published' | 'archived'
+
+export interface Modpack {
+  id: number
+  name: string
+  version: string
+  status: ModpackStatus
+  filename: string | null
+  sizeBytes: number
+  modCount: number
+  modList: string             // JSON string of mod folder names
+  description: string | null
+  createdAt: string
+  updatedAt: string
+  downloadCount: number
+}
+
+export interface ModpackInstalledMod {
+  name: string                // folder name
+  displayName: string
+  version: string
+}
+
+/** Admin-facing state envelope returned by GET /api/modpack. */
+export interface ModpackState {
+  modpack: Modpack | null
+  modList: string[]           // parsed-out folder names included in the pack
+  installedMods: ModpackInstalledMod[]
+}
+
+/** Public-facing trimmed envelope returned by GET /api/modpack/public. */
+export interface PublicModpack {
+  name: string
+  version: string
+  sizeBytes: number
+  modCount: number
+  description: string | null
+}
+
 // ─── Vote Rewards Types ──────────────────────────────
 
 /** Reward delivery shape — mirrors the C# VoteRewardType static class. */
diff --git a/frontend/src/views/LoginView.vue b/frontend/src/views/LoginView.vue
index 18fcd26..109eb0c 100644
--- a/frontend/src/views/LoginView.vue
+++ b/frontend/src/views/LoginView.vue
@@ -1,9 +1,11 @@
 <script setup lang="ts">
-import { ref } from 'vue'
+import { ref, onMounted } from 'vue'
 import { useRouter } from 'vue-router'
 import { useAuthStore } from '@/stores/auth'
 import { useI18n } from 'vue-i18n'
 import { SUPPORTED_LOCALES, setLocale, type LocaleCode } from '@/i18n'
+import { getPublishedModpack, publicModpackDownloadUrl } from '@/api/modpack'
+import type { PublicModpack } from '@/types'
 import InputText from 'primevue/inputtext'
 import Password from 'primevue/password'
 import Button from 'primevue/button'
@@ -19,6 +21,12 @@ const password = ref('')
 const loading = ref(false)
 const error = ref('')
 
+// Player-facing modpack download CTA. Fetched anonymously; resolves to null
+// (silently) if no pack is published. We export the URL constant rather than
+// fetching the file via axios — the browser handles the streaming download.
+const publishedModpack = ref<PublicModpack | null>(null)
+const modpackDownloadUrl = publicModpackDownloadUrl
+
 const localeOptions = SUPPORTED_LOCALES.map((l) => ({ label: l.name, value: l.code }))
 const selectedLocale = ref(locale.value as string)
 
@@ -27,6 +35,17 @@ function onLocaleChange(val: string) {
   setLocale(val as LocaleCode)
 }
 
+function formatModpackSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(0)} KB`
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`
+}
+
+onMounted(async () => {
+  publishedModpack.value = await getPublishedModpack()
+})
+
 async function handleLogin() {
   if (!username.value || !password.value) {
     error.value = t('login.errorBothRequired')
@@ -50,6 +69,27 @@ async function handleLogin() {
 
 <template>
   <div class="login-container">
+    <!--
+      Modpack download CTA — top-right corner, only renders when admin has
+      published a pack. No auth needed; clicking goes straight to the
+      streamed-zip endpoint. Title attribute shows size + mod count on hover.
+    -->
+    <a
+      v-if="publishedModpack"
+      :href="modpackDownloadUrl"
+      class="modpack-cta"
+      :title="t('modpack.ctaTooltip', {
+        size: formatModpackSize(publishedModpack.sizeBytes),
+        n: publishedModpack.modCount,
+      })"
+    >
+      <i class="pi pi-download modpack-cta-icon" />
+      <span class="modpack-cta-text">
+        <span class="modpack-cta-name">{{ publishedModpack.name }}</span>
+        <span class="modpack-cta-version">v{{ publishedModpack.version }}</span>
+      </span>
+    </a>
+
     <div class="login-card">
       <div class="login-header">
         <img
@@ -231,8 +271,54 @@ async function handleLogin() {
   width: 100%;
 }
 
+/* Top-right modpack download CTA. Pinned to the page corner rather than
+   inside the login card so it's visible even when the card is animating
+   in / out and doesn't compete with the form fields. */
+.modpack-cta {
+  position: absolute;
+  top: 1.25rem;
+  right: 1.25rem;
+  display: inline-flex;
+  align-items: center;
+  gap: 0.6rem;
+  padding: 0.55rem 0.95rem;
+  background: var(--kc-bg-card);
+  border: 1px solid var(--kc-border);
+  border-radius: 999px;
+  color: var(--kc-text-secondary);
+  text-decoration: none;
+  font-size: 0.85rem;
+  font-weight: 500;
+  transition: background-color 150ms ease, border-color 150ms ease, color 150ms ease;
+}
+
+.modpack-cta:hover {
+  background: var(--kc-bg-elevated, rgba(255, 255, 255, 0.04));
+  border-color: var(--kc-cyan);
+  color: var(--kc-text-primary, #fff);
+}
+
+.modpack-cta-icon {
+  font-size: 1rem;
+  color: var(--kc-cyan);
+}
+
+.modpack-cta-text { display: inline-flex; align-items: baseline; gap: 0.4rem; }
+.modpack-cta-name { font-weight: 600; }
+.modpack-cta-version {
+  font-variant-numeric: tabular-nums;
+  color: var(--kc-text-secondary);
+  font-size: 0.78rem;
+}
+
 @media (max-width: 640px) {
   .login-card { padding: 1.5rem; margin: 1rem; }
   .login-title { font-size: 1.5rem; }
+  .modpack-cta {
+    top: 0.75rem;
+    right: 0.75rem;
+    padding: 0.45rem 0.8rem;
+    font-size: 0.78rem;
+  }
 }
 </style>
diff --git a/frontend/src/views/ModsView.vue b/frontend/src/views/ModsView.vue
index 5e79ab5..09f0156 100644
--- a/frontend/src/views/ModsView.vue
+++ b/frontend/src/views/ModsView.vue
@@ -3,8 +3,21 @@ import { ref, computed, onMounted } from 'vue'
 import { useI18n } from 'vue-i18n'
 import { useToast } from 'primevue/usetoast'
 import { getMods, uploadMod, deleteMod, toggleMod, type ModInfo } from '@/api/mods'
+import {
+  getModpackState,
+  saveModpackDraft,
+  buildModpack,
+  publishModpack,
+  archiveModpack,
+  unarchiveModpack,
+  deleteModpack,
+  publicModpackDownloadUrl,
+} from '@/api/modpack'
+import type { ModpackState, ModpackInstalledMod } from '@/types'
 import Button from 'primevue/button'
 import InputText from 'primevue/inputtext'
+import Textarea from 'primevue/textarea'
+import MultiSelect from 'primevue/multiselect'
 import DataTable from 'primevue/datatable'
 import Column from 'primevue/column'
 import Tag from 'primevue/tag'
@@ -142,7 +155,135 @@ async function handleToggle(mod: ModInfo) {
   }
 }
 
-onMounted(loadMods)
+// ─── Modpack tab ──────────────────────────────────────────────
+// Single-record modpack feature: admin picks installed mods, gives the
+// pack a name + version, builds a zip, then publishes it so the login
+// page download CTA appears.
+const modpackLoading = ref(false)
+const modpackSaving = ref(false)
+const modpackBuilding = ref(false)
+const modpackState = ref<ModpackState>({ modpack: null, modList: [], installedMods: [] })
+const modpackForm = ref({
+  name: '',
+  version: '',
+  modList: [] as string[],
+  description: '',
+})
+const modpackConfirmDeleteVisible = ref(false)
+
+const modpackStatusSeverity = computed<'success' | 'info' | 'secondary'>(() => {
+  switch (modpackState.value.modpack?.status) {
+    case 'published': return 'success'
+    case 'draft': return 'info'
+    default: return 'secondary'
+  }
+})
+
+const modpackIsBuilt = computed(
+  () => !!modpackState.value.modpack?.filename && (modpackState.value.modpack?.sizeBytes ?? 0) > 0,
+)
+
+const modpackOptions = computed<ModpackInstalledMod[]>(() =>
+  modpackState.value.installedMods,
+)
+
+async function loadModpack() {
+  modpackLoading.value = true
+  try {
+    modpackState.value = await getModpackState()
+    if (modpackState.value.modpack) {
+      modpackForm.value.name = modpackState.value.modpack.name
+      modpackForm.value.version = modpackState.value.modpack.version
+      modpackForm.value.modList = modpackState.value.modList
+      modpackForm.value.description = modpackState.value.modpack.description ?? ''
+    }
+  } catch {
+    toast.add({ severity: 'error', summary: t('common.error'), detail: t('modpack.failedToLoad'), life: 4000 })
+  } finally {
+    modpackLoading.value = false
+  }
+}
+
+async function handleSaveModpack() {
+  modpackSaving.value = true
+  try {
+    await saveModpackDraft({
+      name: modpackForm.value.name,
+      version: modpackForm.value.version,
+      modList: modpackForm.value.modList,
+      description: modpackForm.value.description || null,
+    })
+    toast.add({ severity: 'success', summary: t('common.success'), detail: t('modpack.saved'), life: 3000 })
+    await loadModpack()
+  } catch (err: any) {
+    const detail = err.response?.data?.message ?? t('modpack.failedToSave')
+    toast.add({ severity: 'error', summary: t('common.error'), detail, life: 5000 })
+  } finally {
+    modpackSaving.value = false
+  }
+}
+
+async function handleBuildModpack() {
+  modpackBuilding.value = true
+  try {
+    await buildModpack()
+    toast.add({ severity: 'success', summary: t('common.success'), detail: t('modpack.built'), life: 4000 })
+    await loadModpack()
+  } catch (err: any) {
+    const detail = err.response?.data?.message ?? t('modpack.failedToBuild')
+    toast.add({ severity: 'error', summary: t('common.error'), detail, life: 5000 })
+  } finally {
+    modpackBuilding.value = false
+  }
+}
+
+async function handlePublishModpack() {
+  try {
+    await publishModpack()
+    toast.add({ severity: 'success', summary: t('common.success'), detail: t('modpack.published'), life: 3000 })
+    await loadModpack()
+  } catch (err: any) {
+    const detail = err.response?.data?.message ?? t('modpack.failedToPublish')
+    toast.add({ severity: 'error', summary: t('common.error'), detail, life: 5000 })
+  }
+}
+
+async function handleArchiveModpack() {
+  try {
+    await archiveModpack()
+    toast.add({ severity: 'success', summary: t('common.success'), detail: t('modpack.archived'), life: 3000 })
+    await loadModpack()
+  } catch {
+    toast.add({ severity: 'error', summary: t('common.error'), detail: t('modpack.failedToArchive'), life: 4000 })
+  }
+}
+
+async function handleUnarchiveModpack() {
+  try {
+    await unarchiveModpack()
+    toast.add({ severity: 'success', summary: t('common.success'), detail: t('modpack.unarchived'), life: 3000 })
+    await loadModpack()
+  } catch {
+    toast.add({ severity: 'error', summary: t('common.error'), detail: t('modpack.failedToArchive'), life: 4000 })
+  }
+}
+
+async function handleDeleteModpack() {
+  modpackConfirmDeleteVisible.value = false
+  try {
+    await deleteModpack()
+    toast.add({ severity: 'success', summary: t('common.success'), detail: t('modpack.deleted'), life: 3000 })
+    modpackForm.value = { name: '', version: '', modList: [], description: '' }
+    await loadModpack()
+  } catch {
+    toast.add({ severity: 'error', summary: t('common.error'), detail: t('modpack.failedToDelete'), life: 4000 })
+  }
+}
+
+onMounted(() => {
+  loadMods()
+  loadModpack()
+})
 </script>
 
 <template>
@@ -155,6 +296,7 @@ onMounted(loadMods)
       <TabList>
         <Tab value="0"><i class="pi pi-box" style="margin-right: 0.5rem" />{{ t('mods.installed') }}</Tab>
         <Tab value="1"><i class="pi pi-compass" style="margin-right: 0.5rem" />{{ t('mods.discover') }}</Tab>
+        <Tab value="2"><i class="pi pi-folder" style="margin-right: 0.5rem" />{{ t('modpack.tabLabel') }}</Tab>
       </TabList>
       <TabPanels>
         <TabPanel value="0">
@@ -255,9 +397,140 @@ onMounted(loadMods)
         <TabPanel value="1">
           <ModDiscoveryTab />
         </TabPanel>
+
+        <TabPanel value="2">
+          <div class="tab-content modpack-tab">
+            <Message severity="info" :closable="false">
+              {{ t('modpack.intro') }}
+            </Message>
+
+            <div v-if="modpackLoading" class="empty-state">
+              <i class="pi pi-spin pi-spinner" style="font-size: 2rem; color: var(--kc-text-secondary)" />
+              <p>{{ t('common.loading') }}</p>
+            </div>
+
+            <div v-else class="modpack-form">
+              <!-- Current status + summary card -->
+              <div v-if="modpackState.modpack" class="modpack-status-card">
+                <div class="modpack-status-row">
+                  <Tag :severity="modpackStatusSeverity" :value="t('modpack.status.' + modpackState.modpack.status)" />
+                  <span class="modpack-status-name">
+                    {{ modpackState.modpack.name }} <span class="modpack-version">v{{ modpackState.modpack.version }}</span>
+                  </span>
+                </div>
+                <div class="modpack-status-meta">
+                  <span>{{ t('modpack.modCount', { n: modpackState.modpack.modCount }) }}</span>
+                  <span v-if="modpackIsBuilt">{{ formatSize(modpackState.modpack.sizeBytes) }}</span>
+                  <span v-if="modpackIsBuilt">{{ t('modpack.downloadsCount', { n: modpackState.modpack.downloadCount }) }}</span>
+                </div>
+                <div v-if="modpackState.modpack.status === 'published' && modpackIsBuilt" class="modpack-public-link">
+                  <i class="pi pi-link" style="margin-right: 0.4rem" />
+                  <a :href="publicModpackDownloadUrl" target="_blank" rel="noopener">
+                    {{ t('modpack.publicDownloadLink') }}
+                  </a>
+                </div>
+              </div>
+
+              <!-- Edit form -->
+              <div class="form-grid">
+                <div class="form-group">
+                  <label class="form-label">{{ t('modpack.fields.name') }}</label>
+                  <InputText v-model="modpackForm.name" class="form-input" :placeholder="t('modpack.placeholders.name')" />
+                </div>
+                <div class="form-group">
+                  <label class="form-label">{{ t('modpack.fields.version') }}</label>
+                  <InputText v-model="modpackForm.version" class="form-input" placeholder="1.0.0" />
+                </div>
+              </div>
+
+              <div class="form-group">
+                <label class="form-label">{{ t('modpack.fields.modList') }}</label>
+                <MultiSelect
+                  v-model="modpackForm.modList"
+                  :options="modpackOptions"
+                  optionLabel="displayName"
+                  optionValue="name"
+                  :placeholder="t('modpack.placeholders.modList')"
+                  filter
+                  display="chip"
+                  class="form-input modpack-multiselect"
+                />
+                <small class="form-hint">{{ t('modpack.modListHint') }}</small>
+              </div>
+
+              <div class="form-group">
+                <label class="form-label">{{ t('modpack.fields.description') }}</label>
+                <Textarea v-model="modpackForm.description" rows="3" class="form-input" :placeholder="t('modpack.placeholders.description')" />
+              </div>
+
+              <!-- Action row. Buttons gate themselves on current status. -->
+              <div class="modpack-actions">
+                <Button
+                  :label="t('modpack.actions.saveDraft')"
+                  icon="pi pi-save"
+                  severity="info"
+                  :loading="modpackSaving"
+                  @click="handleSaveModpack"
+                />
+                <Button
+                  :label="t('modpack.actions.build')"
+                  icon="pi pi-box"
+                  severity="secondary"
+                  :loading="modpackBuilding"
+                  :disabled="!modpackState.modpack || modpackForm.modList.length === 0"
+                  @click="handleBuildModpack"
+                />
+                <Button
+                  v-if="modpackState.modpack?.status !== 'published'"
+                  :label="t('modpack.actions.publish')"
+                  icon="pi pi-cloud-upload"
+                  severity="success"
+                  :disabled="!modpackIsBuilt"
+                  @click="handlePublishModpack"
+                />
+                <Button
+                  v-if="modpackState.modpack?.status === 'published'"
+                  :label="t('modpack.actions.archive')"
+                  icon="pi pi-inbox"
+                  severity="warn"
+                  @click="handleArchiveModpack"
+                />
+                <Button
+                  v-if="modpackState.modpack?.status === 'archived'"
+                  :label="t('modpack.actions.unarchive')"
+                  icon="pi pi-undo"
+                  severity="secondary"
+                  @click="handleUnarchiveModpack"
+                />
+                <Button
+                  v-if="modpackState.modpack"
+                  :label="t('modpack.actions.delete')"
+                  icon="pi pi-trash"
+                  severity="danger"
+                  text
+                  @click="modpackConfirmDeleteVisible = true"
+                />
+              </div>
+            </div>
+          </div>
+        </TabPanel>
       </TabPanels>
     </Tabs>
 
+    <!-- Modpack delete confirmation -->
+    <Dialog
+      v-model:visible="modpackConfirmDeleteVisible"
+      :header="t('common.confirmDelete')"
+      modal
+      :style="{ width: '420px' }"
+    >
+      <p>{{ t('modpack.confirmDelete') }}</p>
+      <template #footer>
+        <Button :label="t('common.cancel')" severity="secondary" text @click="modpackConfirmDeleteVisible = false" />
+        <Button :label="t('common.delete')" severity="danger" @click="handleDeleteModpack" />
+      </template>
+    </Dialog>
+
     <!-- Delete confirmation -->
     <Dialog
       v-model:visible="confirmDeleteVisible"
@@ -315,6 +588,54 @@ onMounted(loadMods)
   width: 100%;
 }
 
+/* Modpack tab — admin form for the player-facing modpack zip. */
+.modpack-tab { max-width: 760px; }
+.modpack-form { display: flex; flex-direction: column; gap: 1rem; }
+.modpack-status-card {
+  background: var(--kc-surface-1, rgba(255,255,255,0.03));
+  border: 1px solid var(--kc-border, rgba(255,255,255,0.08));
+  border-radius: 8px;
+  padding: 0.9rem 1.1rem;
+  display: flex;
+  flex-direction: column;
+  gap: 0.4rem;
+}
+.modpack-status-row { display: flex; align-items: center; gap: 0.7rem; flex-wrap: wrap; }
+.modpack-status-name { font-weight: 600; font-size: 1.05rem; }
+.modpack-version { color: var(--kc-text-secondary); font-weight: 400; }
+.modpack-status-meta {
+  display: flex;
+  gap: 1.25rem;
+  color: var(--kc-text-secondary);
+  font-size: 0.85rem;
+  flex-wrap: wrap;
+}
+.modpack-public-link { font-size: 0.85rem; }
+.modpack-public-link a {
+  color: var(--kc-accent, #ff8800);
+  text-decoration: none;
+}
+.modpack-public-link a:hover { text-decoration: underline; }
+.form-grid {
+  display: grid;
+  grid-template-columns: 2fr 1fr;
+  gap: 1rem;
+}
+@media (max-width: 640px) {
+  .form-grid { grid-template-columns: 1fr; }
+}
+.form-group { display: flex; flex-direction: column; gap: 0.35rem; }
+.form-label {
+  font-size: 0.8rem;
+  color: var(--kc-text-secondary);
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+}
+.form-input { width: 100%; }
+.form-hint { color: var(--kc-text-secondary); font-size: 0.8rem; }
+.modpack-multiselect :deep(.p-multiselect-label) { white-space: normal; }
+.modpack-actions { display: flex; gap: 0.5rem; flex-wrap: wrap; margin-top: 0.5rem; }
+
 .mod-name-cell {
   display: flex;
   align-items: center;
diff --git a/src/KitsuneCommand/Config/Migrations/010_modpack.sql b/src/KitsuneCommand/Config/Migrations/010_modpack.sql
new file mode 100644
index 0000000..8443ec4
--- /dev/null
+++ b/src/KitsuneCommand/Config/Migrations/010_modpack.sql
@@ -0,0 +1,29 @@
+-- Singleton modpack table for the server's player-facing mod bundle.
+--
+-- "Latest version only" semantics (per the spec): there's ever only ONE row.
+-- Editing updates it in place; publishing replaces the previously-published
+-- zip on disk; archiving keeps the metadata but unlists from the public
+-- download CTA on the login page. Deleting drops the row + the zip together.
+--
+-- status:
+--   'draft'     — admin is preparing a new pack (not visible publicly)
+--   'published' — visible on the login-page Download CTA, public download enabled
+--   'archived'  — kept for reference but not visible / downloadable
+CREATE TABLE IF NOT EXISTS modpack (
+    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+    name            TEXT    NOT NULL,
+    version         TEXT    NOT NULL,
+    status          TEXT    NOT NULL DEFAULT 'draft',
+    -- Filename of the built zip, relative to the modpacks dir (resolved at
+    -- runtime via ModpackService.GetModpackDir). NULL until BuildZip runs.
+    filename        TEXT,
+    size_bytes      INTEGER NOT NULL DEFAULT 0,
+    mod_count       INTEGER NOT NULL DEFAULT 0,
+    -- JSON array of mod folder names included in the pack.
+    -- e.g. ["KitsunePaintUnlocked","SomeOtherMod"]
+    mod_list        TEXT    NOT NULL DEFAULT '[]',
+    description     TEXT,
+    created_at      TEXT    NOT NULL DEFAULT (datetime('now')),
+    updated_at      TEXT    NOT NULL DEFAULT (datetime('now')),
+    download_count  INTEGER NOT NULL DEFAULT 0
+);
diff --git a/src/KitsuneCommand/Core/ServiceRegistry.cs b/src/KitsuneCommand/Core/ServiceRegistry.cs
index d500204..bb4c031 100644
--- a/src/KitsuneCommand/Core/ServiceRegistry.cs
+++ b/src/KitsuneCommand/Core/ServiceRegistry.cs
@@ -35,6 +35,7 @@ public static IContainer Build(AppSettings settings)
             builder.RegisterType<ServerConfigService>().AsSelf().SingleInstance();
             builder.RegisterType<ModManagerService>().AsSelf().SingleInstance();
             builder.RegisterType<BackupService>().AsSelf().SingleInstance();
+            builder.RegisterType<ModpackService>().AsSelf().SingleInstance();
             builder.RegisterType<DiscordWebhookService>().AsSelf().SingleInstance();
             builder.RegisterType<DiscordBotService>().AsSelf().SingleInstance();
             builder.RegisterType<NexusModDiscoveryService>().AsSelf().SingleInstance();
diff --git a/src/KitsuneCommand/Data/Entities/Modpack.cs b/src/KitsuneCommand/Data/Entities/Modpack.cs
new file mode 100644
index 0000000..aca9acc
--- /dev/null
+++ b/src/KitsuneCommand/Data/Entities/Modpack.cs
@@ -0,0 +1,30 @@
+namespace KitsuneCommand.Data.Entities
+{
+    /// <summary>
+    /// The server's player-facing modpack. Singleton — at most one row exists.
+    /// The status field controls visibility on the login-page download CTA.
+    /// </summary>
+    public class Modpack
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+        public string Version { get; set; }
+
+        /// <summary>"draft" | "published" | "archived"</summary>
+        public string Status { get; set; }
+
+        /// <summary>On-disk filename inside the modpacks dir. Null until built.</summary>
+        public string Filename { get; set; }
+
+        public long SizeBytes { get; set; }
+        public int ModCount { get; set; }
+
+        /// <summary>JSON array of mod folder names included in the pack.</summary>
+        public string ModList { get; set; }
+
+        public string Description { get; set; }
+        public string CreatedAt { get; set; }
+        public string UpdatedAt { get; set; }
+        public int DownloadCount { get; set; }
+    }
+}
diff --git a/src/KitsuneCommand/Data/Repositories/ModpackRepository.cs b/src/KitsuneCommand/Data/Repositories/ModpackRepository.cs
new file mode 100644
index 0000000..beb2573
--- /dev/null
+++ b/src/KitsuneCommand/Data/Repositories/ModpackRepository.cs
@@ -0,0 +1,98 @@
+using Dapper;
+using KitsuneCommand.Data.Entities;
+
+namespace KitsuneCommand.Data.Repositories
+{
+    public interface IModpackRepository
+    {
+        /// <summary>The one and only modpack row, or null if none exists yet.</summary>
+        Modpack GetCurrent();
+
+        /// <summary>The modpack only if it's currently published, else null. Used by the public endpoint.</summary>
+        Modpack GetPublished();
+
+        /// <summary>
+        /// Insert if no row exists, otherwise update the existing row in place.
+        /// "Singleton" semantics — the table is structurally allowed to hold
+        /// many rows, but this repo enforces one-and-only-one.
+        /// </summary>
+        Modpack Upsert(Modpack record);
+
+        /// <summary>Increments download_count atomically. Cheap, doesn't return anything.</summary>
+        void IncrementDownloadCount(int id);
+
+        /// <summary>Removes the row entirely. The on-disk zip is the caller's responsibility.</summary>
+        void Delete(int id);
+    }
+
+    public class ModpackRepository : IModpackRepository
+    {
+        private readonly DbConnectionFactory _db;
+
+        public ModpackRepository(DbConnectionFactory db)
+        {
+            _db = db;
+        }
+
+        public Modpack GetCurrent()
+        {
+            using var conn = _db.CreateConnection();
+            return conn.QueryFirstOrDefault<Modpack>(
+                "SELECT * FROM modpack ORDER BY id DESC LIMIT 1");
+        }
+
+        public Modpack GetPublished()
+        {
+            using var conn = _db.CreateConnection();
+            return conn.QueryFirstOrDefault<Modpack>(
+                "SELECT * FROM modpack WHERE status = 'published' ORDER BY id DESC LIMIT 1");
+        }
+
+        public Modpack Upsert(Modpack record)
+        {
+            using var conn = _db.CreateConnection();
+            if (record.Id == 0)
+            {
+                // Fresh row. updated_at gets the same value as created_at so
+                // sort-by-mtime queries don't surface a "stale" pack the moment
+                // it's created.
+                var newId = conn.ExecuteScalar<long>(@"
+                    INSERT INTO modpack
+                        (name, version, status, filename, size_bytes, mod_count, mod_list, description, updated_at)
+                    VALUES
+                        (@Name, @Version, @Status, @Filename, @SizeBytes, @ModCount, @ModList, @Description, datetime('now'));
+                    SELECT last_insert_rowid();", record);
+                record.Id = (int)newId;
+            }
+            else
+            {
+                conn.Execute(@"
+                    UPDATE modpack
+                       SET name = @Name,
+                           version = @Version,
+                           status = @Status,
+                           filename = @Filename,
+                           size_bytes = @SizeBytes,
+                           mod_count = @ModCount,
+                           mod_list = @ModList,
+                           description = @Description,
+                           updated_at = datetime('now')
+                     WHERE id = @Id", record);
+            }
+            return record;
+        }
+
+        public void IncrementDownloadCount(int id)
+        {
+            using var conn = _db.CreateConnection();
+            conn.Execute("UPDATE modpack SET download_count = download_count + 1 WHERE id = @Id",
+                new { Id = id });
+        }
+
+        public void Delete(int id)
+        {
+            using var conn = _db.CreateConnection();
+            conn.Execute("DELETE FROM modpack WHERE id = @Id", new { Id = id });
+        }
+    }
+}
diff --git a/src/KitsuneCommand/Services/ModpackService.cs b/src/KitsuneCommand/Services/ModpackService.cs
new file mode 100644
index 0000000..c446ee0
--- /dev/null
+++ b/src/KitsuneCommand/Services/ModpackService.cs
@@ -0,0 +1,257 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Compression;
+using System.Linq;
+using System.Text.RegularExpressions;
+using KitsuneCommand.Data.Entities;
+using KitsuneCommand.Data.Repositories;
+using Newtonsoft.Json;
+
+namespace KitsuneCommand.Services
+{
+    /// <summary>
+    /// Single source of truth for the server's player-facing modpack: which
+    /// installed mods are bundled, the published name + version, and the
+    /// on-disk zip used by the public download endpoint.
+    ///
+    /// Storage layout:
+    ///   &lt;game-root&gt;/KitsuneModpacks/      ← zip output
+    ///   &lt;game-root&gt;/Mods/&lt;modName&gt;/      ← source per bundled mod
+    ///
+    /// "Latest version only" semantics: at most one row in the modpack table.
+    /// Edits update in place. Publishing a new version overwrites the previous
+    /// zip on disk.
+    /// </summary>
+    public class ModpackService
+    {
+        private readonly IModpackRepository _repo;
+        private readonly ModManagerService _modManager;
+
+        public ModpackService(IModpackRepository repo, ModManagerService modManager)
+        {
+            _repo = repo;
+            _modManager = modManager;
+        }
+
+        /// <summary>Path to the directory that holds built modpack zips.</summary>
+        public string GetModpackDir()
+        {
+            // Game root is the parent of Mods/. ModManagerService.GetModsPath
+            // already does the rooted-path resolution dance — reuse it.
+            var modsPath = _modManager.GetModsPath();
+            var gameRoot = Path.GetDirectoryName(modsPath);
+            var dir = Path.Combine(gameRoot ?? Directory.GetCurrentDirectory(), "KitsuneModpacks");
+            if (!Directory.Exists(dir))
+                Directory.CreateDirectory(dir);
+            return dir;
+        }
+
+        /// <summary>Current modpack record (any status), or null if none configured.</summary>
+        public Modpack Get() => _repo.GetCurrent();
+
+        /// <summary>
+        /// Save or update the draft. If a record already exists, this updates
+        /// it in place and flips its status back to 'draft' so the published
+        /// zip on disk doesn't drift out of sync with the (now-changed)
+        /// configuration. Caller should run BuildZip + Publish to re-publish.
+        /// </summary>
+        public Modpack SaveDraft(string name, string version, List<string> modList, string description)
+        {
+            if (string.IsNullOrWhiteSpace(name))
+                throw new ArgumentException("Modpack name is required.", nameof(name));
+            if (string.IsNullOrWhiteSpace(version))
+                throw new ArgumentException("Modpack version is required.", nameof(version));
+            if (modList == null) modList = new List<string>();
+
+            // Validate every requested mod actually exists in the Mods/ dir.
+            // Better to fail loudly here than silently produce an empty zip
+            // entry at build time.
+            var installed = _modManager.GetMods().Select(m => m.FolderName).ToHashSet(StringComparer.OrdinalIgnoreCase);
+            var missing = modList.Where(m => !installed.Contains(m)).ToList();
+            if (missing.Count > 0)
+            {
+                throw new InvalidOperationException(
+                    $"Cannot include mods not installed on the server: {string.Join(", ", missing)}.");
+            }
+
+            var existing = _repo.GetCurrent();
+            var record = existing ?? new Modpack { CreatedAt = DateTime.UtcNow.ToString("o") };
+            record.Name = name.Trim();
+            record.Version = version.Trim();
+            record.ModList = JsonConvert.SerializeObject(modList);
+            record.ModCount = modList.Count;
+            record.Description = description;
+
+            // Editing config invalidates the previously-built zip. Force a
+            // re-build before re-publish. We don't delete the old zip here
+            // (BuildZip handles overwrite-on-build), so an existing public
+            // download keeps working until the admin explicitly rebuilds.
+            // Status flips to 'draft' if we're touching previously-published
+            // settings; archived stays archived.
+            if (record.Status != "archived")
+                record.Status = "draft";
+
+            return _repo.Upsert(record);
+        }
+
+        /// <summary>
+        /// Build the on-disk zip from the current mod selection. Overwrites
+        /// any previous zip for this modpack record. Updates the record's
+        /// filename + size_bytes on success.
+        /// </summary>
+        public Modpack BuildZip()
+        {
+            var record = _repo.GetCurrent()
+                ?? throw new InvalidOperationException("No modpack configured yet. Save a draft first.");
+
+            var modNames = JsonConvert.DeserializeObject<List<string>>(record.ModList) ?? new List<string>();
+            if (modNames.Count == 0)
+                throw new InvalidOperationException("Modpack has no mods selected. Pick at least one before building.");
+
+            var modsRoot = _modManager.GetModsPath();
+            var outputDir = GetModpackDir();
+            var safeName = SanitizeForFilename($"{record.Name}-{record.Version}");
+            var filename = $"{safeName}.zip";
+            var outputPath = Path.Combine(outputDir, filename);
+
+            // If the previously-built zip used a different filename (admin
+            // changed name or version), clean it up so we don't accumulate
+            // orphan files in the modpacks dir.
+            if (!string.IsNullOrEmpty(record.Filename) && record.Filename != filename)
+            {
+                var oldPath = Path.Combine(outputDir, record.Filename);
+                try { if (File.Exists(oldPath)) File.Delete(oldPath); } catch { /* best-effort */ }
+            }
+
+            // Build into a temp file first, then move into place. Avoids a
+            // partial-write window where a public downloader could grab a
+            // corrupt half-zip.
+            var tempPath = outputPath + ".building";
+            try { if (File.Exists(tempPath)) File.Delete(tempPath); } catch { /* fall through */ }
+
+            using (var zip = ZipFile.Open(tempPath, ZipArchiveMode.Create))
+            {
+                foreach (var modName in modNames)
+                {
+                    var modDir = Path.Combine(modsRoot, modName);
+                    if (!Directory.Exists(modDir))
+                    {
+                        // Caller previously validated against installed mods,
+                        // but a mod could have been removed between draft-save
+                        // and build. Skip silently with no entry rather than
+                        // poisoning the zip.
+                        continue;
+                    }
+                    AddDirectoryToZip(zip, modDir, modName);
+                }
+            }
+
+            if (File.Exists(outputPath))
+            {
+                try { File.Delete(outputPath); } catch { /* best-effort */ }
+            }
+            File.Move(tempPath, outputPath);
+
+            var fi = new FileInfo(outputPath);
+            record.Filename = filename;
+            record.SizeBytes = fi.Length;
+            return _repo.Upsert(record);
+        }
+
+        /// <summary>Flips status to 'published'. Caller should have run BuildZip first.</summary>
+        public Modpack Publish()
+        {
+            var record = _repo.GetCurrent()
+                ?? throw new InvalidOperationException("No modpack to publish.");
+            if (string.IsNullOrEmpty(record.Filename))
+                throw new InvalidOperationException("Modpack zip hasn't been built yet. Build first, then publish.");
+            record.Status = "published";
+            return _repo.Upsert(record);
+        }
+
+        /// <summary>
+        /// Flips status to 'archived'. Public download stops; the zip stays on
+        /// disk in case admin wants to re-publish or download a copy.
+        /// </summary>
+        public Modpack Archive()
+        {
+            var record = _repo.GetCurrent()
+                ?? throw new InvalidOperationException("No modpack to archive.");
+            record.Status = "archived";
+            return _repo.Upsert(record);
+        }
+
+        /// <summary>
+        /// Flips status to 'draft'. Useful for reviving an archived pack
+        /// without losing its history of edits.
+        /// </summary>
+        public Modpack Unarchive()
+        {
+            var record = _repo.GetCurrent()
+                ?? throw new InvalidOperationException("No modpack to unarchive.");
+            record.Status = "draft";
+            return _repo.Upsert(record);
+        }
+
+        /// <summary>Wipe everything: the DB row and the zip file.</summary>
+        public void Delete()
+        {
+            var record = _repo.GetCurrent();
+            if (record == null) return;
+
+            if (!string.IsNullOrEmpty(record.Filename))
+            {
+                var path = Path.Combine(GetModpackDir(), record.Filename);
+                try { if (File.Exists(path)) File.Delete(path); } catch { /* best-effort */ }
+            }
+            _repo.Delete(record.Id);
+        }
+
+        /// <summary>
+        /// Opens the published zip for streaming. Returns null if no pack is
+        /// published or the file is missing. Caller is responsible for
+        /// disposing the stream and bumping the download counter.
+        /// </summary>
+        public (Modpack Record, FileStream Stream) OpenPublishedForDownload()
+        {
+            var record = _repo.GetPublished();
+            if (record == null || string.IsNullOrEmpty(record.Filename))
+                return (null, null);
+
+            var path = Path.Combine(GetModpackDir(), record.Filename);
+            if (!File.Exists(path))
+                return (record, null);
+
+            var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
+            return (record, stream);
+        }
+
+        public void IncrementDownloadCount(int id) => _repo.IncrementDownloadCount(id);
+
+        // ─── helpers ──────────────────────────────────────────────────────
+
+        private static void AddDirectoryToZip(ZipArchive zip, string sourceDir, string entryRoot)
+        {
+            foreach (var file in Directory.GetFiles(sourceDir, "*", SearchOption.AllDirectories))
+            {
+                var rel = file.Substring(sourceDir.Length).TrimStart(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
+                // ZIP entries use forward slashes per the spec — even when
+                // built on Windows. Picky archivers (and 7-Zip on Linux) will
+                // misrender Windows-style backslashes as part of the filename.
+                var entryName = entryRoot + "/" + rel.Replace(Path.DirectorySeparatorChar, '/').Replace(Path.AltDirectorySeparatorChar, '/');
+                zip.CreateEntryFromFile(file, entryName, CompressionLevel.Optimal);
+            }
+        }
+
+        private static readonly Regex UnsafeFilenameChars =
+            new Regex(@"[^A-Za-z0-9._\-]+", RegexOptions.Compiled);
+
+        private static string SanitizeForFilename(string s)
+        {
+            if (string.IsNullOrWhiteSpace(s)) return "modpack";
+            var clean = UnsafeFilenameChars.Replace(s, "_").Trim('_', '.');
+            return string.IsNullOrEmpty(clean) ? "modpack" : clean;
+        }
+    }
+}
diff --git a/src/KitsuneCommand/Web/Controllers/ModpackController.cs b/src/KitsuneCommand/Web/Controllers/ModpackController.cs
new file mode 100644
index 0000000..2f7fdf7
--- /dev/null
+++ b/src/KitsuneCommand/Web/Controllers/ModpackController.cs
@@ -0,0 +1,228 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Web.Http;
+using KitsuneCommand.Services;
+using KitsuneCommand.Web.Auth;
+using KitsuneCommand.Web.Models;
+using Newtonsoft.Json;
+
+namespace KitsuneCommand.Web.Controllers
+{
+    /// <summary>
+    /// REST surface for the player-facing modpack.
+    ///
+    /// Admin endpoints (require admin role): browse + edit + publish workflow.
+    /// Two endpoints are intentionally <c>[AllowAnonymous]</c> — those are
+    /// what the login page (no-auth) calls to surface the download CTA.
+    /// </summary>
+    [Authorize]
+    [RoutePrefix("api/modpack")]
+    public class ModpackController : ApiController
+    {
+        private readonly ModpackService _service;
+        private readonly ModManagerService _modManager;
+
+        public ModpackController(ModpackService service, ModManagerService modManager)
+        {
+            _service = service;
+            _modManager = modManager;
+        }
+
+        // ─── Admin: state + edit ──────────────────────────────────────────
+
+        /// <summary>
+        /// Full state for the admin UI: the current modpack record (if any)
+        /// plus the list of installed mods (the picker's source data).
+        /// </summary>
+        [HttpGet]
+        [Route("")]
+        [RoleAuthorize("admin")]
+        public IHttpActionResult Get()
+        {
+            var record = _service.Get();
+            var installedMods = _modManager.GetMods()
+                .Select(m => new { name = m.FolderName, displayName = m.DisplayName, version = m.Version })
+                .OrderBy(m => m.name, StringComparer.OrdinalIgnoreCase)
+                .ToList();
+
+            // Parse modList JSON eagerly so the frontend doesn't need to do it.
+            List<string> modList = null;
+            if (record != null && !string.IsNullOrEmpty(record.ModList))
+            {
+                try { modList = JsonConvert.DeserializeObject<List<string>>(record.ModList); }
+                catch { modList = new List<string>(); }
+            }
+
+            return Ok(ApiResponse.Ok(new
+            {
+                modpack = record,
+                modList = modList ?? new List<string>(),
+                installedMods,
+            }));
+        }
+
+        public class SaveDraftRequest
+        {
+            public string Name { get; set; }
+            public string Version { get; set; }
+            public List<string> ModList { get; set; }
+            public string Description { get; set; }
+        }
+
+        [HttpPut]
+        [Route("")]
+        [RoleAuthorize("admin")]
+        public IHttpActionResult Save([FromBody] SaveDraftRequest body)
+        {
+            if (body == null) return BadRequest("Request body is required.");
+            try
+            {
+                var record = _service.SaveDraft(body.Name, body.Version, body.ModList, body.Description);
+                return Ok(ApiResponse.Ok(record));
+            }
+            catch (ArgumentException ex) { return Ok(ApiResponse.Error(400, ex.Message)); }
+            catch (InvalidOperationException ex) { return Ok(ApiResponse.Error(400, ex.Message)); }
+            catch (Exception ex) { return Ok(ApiResponse.Error(500, $"Failed to save modpack: {ex.Message}")); }
+        }
+
+        [HttpPost]
+        [Route("build")]
+        [RoleAuthorize("admin")]
+        public IHttpActionResult Build()
+        {
+            try
+            {
+                var record = _service.BuildZip();
+                return Ok(ApiResponse.Ok(record));
+            }
+            catch (InvalidOperationException ex) { return Ok(ApiResponse.Error(400, ex.Message)); }
+            catch (Exception ex) { return Ok(ApiResponse.Error(500, $"Failed to build modpack: {ex.Message}")); }
+        }
+
+        [HttpPost]
+        [Route("publish")]
+        [RoleAuthorize("admin")]
+        public IHttpActionResult Publish()
+        {
+            try
+            {
+                var record = _service.Publish();
+                return Ok(ApiResponse.Ok(record));
+            }
+            catch (InvalidOperationException ex) { return Ok(ApiResponse.Error(400, ex.Message)); }
+            catch (Exception ex) { return Ok(ApiResponse.Error(500, $"Failed to publish modpack: {ex.Message}")); }
+        }
+
+        [HttpPost]
+        [Route("archive")]
+        [RoleAuthorize("admin")]
+        public IHttpActionResult Archive()
+        {
+            try
+            {
+                var record = _service.Archive();
+                return Ok(ApiResponse.Ok(record));
+            }
+            catch (InvalidOperationException ex) { return Ok(ApiResponse.Error(400, ex.Message)); }
+            catch (Exception ex) { return Ok(ApiResponse.Error(500, $"Failed to archive modpack: {ex.Message}")); }
+        }
+
+        [HttpPost]
+        [Route("unarchive")]
+        [RoleAuthorize("admin")]
+        public IHttpActionResult Unarchive()
+        {
+            try
+            {
+                var record = _service.Unarchive();
+                return Ok(ApiResponse.Ok(record));
+            }
+            catch (InvalidOperationException ex) { return Ok(ApiResponse.Error(400, ex.Message)); }
+            catch (Exception ex) { return Ok(ApiResponse.Error(500, $"Failed to unarchive modpack: {ex.Message}")); }
+        }
+
+        [HttpDelete]
+        [Route("")]
+        [RoleAuthorize("admin")]
+        public IHttpActionResult Delete()
+        {
+            try
+            {
+                _service.Delete();
+                return Ok(ApiResponse.Ok("Modpack deleted."));
+            }
+            catch (Exception ex) { return Ok(ApiResponse.Error(500, $"Failed to delete modpack: {ex.Message}")); }
+        }
+
+        // ─── Public: anonymous metadata + download ────────────────────────
+
+        /// <summary>
+        /// Metadata for the published modpack, or a 404-shaped envelope if
+        /// none is published. Login page calls this to render the CTA.
+        /// No auth — anyone hitting the panel sees it.
+        /// </summary>
+        [HttpGet]
+        [Route("public")]
+        [AllowAnonymous]
+        public IHttpActionResult GetPublic()
+        {
+            var record = _service.Get();
+            if (record == null || record.Status != "published")
+            {
+                return Ok(ApiResponse.Error(404, "No modpack is currently published."));
+            }
+            return Ok(ApiResponse.Ok(new
+            {
+                name = record.Name,
+                version = record.Version,
+                sizeBytes = record.SizeBytes,
+                modCount = record.ModCount,
+                description = record.Description,
+            }));
+        }
+
+        /// <summary>
+        /// Streams the published modpack zip. Increments the download counter
+        /// before serving so a successful HTTP 200 implies the counter moved.
+        /// No auth — anyone with the link gets the file.
+        /// </summary>
+        [HttpGet]
+        [Route("public/download")]
+        [AllowAnonymous]
+        public HttpResponseMessage Download()
+        {
+            var (record, stream) = _service.OpenPublishedForDownload();
+            if (record == null)
+            {
+                return new HttpResponseMessage(HttpStatusCode.NotFound)
+                {
+                    Content = new StringContent("No modpack is currently published.")
+                };
+            }
+            if (stream == null)
+            {
+                return new HttpResponseMessage(HttpStatusCode.NotFound)
+                {
+                    Content = new StringContent("Modpack metadata exists but the file is missing on disk. Rebuild from the admin panel.")
+                };
+            }
+
+            _service.IncrementDownloadCount(record.Id);
+
+            var response = new HttpResponseMessage(HttpStatusCode.OK)
+            {
+                Content = new StreamContent(stream),
+            };
+            response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/zip");
+            response.Content.Headers.ContentDisposition =
+                new ContentDispositionHeaderValue("attachment") { FileName = record.Filename };
+            response.Content.Headers.ContentLength = stream.Length;
+            return response;
+        }
+    }
+}