diff --git a/src/components/menus/user/UserLeftMenu.vue b/src/components/menus/user/UserLeftMenu.vue
index e9e6dd51..f85ca91d 100644
--- a/src/components/menus/user/UserLeftMenu.vue
+++ b/src/components/menus/user/UserLeftMenu.vue
@@ -1,6 +1,7 @@
 <script setup>
 import MenuDefault from "@/components/menus/MenuDefault.vue";
 import LanguageSelector from "@/components/i18n/LanguageSelector.vue";
+import ReleaseChannelSidebarSelector from "@/components/release/ReleaseChannelSidebarSelector.vue";
 import {ref, computed} from "vue";
 import {SessionUser} from "@/components/session/token/SessionUser.vue";
 import { useI18n } from 'vue-i18n';
@@ -70,9 +71,10 @@ const menu_items = computed(() => [
         :show_icons="false"
     />
     <LanguageSelector />
+    <ReleaseChannelSidebarSelector />
   </div>
 </template>
 
 <style scoped>
 
-</style>
\ No newline at end of file
+</style>
diff --git a/src/components/release/ReleaseAssignmentSubjectAutocomplete.vue b/src/components/release/ReleaseAssignmentSubjectAutocomplete.vue
new file mode 100644
index 00000000..3ed3bca0
--- /dev/null
+++ b/src/components/release/ReleaseAssignmentSubjectAutocomplete.vue
@@ -0,0 +1,404 @@
+<script setup>
+import { computed, nextTick, onBeforeUnmount, onMounted, ref, watch } from "vue";
+import { BAutocomplete } from "buefy";
+import { useI18n } from "vue-i18n";
+import { searchReleaseAssignmentSubjects } from "@/services/superuserReleases.js";
+
+const props = defineProps({
+  modelValue: {
+    type: Object,
+    default: null,
+  },
+  limit: {
+    type: Number,
+    default: 5,
+  },
+  debounceMs: {
+    type: Number,
+    default: 250,
+  },
+});
+
+const emit = defineEmits(["update:modelValue", "select", "clear"]);
+
+const { t } = useI18n({ useScope: "global" });
+const tr = (key, params = {}) => t(`configuration.release_manager.assignments.${key}`, params);
+const valueLabel = (type) => {
+  const key = `configuration.release_manager.values.subject_type.${type}`;
+  const translated = t(key);
+  return translated === key ? type : translated;
+};
+
+const SUBJECT_TYPES = ["user", "subuser", "customer"];
+const autocompleteRef = ref(null);
+const typedSubject = ref("");
+const remoteOptions = ref([]);
+const selectedOption = ref(null);
+const isFetching = ref(false);
+
+let debounceTimer = null;
+let requestSequence = 0;
+
+const subjectIcon = (type) => {
+  if (type === "customer") {
+    return "fas fa-building";
+  }
+  if (type === "subuser") {
+    return "fas fa-id-badge";
+  }
+  return "fas fa-user";
+};
+
+const normalizeOption = (option) => {
+  if (!option || typeof option !== "object") {
+    return null;
+  }
+
+  const subjectType = String(option.subject_type || "").trim().toLowerCase();
+  const subjectId = String(option.subject_id || "").trim();
+  if (!SUBJECT_TYPES.includes(subjectType) || !subjectId) {
+    return null;
+  }
+
+  const title = String(option.title || `${valueLabel(subjectType)} #${subjectId}`).trim();
+  const description = String(option.description || "").trim();
+  return {
+    subject_type: subjectType,
+    subject_id: subjectId,
+    label: String(option.label || (description ? `${title} - ${description}` : title)).trim(),
+    title,
+    description,
+    icon: String(option.icon || subjectIcon(subjectType)).trim(),
+    source: String(option.source || subjectType).trim(),
+    group: option.group || subjectType,
+    manual: Boolean(option.manual),
+  };
+};
+
+const manualTitle = (type, id) => {
+  if (type === "customer") {
+    return tr("manual_customer", { id });
+  }
+  if (type === "subuser") {
+    return tr("manual_subuser", { id });
+  }
+  return tr("manual_user", { id });
+};
+
+const manualOptions = computed(() => {
+  const query = typedSubject.value.trim();
+  if (!query) {
+    return [];
+  }
+
+  const explicit = query.match(/^(user|subuser|customer):([a-zA-Z0-9_.:-]{1,64})$/i);
+  const subjects = explicit
+    ? [{ type: explicit[1].toLowerCase(), id: explicit[2] }]
+    : /^\d{1,64}$/.test(query)
+      ? SUBJECT_TYPES.map((type) => ({ type, id: query }))
+      : [];
+
+  return subjects
+    .map(({ type, id }) =>
+      normalizeOption({
+        subject_type: type,
+        subject_id: id,
+        title: manualTitle(type, id),
+        description: tr("manual_description", { subject: `${type}:${id}` }),
+        icon: subjectIcon(type),
+        source: "manual",
+        group: "manual",
+        manual: true,
+      })
+    )
+    .filter(Boolean);
+});
+
+const groupLabel = (group) => {
+  if (group === "manual") {
+    return tr("group_manual");
+  }
+  if (group === "customer") {
+    return tr("group_customers");
+  }
+  if (group === "subuser") {
+    return tr("group_subusers");
+  }
+  return tr("group_users");
+};
+
+const groupedOptions = computed(() => {
+  const seen = new Set();
+  const grouped = new Map();
+  const order = ["user", "subuser", "customer", "manual"];
+
+  [...remoteOptions.value, ...manualOptions.value].forEach((option) => {
+    const normalized = normalizeOption(option);
+    if (!normalized) {
+      return;
+    }
+
+    const key = `${normalized.subject_type}:${normalized.subject_id}`;
+    if (seen.has(key)) {
+      return;
+    }
+    seen.add(key);
+
+    const group = normalized.group || normalized.subject_type;
+    if (!grouped.has(group)) {
+      grouped.set(group, []);
+    }
+    grouped.get(group).push(normalized);
+  });
+
+  return order
+    .filter((group) => grouped.has(group))
+    .map((group) => ({
+      group: groupLabel(group),
+      key: group,
+      items: grouped.get(group),
+    }));
+});
+
+const syncInputAttributes = async () => {
+  await nextTick();
+  const input = autocompleteRef.value?.$el?.querySelector?.("input");
+  if (!input) {
+    return;
+  }
+
+  input.setAttribute("data-testid", "release-assignment-subject-search");
+  input.setAttribute("autocomplete", "off");
+  input.setAttribute("aria-label", tr("subject"));
+};
+
+const fetchOptions = async (query) => {
+  const search = String(query || "").trim();
+  if (!search) {
+    remoteOptions.value = [];
+    isFetching.value = false;
+    return;
+  }
+
+  const currentRequest = ++requestSequence;
+  isFetching.value = true;
+  try {
+    const response = await searchReleaseAssignmentSubjects({ search, limit: props.limit });
+    if (currentRequest !== requestSequence) {
+      return;
+    }
+    const options = Array.isArray(response?.data?.data) ? response.data.data : [];
+    remoteOptions.value = options.map(normalizeOption).filter(Boolean);
+  } catch {
+    if (currentRequest === requestSequence) {
+      remoteOptions.value = [];
+    }
+  } finally {
+    if (currentRequest === requestSequence) {
+      isFetching.value = false;
+    }
+  }
+};
+
+const scheduleFetch = (query) => {
+  if (debounceTimer) {
+    clearTimeout(debounceTimer);
+    debounceTimer = null;
+  }
+
+  if (props.debounceMs <= 0) {
+    void fetchOptions(query);
+    return;
+  }
+
+  debounceTimer = window.setTimeout(() => {
+    debounceTimer = null;
+    void fetchOptions(query);
+  }, props.debounceMs);
+};
+
+const handleTyping = (value) => {
+  typedSubject.value = String(value || "");
+  if (selectedOption.value && typedSubject.value !== selectedOption.value.label) {
+    selectedOption.value = null;
+    emit("clear");
+  }
+  scheduleFetch(typedSubject.value);
+  void syncInputAttributes();
+};
+
+const handleSelect = (option) => {
+  const normalized = normalizeOption(option);
+  if (!normalized) {
+    return;
+  }
+
+  selectedOption.value = normalized;
+  typedSubject.value = normalized.label;
+  emit("update:modelValue", normalized);
+  emit("select", normalized);
+  void syncInputAttributes();
+};
+
+watch(
+  () => props.modelValue,
+  (nextValue) => {
+    const normalized = normalizeOption(nextValue);
+    selectedOption.value = normalized;
+    typedSubject.value = normalized?.label || "";
+    void syncInputAttributes();
+  },
+  { immediate: true }
+);
+
+onMounted(() => {
+  void syncInputAttributes();
+});
+
+onBeforeUnmount(() => {
+  if (debounceTimer) {
+    clearTimeout(debounceTimer);
+  }
+  requestSequence++;
+});
+</script>
+
+<template>
+  <div class="release-assignment-subject" data-testid="release-assignment-subject-autocomplete">
+    <BAutocomplete
+      ref="autocompleteRef"
+      v-model="typedSubject"
+      :data="groupedOptions"
+      field="label"
+      group-field="group"
+      group-options="items"
+      :placeholder="tr('subject_placeholder')"
+      icon="search"
+      icon-pack="fas"
+      :loading="isFetching"
+      open-on-focus
+      expanded
+      keep-first
+      max-height="320"
+      @typing="handleTyping"
+      @select="handleSelect"
+      @focus="syncInputAttributes"
+    >
+      <template #group="{ group, index }">
+        <span
+          class="release-assignment-subject__group"
+          :data-testid="`release-assignment-subject-group-${groupedOptions[index]?.key || 'other'}`"
+        >
+          {{ group }}
+        </span>
+      </template>
+      <template #default="slotProps">
+        <div
+          class="release-assignment-subject__option"
+          :data-testid="
+            slotProps.option.manual
+              ? `release-assignment-subject-manual-${slotProps.option.subject_type}-${slotProps.option.subject_id}`
+              : `release-assignment-subject-option-${slotProps.option.subject_type}-${slotProps.option.subject_id}`
+          "
+        >
+          <span class="release-assignment-subject__icon">
+            <i :class="slotProps.option.icon" aria-hidden="true"></i>
+          </span>
+          <span class="release-assignment-subject__body">
+            <strong>{{ slotProps.option.title }}</strong>
+            <small>{{ slotProps.option.description }}</small>
+          </span>
+          <b-tag size="is-small">{{ valueLabel(slotProps.option.subject_type) }}</b-tag>
+        </div>
+      </template>
+      <template #empty>
+        <span class="release-assignment-subject__empty">{{ tr("subject_empty") }}</span>
+      </template>
+    </BAutocomplete>
+  </div>
+</template>
+
+<style scoped>
+.release-assignment-subject {
+  min-width: 0;
+  width: 100%;
+}
+
+.release-assignment-subject :deep(.autocomplete),
+.release-assignment-subject :deep(.control) {
+  width: 100%;
+}
+
+.release-assignment-subject :deep(.dropdown-content) {
+  border-radius: 6px;
+  box-shadow: 0 12px 28px rgba(31, 45, 61, 0.16);
+  max-width: min(760px, calc(100vw - 32px));
+}
+
+.release-assignment-subject :deep(.dropdown-item) {
+  padding: 0;
+  white-space: normal;
+}
+
+.release-assignment-subject__group {
+  background: #f7f9fc;
+  color: #5f6b7c;
+  display: block;
+  font-size: 0.72rem;
+  font-weight: 800;
+  letter-spacing: 0;
+  line-height: 1.2;
+  padding: 8px 12px 5px;
+  text-transform: uppercase;
+}
+
+.release-assignment-subject__option {
+  align-items: center;
+  display: grid;
+  gap: 10px;
+  grid-template-columns: 34px minmax(0, 1fr) auto;
+  padding: 10px 12px;
+  width: 100%;
+}
+
+.release-assignment-subject__icon {
+  align-items: center;
+  background: #eef3fb;
+  border-radius: 50%;
+  color: #243957;
+  display: inline-flex;
+  height: 30px;
+  justify-content: center;
+  width: 30px;
+}
+
+.release-assignment-subject__body {
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+  min-width: 0;
+}
+
+.release-assignment-subject__body strong,
+.release-assignment-subject__body small {
+  display: block;
+  overflow-wrap: anywhere;
+}
+
+.release-assignment-subject__body strong {
+  color: #253047;
+  line-height: 1.25;
+}
+
+.release-assignment-subject__body small,
+.release-assignment-subject__empty {
+  color: #758195;
+  font-size: 0.78rem;
+  line-height: 1.25;
+}
+
+.release-assignment-subject__empty {
+  display: block;
+  padding: 10px 12px;
+}
+</style>
diff --git a/src/components/release/ReleaseChannelSelector.vue b/src/components/release/ReleaseChannelSelector.vue
new file mode 100644
index 00000000..6a1a8ca3
--- /dev/null
+++ b/src/components/release/ReleaseChannelSelector.vue
@@ -0,0 +1,305 @@
+<script setup>
+import { computed } from "vue";
+import { useI18n } from "vue-i18n";
+import {
+  releaseChannelKey,
+  releaseChannelOptions,
+  selectedReleaseChannelSlug,
+} from "@/services/releaseChannelAvailability.js";
+import { releaseRuntimeState } from "@/services/releaseTimeline.js";
+
+const props = defineProps({
+  variant: {
+    type: String,
+    default: "panel",
+  },
+  switchingSlug: {
+    type: String,
+    default: "",
+  },
+  disabled: {
+    type: Boolean,
+    default: false,
+  },
+});
+
+const emit = defineEmits(["select"]);
+
+const { t, te } = useI18n({ useScope: "global" });
+const tr = (key, fallback, params = {}) => {
+  const path = `configuration.release_manager.channel_selector.${key}`;
+  return te(path) ? t(path, params) : fallback;
+};
+
+const activeSlug = computed(() => selectedReleaseChannelSlug.value || releaseChannelKey(releaseRuntimeState.channel));
+const isSidebar = computed(() => props.variant === "sidebar");
+const selectorTitle = computed(() =>
+  isSidebar.value ? tr("sidebar_title", "Release") : tr("title", "Release channel")
+);
+const selectorSubtitle = computed(() =>
+  isSidebar.value ? "" : tr("subtitle", "Choose which assigned release channel this device should use.")
+);
+
+const optionStateLabel = (option) => {
+  if (option.defaultChannel) {
+    return tr("default", "Default");
+  }
+  return option.configured ? tr("ready", "Ready") : tr("unavailable", "Not ready");
+};
+
+const missingLabel = (key) => {
+  if (key === "release_bundle") return tr("release_bundle", "Release bundle");
+  if (key === "frontend_version") return tr("frontend_version", "Frontend version");
+  if (key === "api_version") return tr("api_version", "API version");
+  return key;
+};
+
+const optionTestId = (option) => `release-channel-option-${option.channelSlug || "unknown"}`;
+
+const selectOption = (option) => {
+  if (props.disabled || props.switchingSlug || option.channelSlug === activeSlug.value) {
+    return;
+  }
+  emit("select", option);
+};
+</script>
+
+<template>
+  <section
+    class="release-channel-selector"
+    :class="[`release-channel-selector--${variant}`]"
+    data-testid="release-channel-selector"
+  >
+    <div class="release-channel-selector__header">
+      <p>{{ selectorTitle }}</p>
+      <span v-if="selectorSubtitle">{{ selectorSubtitle }}</span>
+    </div>
+
+    <div class="release-channel-selector__options">
+      <button
+        v-for="option in releaseChannelOptions"
+        :key="option.channelSlug"
+        type="button"
+        class="release-channel-option"
+        :class="{
+          'release-channel-option--active': option.channelSlug === activeSlug,
+          'release-channel-option--unavailable': !option.configured,
+        }"
+        :aria-pressed="option.channelSlug === activeSlug"
+        :disabled="disabled || Boolean(switchingSlug)"
+        :data-testid="optionTestId(option)"
+        @click="selectOption(option)"
+      >
+        <span class="release-channel-option__main">
+          <span class="release-channel-option__icon" aria-hidden="true">
+            <i class="fas" :class="option.defaultChannel ? 'fa-shield-alt' : 'fa-code-branch'"></i>
+          </span>
+          <span class="release-channel-option__copy">
+            <strong>{{ option.channelName }}</strong>
+            <small>{{ optionStateLabel(option) }}</small>
+          </span>
+        </span>
+
+        <span class="release-channel-option__meta">
+          <span v-if="switchingSlug === option.channelSlug" class="release-channel-option__spinner" aria-hidden="true">
+            <i class="fas fa-circle-notch fa-spin"></i>
+          </span>
+          <span v-else-if="option.channelSlug === activeSlug" class="release-channel-option__check" aria-hidden="true">
+            <i class="fas fa-check"></i>
+          </span>
+          <span v-else class="release-channel-option__arrow" aria-hidden="true">
+            <i class="fas fa-chevron-right"></i>
+          </span>
+        </span>
+
+        <span
+          v-if="!isSidebar && !option.configured && option.missing.length"
+          class="release-channel-option__missing"
+        >
+          <span v-for="item in option.missing" :key="item">{{ missingLabel(item) }}</span>
+        </span>
+      </button>
+    </div>
+  </section>
+</template>
+
+<style scoped>
+.release-channel-selector {
+  width: 100%;
+}
+
+.release-channel-selector--panel {
+  margin-top: 24px;
+  padding: 18px;
+  border: 1px solid #d9e4f2;
+  background: rgba(255, 255, 255, 0.72);
+}
+
+.release-channel-selector--sidebar {
+  padding: 0 16px 14px;
+}
+
+.release-channel-selector__header {
+  margin-bottom: 10px;
+}
+
+.release-channel-selector__header p {
+  margin: 0;
+  color: #10243f;
+  font-size: 0.78rem;
+  font-weight: 800;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+}
+
+.release-channel-selector__header span {
+  display: block;
+  margin-top: 3px;
+  color: #64748b;
+  font-size: 0.88rem;
+  line-height: 1.35;
+}
+
+.release-channel-selector--sidebar .release-channel-selector__header {
+  margin-bottom: 8px;
+}
+
+.release-channel-selector__options {
+  display: grid;
+  gap: 8px;
+}
+
+.release-channel-option {
+  width: 100%;
+  min-width: 0;
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  align-items: center;
+  gap: 10px;
+  padding: 12px;
+  border: 1px solid #d7e2ef;
+  border-radius: 6px;
+  background: #ffffff;
+  color: #1f2937;
+  cursor: pointer;
+  text-align: left;
+  transition:
+    border-color 0.18s ease,
+    box-shadow 0.18s ease,
+    transform 0.18s ease;
+}
+
+.release-channel-option:hover:not(:disabled) {
+  border-color: #8fb1d6;
+  box-shadow: 0 10px 22px rgba(15, 23, 42, 0.1);
+  transform: translateY(-1px);
+}
+
+.release-channel-option:disabled {
+  cursor: default;
+}
+
+.release-channel-option--active {
+  border-color: #153554;
+  background: #f8fbff;
+  box-shadow: inset 3px 0 0 #153554;
+}
+
+.release-channel-option--unavailable:not(.release-channel-option--active) {
+  border-color: #f4cc7a;
+  background: #fffaf0;
+}
+
+.release-channel-option__main {
+  min-width: 0;
+  display: flex;
+  align-items: center;
+  gap: 10px;
+}
+
+.release-channel-option__icon,
+.release-channel-option__check,
+.release-channel-option__arrow,
+.release-channel-option__spinner {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  flex: 0 0 auto;
+}
+
+.release-channel-option__icon {
+  width: 28px;
+  height: 28px;
+  border-radius: 50%;
+  background: #eaf2fb;
+  color: #005486;
+}
+
+.release-channel-option__copy {
+  min-width: 0;
+  display: grid;
+  gap: 2px;
+}
+
+.release-channel-option__copy strong,
+.release-channel-option__copy small {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.release-channel-option__copy strong {
+  color: #172033;
+  font-size: 0.95rem;
+  line-height: 1.2;
+}
+
+.release-channel-option__copy small {
+  color: #64748b;
+  font-size: 0.76rem;
+  font-weight: 700;
+  text-transform: uppercase;
+}
+
+.release-channel-option__meta {
+  color: #153554;
+}
+
+.release-channel-option__missing {
+  grid-column: 1 / -1;
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+  padding-left: 38px;
+}
+
+.release-channel-option__missing span {
+  padding: 4px 7px;
+  border: 1px solid #f6c56b;
+  background: #fff7e6;
+  color: #704600;
+  font-size: 0.72rem;
+  font-weight: 700;
+}
+
+.release-channel-selector--sidebar .release-channel-option {
+  padding: 9px 10px;
+  border-radius: 5px;
+  box-shadow: none;
+}
+
+.release-channel-selector--sidebar .release-channel-option__icon {
+  width: 24px;
+  height: 24px;
+  font-size: 0.72rem;
+}
+
+.release-channel-selector--sidebar .release-channel-option__copy strong {
+  font-size: 0.86rem;
+}
+
+.release-channel-selector--sidebar .release-channel-option__copy small {
+  font-size: 0.68rem;
+}
+</style>
diff --git a/src/components/release/ReleaseChannelSidebarSelector.vue b/src/components/release/ReleaseChannelSidebarSelector.vue
new file mode 100644
index 00000000..65e49f2e
--- /dev/null
+++ b/src/components/release/ReleaseChannelSidebarSelector.vue
@@ -0,0 +1,34 @@
+<script setup>
+import { ref } from "vue";
+import { SessionUser } from "@/components/session/token/SessionUser.vue";
+import ReleaseChannelSelector from "@/components/release/ReleaseChannelSelector.vue";
+import {
+  releaseChannelSelectorVisible,
+  selectReleaseChannel,
+} from "@/services/releaseChannelAvailability.js";
+
+const switchingSlug = ref("");
+
+const switchChannel = async (option) => {
+  const slug = selectReleaseChannel(option.channel);
+  if (!slug) {
+    return;
+  }
+
+  switchingSlug.value = slug;
+  try {
+    await SessionUser.refreshReleaseRuntime();
+  } finally {
+    switchingSlug.value = "";
+  }
+};
+</script>
+
+<template>
+  <ReleaseChannelSelector
+    v-if="releaseChannelSelectorVisible"
+    variant="sidebar"
+    :switching-slug="switchingSlug"
+    @select="switchChannel"
+  />
+</template>
diff --git a/src/components/release/ReleaseChannelSwitched.vue b/src/components/release/ReleaseChannelSwitched.vue
index e55f945e..3330456c 100644
--- a/src/components/release/ReleaseChannelSwitched.vue
+++ b/src/components/release/ReleaseChannelSwitched.vue
@@ -3,7 +3,6 @@ import { computed } from "vue";
 import { useI18n } from "vue-i18n";
 import {
   acknowledgeReleaseChannelSwitch,
-  redirectToConfiguredReleaseFrontend,
   releaseChannelSwitchedStatus,
 } from "@/services/releaseChannelAvailability.js";
 
@@ -18,10 +17,11 @@ const localizedChannelDescription = computed(() => {
   const key = `configuration.release_manager.channel_descriptions.${status.value.channelSlug}`;
   return status.value.channelSlug && te(key) ? t(key) : status.value.description;
 });
-const frontendLabel = computed(() => status.value.frontendBaseUrl || tr("current_app_image"));
-const apiLabel = computed(() => status.value.apiBaseUrl || tr("current_api"));
 const frontendVersion = computed(() => status.value.versions?.frontend || null);
 const apiVersion = computed(() => status.value.versions?.api || null);
+const bundleLabel = computed(() =>
+  status.value.versions?.bundle_id ? `#${status.value.versions.bundle_id}` : tr("assigned_channel")
+);
 
 const versionLabel = (version, fallback) => {
   return version?.version_label || version?.commit_sha || fallback;
@@ -29,7 +29,6 @@ const versionLabel = (version, fallback) => {
 
 const continueToApp = () => {
   acknowledgeReleaseChannelSwitch(status.value.channel, status.value.principalKey);
-  redirectToConfiguredReleaseFrontend();
 };
 </script>
 
@@ -66,12 +65,8 @@ const continueToApp = () => {
 
         <div class="release-details" data-testid="release-channel-switched-details">
           <span
-            ><strong>{{ tr("frontend") }}</strong
-            >{{ frontendLabel }}</span
-          >
-          <span
-            ><strong>{{ tr("api") }}</strong
-            >{{ apiLabel }}</span
+            ><strong>{{ tr("bundle") }}</strong
+            >{{ bundleLabel }}</span
           >
           <span
             ><strong>{{ tr("frontend_version") }}</strong
diff --git a/src/components/release/ReleaseChannelUnavailable.vue b/src/components/release/ReleaseChannelUnavailable.vue
index 8dbf5956..c510e819 100644
--- a/src/components/release/ReleaseChannelUnavailable.vue
+++ b/src/components/release/ReleaseChannelUnavailable.vue
@@ -3,11 +3,13 @@ import { computed, onBeforeUnmount, onMounted, ref } from "vue";
 import { useRouter } from "vue-router";
 import { useI18n } from "vue-i18n";
 import { SessionUser } from "@/components/session/token/SessionUser.vue";
+import ReleaseChannelSelector from "@/components/release/ReleaseChannelSelector.vue";
 import {
   ignoreUnavailableReleaseChannel,
-  redirectToConfiguredReleaseFrontend,
+  releaseChannelSelectorVisible,
   releaseChannelUnavailableStatus,
   RELEASE_CHANNEL_CHECK_INTERVAL_MS,
+  selectReleaseChannel,
 } from "@/services/releaseChannelAvailability.js";
 
 const router = useRouter();
@@ -16,6 +18,7 @@ const tr = (key, params = {}) => t(`configuration.release_manager.channel_unavai
 const checking = ref(false);
 const checkError = ref("");
 const secondsUntilNextCheck = ref(RELEASE_CHANNEL_CHECK_INTERVAL_MS / 1000);
+const switchingSlug = ref("");
 
 let pollTimer = null;
 let countdownTimer = null;
@@ -30,9 +33,12 @@ const localizedChannelDescription = computed(() => {
   return status.value.channelSlug && te(key) ? t(key) : status.value.description;
 });
 const missingLabels = computed(() =>
-  status.value.missing.map((key) =>
-    key === "frontend_base_url" ? tr("frontend_url") : key === "api_base_url" ? tr("api_url") : key
-  )
+  status.value.missing.map((key) => {
+    if (key === "release_bundle") return tr("release_bundle");
+    if (key === "frontend_version") return tr("frontend_version");
+    if (key === "api_version") return tr("api_version");
+    return key;
+  })
 );
 
 const resetCountdown = () => {
@@ -48,7 +54,6 @@ const checkAgain = async () => {
   checkError.value = "";
   try {
     await SessionUser.refreshReleaseRuntime();
-    redirectToConfiguredReleaseFrontend();
   } catch (error) {
     checkError.value = tr("refresh_error");
   } finally {
@@ -61,6 +66,24 @@ const ignoreForFiveMinutes = () => {
   ignoreUnavailableReleaseChannel(status.value.channel);
 };
 
+const switchChannel = async (option) => {
+  const slug = selectReleaseChannel(option.channel);
+  if (!slug || switchingSlug.value) {
+    return;
+  }
+
+  switchingSlug.value = slug;
+  checkError.value = "";
+  try {
+    await SessionUser.refreshReleaseRuntime();
+  } catch (error) {
+    checkError.value = tr("refresh_error");
+  } finally {
+    switchingSlug.value = "";
+    resetCountdown();
+  }
+};
+
 const logout = async () => {
   await SessionUser.auth.logout();
   router.push({ name: "login" });
@@ -120,6 +143,11 @@ onBeforeUnmount(() => {
         <div class="release-missing" data-testid="release-channel-missing">
           <span v-for="label in missingLabels" :key="label">{{ label }}</span>
         </div>
+        <ReleaseChannelSelector
+          v-if="releaseChannelSelectorVisible"
+          :switching-slug="switchingSlug"
+          @select="switchChannel"
+        />
         <p class="release-check-status" data-testid="release-channel-next-check">
           {{ tr("checking_again", { seconds: secondsUntilNextCheck }) }}
         </p>
diff --git a/src/components/session/token/SessionUser.vue b/src/components/session/token/SessionUser.vue
index 927912e5..254f887d 100644
--- a/src/components/session/token/SessionUser.vue
+++ b/src/components/session/token/SessionUser.vue
@@ -48,7 +48,11 @@ import Swal from "sweetalert2";
 import { SubuserGrants } from "@/components/session/token/SessionUser/Objects/SubuserGrants.vue";
 import { Subusers } from "@/components/session/token/SessionUser/Objects/Subusers.vue";
 import { configureReleaseRuntime } from "@/services/releaseTimeline.js";
-import { setReleaseChannelSwitchNoticePrincipal } from "@/services/releaseChannelAvailability.js";
+import {
+  reconcileSelectedReleaseChannel,
+  releaseChannelRuntimeRequestParams,
+  setReleaseChannelSwitchNoticePrincipal,
+} from "@/services/releaseChannelAvailability.js";
 
 const normalizePositiveInteger = (value) => {
   const parsedValue = Number.parseInt(String(value ?? ""), 10);
@@ -92,16 +96,18 @@ const hydrateSessionFromStorage = () => {
 const applyReleaseRuntimeConfig = (runtime) => {
   const normalizedRuntime = runtime || {};
   configureReleaseRuntime(normalizedRuntime);
+  reconcileSelectedReleaseChannel(normalizedRuntime);
   SessionUser.runtimeConfig.release.traceId.value = normalizedRuntime.trace_id || null;
   SessionUser.runtimeConfig.release.channel.value = normalizedRuntime.channel || null;
-  SessionUser.runtimeConfig.release.versions.value = normalizedRuntime.versions || { frontend: null, api: null };
-  SessionUser.runtimeConfig.release.frontendBaseUrl.value =
-    normalizedRuntime.frontend_base_url ||
-    normalizedRuntime.frontendBaseUrl ||
-    normalizedRuntime?.channel?.frontend_base_url ||
-    null;
-  SessionUser.runtimeConfig.release.apiBaseUrl.value =
-    normalizedRuntime.api_base_url || normalizedRuntime.apiBaseUrl || normalizedRuntime?.channel?.api_base_url || null;
+  SessionUser.runtimeConfig.release.availableChannels.value =
+    normalizedRuntime.available_channels || normalizedRuntime.availableChannels || [];
+  SessionUser.runtimeConfig.release.versions.value = normalizedRuntime.versions || {
+    frontend: null,
+    api: null,
+    bundle_id: null,
+  };
+  SessionUser.runtimeConfig.release.frontendBaseUrl.value = null;
+  SessionUser.runtimeConfig.release.apiBaseUrl.value = null;
   SessionUser.runtimeConfig.release.availability.value = normalizedRuntime.availability || {
     configured: true,
     missing: [],
@@ -117,7 +123,7 @@ const applyReleaseRuntimeConfig = (runtime) => {
 };
 
 export const refreshReleaseRuntime = async () => {
-  return authenticatedRequest("/release/runtime", "GET")
+  return authenticatedRequest("/release/runtime", "GET", releaseChannelRuntimeRequestParams())
     .then((response) => {
       applyReleaseRuntimeConfig(response?.data?.data || response?.data || {});
     })
@@ -272,7 +278,7 @@ export const getSubuserSessionData = async () => {
  * @returns {Promise<void>}
  */
 export const getSessionData = async () => {
-  return await authenticatedRequest("/auth/session", "GET")
+  return await authenticatedRequest("/auth/session", "GET", releaseChannelRuntimeRequestParams())
     .then((response) => {
       SessionUser.user.id.value = response.data.data.id;
       SessionUser.user.customer_number.value = response.data.data.customer_number;
@@ -487,6 +493,7 @@ export const SessionUser = {
     release: {
       traceId: ref(null),
       channel: ref(null),
+      availableChannels: ref([]),
       versions: ref({ frontend: null, api: null }),
       frontendBaseUrl: ref(null),
       apiBaseUrl: ref(null),
@@ -743,7 +750,8 @@ export const SessionUser = {
     SessionUser.runtimeConfig.economic.defaultDistributionDepartmentId.value = null;
     SessionUser.runtimeConfig.release.traceId.value = null;
     SessionUser.runtimeConfig.release.channel.value = null;
-    SessionUser.runtimeConfig.release.versions.value = { frontend: null, api: null };
+    SessionUser.runtimeConfig.release.availableChannels.value = [];
+    SessionUser.runtimeConfig.release.versions.value = { frontend: null, api: null, bundle_id: null };
     SessionUser.runtimeConfig.release.frontendBaseUrl.value = null;
     SessionUser.runtimeConfig.release.apiBaseUrl.value = null;
     SessionUser.runtimeConfig.release.availability.value = {
diff --git a/src/components/viewport/page/headers/DesktopNavigationBuefy.vue b/src/components/viewport/page/headers/DesktopNavigationBuefy.vue
index e57a7cbf..003261ee 100644
--- a/src/components/viewport/page/headers/DesktopNavigationBuefy.vue
+++ b/src/components/viewport/page/headers/DesktopNavigationBuefy.vue
@@ -8,6 +8,7 @@ import { ADMIN_DEPARTMENT_SELECTION_CLASS } from "@/components/models/navigation
 import { isDepartmentLabelValid, sortByDepartmentPriorityOrder } from "@/services/departmentVisibility.js";
 import { isSmall } from "@/components/displays/pagination/PaginationDisplayIsSmall.vue";
 import LanguageSelector from "@/components/i18n/LanguageSelector.vue";
+import ReleaseChannelSidebarSelector from "@/components/release/ReleaseChannelSidebarSelector.vue";
 import { SessionUser } from "@/components/session/token/SessionUser.vue";
 import NavigationMenuGlobalSearch from "@/components/viewport/page/headers/menu/NavigationMenuGlobalSearch.vue";
 
@@ -452,6 +453,7 @@ const getChildBadgeTestId = (item: NavigationMenuItem) => (isDraftsNavigationChi
       </BMenuList>
     </BMenu>
     <LanguageSelector />
+    <ReleaseChannelSidebarSelector />
   </div>
 </template>
 
diff --git a/src/i18n/generated/da-v2.json b/src/i18n/generated/da-v2.json
index eaef79e1..c40cc249 100644
--- a/src/i18n/generated/da-v2.json
+++ b/src/i18n/generated/da-v2.json
@@ -2569,9 +2569,10 @@
               "kicker": "Release Manager",
               "title": "Release-kanalen er ikke klar",
               "summary_prefix": "Din konto er tildelt",
-              "summary_suffix": ", men kanalen mangler den konfiguration, der skal bruges for at indlæse dens release-image.",
-              "frontend_url": "Frontend-URL",
-              "api_url": "API-URL",
+              "summary_suffix": ", men kanalen mangler et aktivt release-bundle.",
+              "release_bundle": "Release-bundle",
+              "frontend_version": "Frontend-version",
+              "api_version": "API-version",
               "checking_again": "Tjekker igen om {seconds}s",
               "refresh_error": "Release-status kunne ikke opdateres. Det næste automatiske tjek prøver igen.",
               "ignore": "Ignorer de næste 5 minutter",
@@ -2584,6 +2585,7 @@
               "title": "Du er nu på {channel}",
               "summary_prefix": "Din konto er blevet tildelt release-kanalen",
               "summary_suffix": "Denne enhed husker, at du har set denne besked.",
+              "bundle": "Bundle",
               "frontend": "Frontend",
               "api": "API",
               "frontend_version": "Frontend-version",
@@ -2594,6 +2596,17 @@
               "base_image": "Basis-image",
               "continue": "Fortsæt"
             },
+            "channel_selector": {
+              "title": "Release-kanal",
+              "subtitle": "Vælg hvilken tildelt release-kanal denne enhed skal bruge.",
+              "sidebar_title": "Release",
+              "default": "Standard",
+              "ready": "Klar",
+              "unavailable": "Ikke klar",
+              "release_bundle": "Release-bundle",
+              "frontend_version": "Frontend-version",
+              "api_version": "API-version"
+            },
             "common": {
               "yes": "ja",
               "no": "nej",
@@ -2743,6 +2756,18 @@
             "assignments": {
               "title": "Tildelinger",
               "subtitle": "Fastgør brugere, medarbejdere eller kunder til release-kanaler.",
+              "subject": "Emne",
+              "subject_message": "Søg efter brugere, medarbejdere eller kunder, eller skriv et manuelt emne som user:42.",
+              "subject_placeholder": "Søg eller skriv emne",
+              "subject_empty": "Ingen emner fundet",
+              "group_users": "Brugere",
+              "group_subusers": "Medarbejdere",
+              "group_customers": "Kunder",
+              "group_manual": "Manuel",
+              "manual_user": "Bruger #{id}",
+              "manual_subuser": "Medarbejder #{id}",
+              "manual_customer": "Kunde #{id}",
+              "manual_description": "Brug indtastet værdi {subject}",
               "subject_type": "Emnetype",
               "subject_type_message": "Vælg identitetstypen, der skal fastgøres.",
               "customer": "Kunde",
diff --git a/src/i18n/generated/de-v2.json b/src/i18n/generated/de-v2.json
index e58d86ab..71ceb5e6 100644
--- a/src/i18n/generated/de-v2.json
+++ b/src/i18n/generated/de-v2.json
@@ -2679,9 +2679,10 @@
               "kicker": "Release Manager",
               "title": "Release-Kanal ist nicht bereit",
               "summary_prefix": "Dein Konto ist zugewiesen zu",
-              "summary_suffix": ", aber diesem Kanal fehlt die Konfiguration, um sein Release-Image zu laden.",
-              "frontend_url": "Frontend-URL",
-              "api_url": "API-URL",
+              "summary_suffix": ", aber diesem Kanal fehlt ein aktives Release-Bundle.",
+              "release_bundle": "Release-Bundle",
+              "frontend_version": "Frontend-Version",
+              "api_version": "API-Version",
               "checking_again": "Erneute Prüfung in {seconds}s",
               "refresh_error": "Release-Status konnte nicht aktualisiert werden. Die nächste automatische Prüfung versucht es erneut.",
               "ignore": "Nächste 5 Minuten ignorieren",
@@ -2694,6 +2695,7 @@
               "title": "Du bist jetzt auf {channel}",
               "summary_prefix": "Dein Konto wurde dem Release-Kanal",
               "summary_suffix": "zugewiesen. Dieses Gerät merkt sich, dass du diesen Hinweis gesehen hast.",
+              "bundle": "Bundle",
               "frontend": "Frontend",
               "api": "API",
               "frontend_version": "Frontend-Version",
@@ -2704,6 +2706,17 @@
               "base_image": "Basis-Image",
               "continue": "Fortfahren"
             },
+            "channel_selector": {
+              "title": "Release-Kanal",
+              "subtitle": "Wählen Sie, welchen zugewiesenen Release-Kanal dieses Gerät verwenden soll.",
+              "sidebar_title": "Release",
+              "default": "Standard",
+              "ready": "Bereit",
+              "unavailable": "Nicht bereit",
+              "release_bundle": "Release-Bundle",
+              "frontend_version": "Frontend-Version",
+              "api_version": "API-Version"
+            },
             "common": {
               "yes": "ja",
               "no": "nein",
@@ -2853,6 +2866,18 @@
             "assignments": {
               "title": "Zuweisungen",
               "subtitle": "Benutzer, Mitarbeiter oder Kunden an Release-Kanäle binden.",
+              "subject": "Subjekt",
+              "subject_message": "Benutzer, Subuser oder Kunden suchen oder ein manuelles Subjekt wie user:42 eingeben.",
+              "subject_placeholder": "Subjekt suchen oder eingeben",
+              "subject_empty": "Keine Subjekte gefunden",
+              "group_users": "Benutzer",
+              "group_subusers": "Subuser",
+              "group_customers": "Kunden",
+              "group_manual": "Manuell",
+              "manual_user": "Benutzer #{id}",
+              "manual_subuser": "Subuser #{id}",
+              "manual_customer": "Kunde #{id}",
+              "manual_description": "Eingegebenen Wert {subject} verwenden",
               "subject_type": "Subjekttyp",
               "subject_type_message": "Identitätstyp zum Binden auswählen.",
               "customer": "Customer",
diff --git a/src/i18n/generated/en-v2.json b/src/i18n/generated/en-v2.json
index bffd0195..605b357a 100644
--- a/src/i18n/generated/en-v2.json
+++ b/src/i18n/generated/en-v2.json
@@ -2403,9 +2403,10 @@
               "kicker": "Release Manager",
               "title": "Release channel is not ready",
               "summary_prefix": "Your account is assigned to",
-              "summary_suffix": ", but that channel is missing the configuration needed to load its release image.",
-              "frontend_url": "Frontend URL",
-              "api_url": "API URL",
+              "summary_suffix": ", but that channel is missing an active release bundle.",
+              "release_bundle": "Release bundle",
+              "frontend_version": "Frontend version",
+              "api_version": "API version",
               "checking_again": "Checking again in {seconds}s",
               "refresh_error": "Release status could not be refreshed. The next automatic check will try again.",
               "ignore": "Ignore next 5 minutes",
@@ -2418,6 +2419,7 @@
               "title": "You are now on {channel}",
               "summary_prefix": "Your account has been assigned to the",
               "summary_suffix": "release channel. This device will remember that you have seen this notice.",
+              "bundle": "Bundle",
               "frontend": "Frontend",
               "api": "API",
               "frontend_version": "Frontend version",
@@ -2428,6 +2430,17 @@
               "base_image": "Base image",
               "continue": "Continue"
             },
+            "channel_selector": {
+              "title": "Release channel",
+              "subtitle": "Choose which assigned release channel this device should use.",
+              "sidebar_title": "Release",
+              "default": "Default",
+              "ready": "Ready",
+              "unavailable": "Not ready",
+              "release_bundle": "Release bundle",
+              "frontend_version": "Frontend version",
+              "api_version": "API version"
+            },
             "common": {
               "yes": "yes",
               "no": "no",
@@ -2577,6 +2590,18 @@
             "assignments": {
               "title": "Assignments",
               "subtitle": "Pin users, subusers, or customers to release channels.",
+              "subject": "Subject",
+              "subject_message": "Search users, subusers, or customers, or type a manual subject like user:42.",
+              "subject_placeholder": "Search or type subject",
+              "subject_empty": "No subjects found",
+              "group_users": "Users",
+              "group_subusers": "Subusers",
+              "group_customers": "Customers",
+              "group_manual": "Manual",
+              "manual_user": "User #{id}",
+              "manual_subuser": "Subuser #{id}",
+              "manual_customer": "Customer #{id}",
+              "manual_description": "Use typed value {subject}",
               "subject_type": "Subject type",
               "subject_type_message": "Choose the identity type to pin.",
               "customer": "Customer",
diff --git a/src/i18n/generated/global-v2.json b/src/i18n/generated/global-v2.json
index f31953ec..d0993073 100644
--- a/src/i18n/generated/global-v2.json
+++ b/src/i18n/generated/global-v2.json
@@ -1629,8 +1629,9 @@
           "title": "@:{'templates.generated.compat.configuration.release_manager.channel_unavailable.title'}",
           "summary_prefix": "@:{'templates.generated.compat.configuration.release_manager.channel_unavailable.summary_prefix'}",
           "summary_suffix": "@:{'templates.generated.compat.configuration.release_manager.channel_unavailable.summary_suffix'}",
-          "frontend_url": "@:{'templates.generated.compat.configuration.release_manager.channel_unavailable.frontend_url'}",
-          "api_url": "@:{'templates.generated.compat.configuration.release_manager.channel_unavailable.api_url'}",
+          "release_bundle": "@:{'templates.generated.compat.configuration.release_manager.channel_unavailable.release_bundle'}",
+          "frontend_version": "@:{'templates.generated.compat.configuration.release_manager.channel_unavailable.frontend_version'}",
+          "api_version": "@:{'templates.generated.compat.configuration.release_manager.channel_unavailable.api_version'}",
           "checking_again": "@:{'templates.generated.compat.configuration.release_manager.channel_unavailable.checking_again'}",
           "refresh_error": "@:{'templates.generated.compat.configuration.release_manager.channel_unavailable.refresh_error'}",
           "ignore": "@:{'templates.generated.compat.configuration.release_manager.channel_unavailable.ignore'}",
@@ -1643,6 +1644,7 @@
           "title": "@:{'templates.generated.compat.configuration.release_manager.channel_switched.title'}",
           "summary_prefix": "@:{'templates.generated.compat.configuration.release_manager.channel_switched.summary_prefix'}",
           "summary_suffix": "@:{'templates.generated.compat.configuration.release_manager.channel_switched.summary_suffix'}",
+          "bundle": "@:{'templates.generated.compat.configuration.release_manager.channel_switched.bundle'}",
           "frontend": "@:{'templates.generated.compat.configuration.release_manager.channel_switched.frontend'}",
           "api": "@:{'templates.generated.compat.configuration.release_manager.channel_switched.api'}",
           "frontend_version": "@:{'templates.generated.compat.configuration.release_manager.channel_switched.frontend_version'}",
@@ -1653,6 +1655,17 @@
           "base_image": "@:{'templates.generated.compat.configuration.release_manager.channel_switched.base_image'}",
           "continue": "@:{'templates.generated.compat.configuration.release_manager.channel_switched.continue'}"
         },
+        "channel_selector": {
+          "title": "@:{'templates.generated.compat.configuration.release_manager.channel_selector.title'}",
+          "subtitle": "@:{'templates.generated.compat.configuration.release_manager.channel_selector.subtitle'}",
+          "sidebar_title": "@:{'templates.generated.compat.configuration.release_manager.channel_selector.sidebar_title'}",
+          "default": "@:{'templates.generated.compat.configuration.release_manager.channel_selector.default'}",
+          "ready": "@:{'templates.generated.compat.configuration.release_manager.channel_selector.ready'}",
+          "unavailable": "@:{'templates.generated.compat.configuration.release_manager.channel_selector.unavailable'}",
+          "release_bundle": "@:{'templates.generated.compat.configuration.release_manager.channel_selector.release_bundle'}",
+          "frontend_version": "@:{'templates.generated.compat.configuration.release_manager.channel_selector.frontend_version'}",
+          "api_version": "@:{'templates.generated.compat.configuration.release_manager.channel_selector.api_version'}"
+        },
         "common": {
           "yes": "@:{'templates.generated.compat.configuration.release_manager.common.yes'}",
           "no": "@:{'templates.generated.compat.configuration.release_manager.common.no'}",
@@ -1802,6 +1815,18 @@
         "assignments": {
           "title": "@:{'templates.generated.compat.configuration.release_manager.assignments.title'}",
           "subtitle": "@:{'templates.generated.compat.configuration.release_manager.assignments.subtitle'}",
+          "subject": "@:{'templates.generated.compat.configuration.release_manager.assignments.subject'}",
+          "subject_message": "@:{'templates.generated.compat.configuration.release_manager.assignments.subject_message'}",
+          "subject_placeholder": "@:{'templates.generated.compat.configuration.release_manager.assignments.subject_placeholder'}",
+          "subject_empty": "@:{'templates.generated.compat.configuration.release_manager.assignments.subject_empty'}",
+          "group_users": "@:{'templates.generated.compat.configuration.release_manager.assignments.group_users'}",
+          "group_subusers": "@:{'templates.generated.compat.configuration.release_manager.assignments.group_subusers'}",
+          "group_customers": "@:{'templates.generated.compat.configuration.release_manager.assignments.group_customers'}",
+          "group_manual": "@:{'templates.generated.compat.configuration.release_manager.assignments.group_manual'}",
+          "manual_user": "@:{'templates.generated.compat.configuration.release_manager.assignments.manual_user'}",
+          "manual_subuser": "@:{'templates.generated.compat.configuration.release_manager.assignments.manual_subuser'}",
+          "manual_customer": "@:{'templates.generated.compat.configuration.release_manager.assignments.manual_customer'}",
+          "manual_description": "@:{'templates.generated.compat.configuration.release_manager.assignments.manual_description'}",
           "subject_type": "@:{'templates.generated.compat.configuration.release_manager.assignments.subject_type'}",
           "subject_type_message": "@:{'templates.generated.compat.configuration.release_manager.assignments.subject_type_message'}",
           "customer": "@:{'templates.generated.compat.configuration.release_manager.assignments.customer'}",
diff --git a/src/i18n/generated/no-v2.json b/src/i18n/generated/no-v2.json
index 6bff508f..ef54a73d 100644
--- a/src/i18n/generated/no-v2.json
+++ b/src/i18n/generated/no-v2.json
@@ -2680,9 +2680,10 @@
               "kicker": "Release Manager",
               "title": "Release-kanalen er ikke klar",
               "summary_prefix": "Kontoen din er tildelt",
-              "summary_suffix": ", men kanalen mangler konfigurasjonen som trengs for å laste release-imaget.",
-              "frontend_url": "Frontend-URL",
-              "api_url": "API-URL",
+              "summary_suffix": ", men kanalen mangler en aktiv release-bundle.",
+              "release_bundle": "Release-bundle",
+              "frontend_version": "Frontend-versjon",
+              "api_version": "API-versjon",
               "checking_again": "Sjekker igjen om {seconds}s",
               "refresh_error": "Release-status kunne ikke oppdateres. Neste automatiske sjekk prøver igjen.",
               "ignore": "Ignorer de neste 5 minuttene",
@@ -2695,6 +2696,7 @@
               "title": "Du er nå på {channel}",
               "summary_prefix": "Kontoen din er tildelt release-kanalen",
               "summary_suffix": "Denne enheten husker at du har sett denne meldingen.",
+              "bundle": "Bundle",
               "frontend": "Frontend",
               "api": "API",
               "frontend_version": "Frontend-versjon",
@@ -2705,6 +2707,17 @@
               "base_image": "Basis-image",
               "continue": "Fortsett"
             },
+            "channel_selector": {
+              "title": "Release-kanal",
+              "subtitle": "Velg hvilken tildelt release-kanal denne enheten skal bruke.",
+              "sidebar_title": "Release",
+              "default": "Standard",
+              "ready": "Klar",
+              "unavailable": "Ikke klar",
+              "release_bundle": "Release-bundle",
+              "frontend_version": "Frontend-versjon",
+              "api_version": "API-versjon"
+            },
             "common": {
               "yes": "ja",
               "no": "nei",
@@ -2854,6 +2867,18 @@
             "assignments": {
               "title": "Tildelinger",
               "subtitle": "Fest brukere, medarbeidere eller kunder til release-kanaler.",
+              "subject": "Emne",
+              "subject_message": "Søk etter brukere, medarbeidere eller kunder, eller skriv et manuelt emne som user:42.",
+              "subject_placeholder": "Søk eller skriv emne",
+              "subject_empty": "Ingen emner funnet",
+              "group_users": "Brukere",
+              "group_subusers": "Medarbeidere",
+              "group_customers": "Kunder",
+              "group_manual": "Manuell",
+              "manual_user": "Bruker #{id}",
+              "manual_subuser": "Medarbeider #{id}",
+              "manual_customer": "Kunde #{id}",
+              "manual_description": "Bruk inntastet verdi {subject}",
               "subject_type": "Emnetype",
               "subject_type_message": "Vælg identitetstypen, der skal fastgøres.",
               "customer": "Kunde",
diff --git a/src/i18n/generated/sv-v2.json b/src/i18n/generated/sv-v2.json
index 1f371a94..4986fab8 100644
--- a/src/i18n/generated/sv-v2.json
+++ b/src/i18n/generated/sv-v2.json
@@ -2730,9 +2730,10 @@
               "kicker": "Release Manager",
               "title": "Release-kanalen är inte klar",
               "summary_prefix": "Ditt konto är tilldelat",
-              "summary_suffix": ", men kanalen saknar konfigurationen som behövs för att läsa in dess release-image.",
-              "frontend_url": "Frontend-URL",
-              "api_url": "API-URL",
+              "summary_suffix": ", men kanalen saknar ett aktivt release-bundle.",
+              "release_bundle": "Release-bundle",
+              "frontend_version": "Frontend-version",
+              "api_version": "API-version",
               "checking_again": "Kontrollerar igen om {seconds}s",
               "refresh_error": "Release-status kunde inte uppdateras. Nästa automatiska kontroll försöker igen.",
               "ignore": "Ignorera de kommande 5 minuterna",
@@ -2745,6 +2746,7 @@
               "title": "Du är nu på {channel}",
               "summary_prefix": "Ditt konto har tilldelats release-kanalen",
               "summary_suffix": "Den här enheten kommer ihåg att du har sett detta meddelande.",
+              "bundle": "Bundle",
               "frontend": "Frontend",
               "api": "API",
               "frontend_version": "Frontend-version",
@@ -2755,6 +2757,17 @@
               "base_image": "Bas-image",
               "continue": "Fortsätt"
             },
+            "channel_selector": {
+              "title": "Release-kanal",
+              "subtitle": "Välj vilken tilldelad release-kanal den här enheten ska använda.",
+              "sidebar_title": "Release",
+              "default": "Standard",
+              "ready": "Klar",
+              "unavailable": "Inte klar",
+              "release_bundle": "Release-bundle",
+              "frontend_version": "Frontend-version",
+              "api_version": "API-version"
+            },
             "common": {
               "yes": "ja",
               "no": "nej",
@@ -2904,6 +2917,18 @@
             "assignments": {
               "title": "Tilldelningar",
               "subtitle": "Fäst användare, medarbetare eller kunder till release-kanaler.",
+              "subject": "Ämne",
+              "subject_message": "Sök efter användare, medarbetare eller kunder, eller skriv ett manuellt ämne som user:42.",
+              "subject_placeholder": "Sök eller skriv ämne",
+              "subject_empty": "Inga ämnen hittades",
+              "group_users": "Användare",
+              "group_subusers": "Medarbetare",
+              "group_customers": "Kunder",
+              "group_manual": "Manuell",
+              "manual_user": "Användare #{id}",
+              "manual_subuser": "Medarbetare #{id}",
+              "manual_customer": "Kund #{id}",
+              "manual_description": "Använd inmatat värde {subject}",
               "subject_type": "Ämnestyp",
               "subject_type_message": "Välj identitetstypen som ska fästas.",
               "customer": "Kunde",
diff --git a/src/i18n/locales/da.json b/src/i18n/locales/da.json
index c3d08c28..a6cb3658 100644
--- a/src/i18n/locales/da.json
+++ b/src/i18n/locales/da.json
@@ -1627,9 +1627,10 @@
         "kicker": "Release Manager",
         "title": "Release-kanalen er ikke klar",
         "summary_prefix": "Din konto er tildelt",
-        "summary_suffix": ", men kanalen mangler den konfiguration, der skal bruges for at indlæse dens release-image.",
-        "frontend_url": "Frontend-URL",
-        "api_url": "API-URL",
+        "summary_suffix": ", men kanalen mangler et aktivt release-bundle.",
+        "release_bundle": "Release-bundle",
+        "frontend_version": "Frontend-version",
+        "api_version": "API-version",
         "checking_again": "Tjekker igen om {seconds}s",
         "refresh_error": "Release-status kunne ikke opdateres. Det næste automatiske tjek prøver igen.",
         "ignore": "Ignorer de næste 5 minutter",
@@ -1642,6 +1643,7 @@
         "title": "Du er nu på {channel}",
         "summary_prefix": "Din konto er blevet tildelt release-kanalen",
         "summary_suffix": "Denne enhed husker, at du har set denne besked.",
+        "bundle": "Bundle",
         "frontend": "Frontend",
         "api": "API",
         "frontend_version": "Frontend-version",
@@ -1652,6 +1654,17 @@
         "base_image": "Basis-image",
         "continue": "Fortsæt"
       },
+      "channel_selector": {
+        "title": "Release-kanal",
+        "subtitle": "Vælg hvilken tildelt release-kanal denne enhed skal bruge.",
+        "sidebar_title": "Release",
+        "default": "Standard",
+        "ready": "Klar",
+        "unavailable": "Ikke klar",
+        "release_bundle": "Release-bundle",
+        "frontend_version": "Frontend-version",
+        "api_version": "API-version"
+      },
       "common": {
         "yes": "ja",
         "no": "nej",
@@ -1801,6 +1814,18 @@
       "assignments": {
         "title": "Tildelinger",
         "subtitle": "Fastgør brugere, medarbejdere eller kunder til release-kanaler.",
+        "subject": "Emne",
+        "subject_message": "Søg efter brugere, medarbejdere eller kunder, eller skriv et manuelt emne som user:42.",
+        "subject_placeholder": "Søg eller skriv emne",
+        "subject_empty": "Ingen emner fundet",
+        "group_users": "Brugere",
+        "group_subusers": "Medarbejdere",
+        "group_customers": "Kunder",
+        "group_manual": "Manuel",
+        "manual_user": "Bruger #{id}",
+        "manual_subuser": "Medarbejder #{id}",
+        "manual_customer": "Kunde #{id}",
+        "manual_description": "Brug indtastet værdi {subject}",
         "subject_type": "Emnetype",
         "subject_type_message": "Vælg identitetstypen, der skal fastgøres.",
         "customer": "Kunde",
diff --git a/src/i18n/locales/de.json b/src/i18n/locales/de.json
index bcb2beb2..f0305305 100644
--- a/src/i18n/locales/de.json
+++ b/src/i18n/locales/de.json
@@ -1627,9 +1627,10 @@
         "kicker": "Release Manager",
         "title": "Release-Kanal ist nicht bereit",
         "summary_prefix": "Dein Konto ist zugewiesen zu",
-        "summary_suffix": ", aber diesem Kanal fehlt die Konfiguration, um sein Release-Image zu laden.",
-        "frontend_url": "Frontend-URL",
-        "api_url": "API-URL",
+        "summary_suffix": ", aber diesem Kanal fehlt ein aktives Release-Bundle.",
+        "release_bundle": "Release-Bundle",
+        "frontend_version": "Frontend-Version",
+        "api_version": "API-Version",
         "checking_again": "Erneute Prüfung in {seconds}s",
         "refresh_error": "Release-Status konnte nicht aktualisiert werden. Die nächste automatische Prüfung versucht es erneut.",
         "ignore": "Nächste 5 Minuten ignorieren",
@@ -1642,6 +1643,7 @@
         "title": "Du bist jetzt auf {channel}",
         "summary_prefix": "Dein Konto wurde dem Release-Kanal",
         "summary_suffix": "zugewiesen. Dieses Gerät merkt sich, dass du diesen Hinweis gesehen hast.",
+        "bundle": "Bundle",
         "frontend": "Frontend",
         "api": "API",
         "frontend_version": "Frontend-Version",
@@ -1652,6 +1654,17 @@
         "base_image": "Basis-Image",
         "continue": "Fortfahren"
       },
+      "channel_selector": {
+        "title": "Release-Kanal",
+        "subtitle": "Wählen Sie, welchen zugewiesenen Release-Kanal dieses Gerät verwenden soll.",
+        "sidebar_title": "Release",
+        "default": "Standard",
+        "ready": "Bereit",
+        "unavailable": "Nicht bereit",
+        "release_bundle": "Release-Bundle",
+        "frontend_version": "Frontend-Version",
+        "api_version": "API-Version"
+      },
       "common": {
         "yes": "ja",
         "no": "nein",
@@ -1801,6 +1814,18 @@
       "assignments": {
         "title": "Zuweisungen",
         "subtitle": "Benutzer, Mitarbeiter oder Kunden an Release-Kanäle binden.",
+        "subject": "Subjekt",
+        "subject_message": "Benutzer, Subuser oder Kunden suchen oder ein manuelles Subjekt wie user:42 eingeben.",
+        "subject_placeholder": "Subjekt suchen oder eingeben",
+        "subject_empty": "Keine Subjekte gefunden",
+        "group_users": "Benutzer",
+        "group_subusers": "Subuser",
+        "group_customers": "Kunden",
+        "group_manual": "Manuell",
+        "manual_user": "Benutzer #{id}",
+        "manual_subuser": "Subuser #{id}",
+        "manual_customer": "Kunde #{id}",
+        "manual_description": "Eingegebenen Wert {subject} verwenden",
         "subject_type": "Subjekttyp",
         "subject_type_message": "Identitätstyp zum Binden auswählen.",
         "customer": "Customer",
diff --git a/src/i18n/locales/en.json b/src/i18n/locales/en.json
index 0061715e..9110240c 100644
--- a/src/i18n/locales/en.json
+++ b/src/i18n/locales/en.json
@@ -1627,9 +1627,10 @@
         "kicker": "Release Manager",
         "title": "Release channel is not ready",
         "summary_prefix": "Your account is assigned to",
-        "summary_suffix": ", but that channel is missing the configuration needed to load its release image.",
-        "frontend_url": "Frontend URL",
-        "api_url": "API URL",
+        "summary_suffix": ", but that channel is missing an active release bundle.",
+        "release_bundle": "Release bundle",
+        "frontend_version": "Frontend version",
+        "api_version": "API version",
         "checking_again": "Checking again in {seconds}s",
         "refresh_error": "Release status could not be refreshed. The next automatic check will try again.",
         "ignore": "Ignore next 5 minutes",
@@ -1642,6 +1643,7 @@
         "title": "You are now on {channel}",
         "summary_prefix": "Your account has been assigned to the",
         "summary_suffix": "release channel. This device will remember that you have seen this notice.",
+        "bundle": "Bundle",
         "frontend": "Frontend",
         "api": "API",
         "frontend_version": "Frontend version",
@@ -1652,6 +1654,17 @@
         "base_image": "Base image",
         "continue": "Continue"
       },
+      "channel_selector": {
+        "title": "Release channel",
+        "subtitle": "Choose which assigned release channel this device should use.",
+        "sidebar_title": "Release",
+        "default": "Default",
+        "ready": "Ready",
+        "unavailable": "Not ready",
+        "release_bundle": "Release bundle",
+        "frontend_version": "Frontend version",
+        "api_version": "API version"
+      },
       "common": {
         "yes": "yes",
         "no": "no",
@@ -1801,6 +1814,18 @@
       "assignments": {
         "title": "Assignments",
         "subtitle": "Pin users, subusers, or customers to release channels.",
+        "subject": "Subject",
+        "subject_message": "Search users, subusers, or customers, or type a manual subject like user:42.",
+        "subject_placeholder": "Search or type subject",
+        "subject_empty": "No subjects found",
+        "group_users": "Users",
+        "group_subusers": "Subusers",
+        "group_customers": "Customers",
+        "group_manual": "Manual",
+        "manual_user": "User #{id}",
+        "manual_subuser": "Subuser #{id}",
+        "manual_customer": "Customer #{id}",
+        "manual_description": "Use typed value {subject}",
         "subject_type": "Subject type",
         "subject_type_message": "Choose the identity type to pin.",
         "customer": "Customer",
diff --git a/src/i18n/locales/no.json b/src/i18n/locales/no.json
index f7ae3091..96576fd1 100644
--- a/src/i18n/locales/no.json
+++ b/src/i18n/locales/no.json
@@ -1627,9 +1627,10 @@
         "kicker": "Release Manager",
         "title": "Release-kanalen er ikke klar",
         "summary_prefix": "Kontoen din er tildelt",
-        "summary_suffix": ", men kanalen mangler konfigurasjonen som trengs for å laste release-imaget.",
-        "frontend_url": "Frontend-URL",
-        "api_url": "API-URL",
+        "summary_suffix": ", men kanalen mangler en aktiv release-bundle.",
+        "release_bundle": "Release-bundle",
+        "frontend_version": "Frontend-versjon",
+        "api_version": "API-versjon",
         "checking_again": "Sjekker igjen om {seconds}s",
         "refresh_error": "Release-status kunne ikke oppdateres. Neste automatiske sjekk prøver igjen.",
         "ignore": "Ignorer de neste 5 minuttene",
@@ -1642,6 +1643,7 @@
         "title": "Du er nå på {channel}",
         "summary_prefix": "Kontoen din er tildelt release-kanalen",
         "summary_suffix": "Denne enheten husker at du har sett denne meldingen.",
+        "bundle": "Bundle",
         "frontend": "Frontend",
         "api": "API",
         "frontend_version": "Frontend-versjon",
@@ -1652,6 +1654,17 @@
         "base_image": "Basis-image",
         "continue": "Fortsett"
       },
+      "channel_selector": {
+        "title": "Release-kanal",
+        "subtitle": "Velg hvilken tildelt release-kanal denne enheten skal bruke.",
+        "sidebar_title": "Release",
+        "default": "Standard",
+        "ready": "Klar",
+        "unavailable": "Ikke klar",
+        "release_bundle": "Release-bundle",
+        "frontend_version": "Frontend-versjon",
+        "api_version": "API-versjon"
+      },
       "common": {
         "yes": "ja",
         "no": "nei",
@@ -1801,6 +1814,18 @@
       "assignments": {
         "title": "Tildelinger",
         "subtitle": "Fest brukere, medarbeidere eller kunder til release-kanaler.",
+        "subject": "Emne",
+        "subject_message": "Søk etter brukere, medarbeidere eller kunder, eller skriv et manuelt emne som user:42.",
+        "subject_placeholder": "Søk eller skriv emne",
+        "subject_empty": "Ingen emner funnet",
+        "group_users": "Brukere",
+        "group_subusers": "Medarbeidere",
+        "group_customers": "Kunder",
+        "group_manual": "Manuell",
+        "manual_user": "Bruker #{id}",
+        "manual_subuser": "Medarbeider #{id}",
+        "manual_customer": "Kunde #{id}",
+        "manual_description": "Bruk inntastet verdi {subject}",
         "subject_type": "Emnetype",
         "subject_type_message": "Vælg identitetstypen, der skal fastgøres.",
         "customer": "Kunde",
diff --git a/src/i18n/locales/sv.json b/src/i18n/locales/sv.json
index 7bf7c27f..e9bd815d 100644
--- a/src/i18n/locales/sv.json
+++ b/src/i18n/locales/sv.json
@@ -1627,9 +1627,10 @@
         "kicker": "Release Manager",
         "title": "Release-kanalen är inte klar",
         "summary_prefix": "Ditt konto är tilldelat",
-        "summary_suffix": ", men kanalen saknar konfigurationen som behövs för att läsa in dess release-image.",
-        "frontend_url": "Frontend-URL",
-        "api_url": "API-URL",
+        "summary_suffix": ", men kanalen saknar ett aktivt release-bundle.",
+        "release_bundle": "Release-bundle",
+        "frontend_version": "Frontend-version",
+        "api_version": "API-version",
         "checking_again": "Kontrollerar igen om {seconds}s",
         "refresh_error": "Release-status kunde inte uppdateras. Nästa automatiska kontroll försöker igen.",
         "ignore": "Ignorera de kommande 5 minuterna",
@@ -1642,6 +1643,7 @@
         "title": "Du är nu på {channel}",
         "summary_prefix": "Ditt konto har tilldelats release-kanalen",
         "summary_suffix": "Den här enheten kommer ihåg att du har sett detta meddelande.",
+        "bundle": "Bundle",
         "frontend": "Frontend",
         "api": "API",
         "frontend_version": "Frontend-version",
@@ -1652,6 +1654,17 @@
         "base_image": "Bas-image",
         "continue": "Fortsätt"
       },
+      "channel_selector": {
+        "title": "Release-kanal",
+        "subtitle": "Välj vilken tilldelad release-kanal den här enheten ska använda.",
+        "sidebar_title": "Release",
+        "default": "Standard",
+        "ready": "Klar",
+        "unavailable": "Inte klar",
+        "release_bundle": "Release-bundle",
+        "frontend_version": "Frontend-version",
+        "api_version": "API-version"
+      },
       "common": {
         "yes": "ja",
         "no": "nej",
@@ -1801,6 +1814,18 @@
       "assignments": {
         "title": "Tilldelningar",
         "subtitle": "Fäst användare, medarbetare eller kunder till release-kanaler.",
+        "subject": "Ämne",
+        "subject_message": "Sök efter användare, medarbetare eller kunder, eller skriv ett manuellt ämne som user:42.",
+        "subject_placeholder": "Sök eller skriv ämne",
+        "subject_empty": "Inga ämnen hittades",
+        "group_users": "Användare",
+        "group_subusers": "Medarbetare",
+        "group_customers": "Kunder",
+        "group_manual": "Manuell",
+        "manual_user": "Användare #{id}",
+        "manual_subuser": "Medarbetare #{id}",
+        "manual_customer": "Kund #{id}",
+        "manual_description": "Använd inmatat värde {subject}",
         "subject_type": "Ämnestyp",
         "subject_type_message": "Välj identitetstypen som ska fästas.",
         "customer": "Kunde",
diff --git a/src/i18n/source/da/phrases/compat/configuration/index.json b/src/i18n/source/da/phrases/compat/configuration/index.json
index f86ab3f9..90045c3c 100644
--- a/src/i18n/source/da/phrases/compat/configuration/index.json
+++ b/src/i18n/source/da/phrases/compat/configuration/index.json
@@ -430,9 +430,10 @@
           "kicker": "Release Manager",
           "title": "Release-kanalen er ikke klar",
           "summary_prefix": "Din konto er tildelt",
-          "summary_suffix": ", men kanalen mangler den konfiguration, der skal bruges for at indlæse dens release-image.",
-          "frontend_url": "Frontend-URL",
-          "api_url": "API-URL",
+          "summary_suffix": ", men kanalen mangler et aktivt release-bundle.",
+          "release_bundle": "Release-bundle",
+          "frontend_version": "Frontend-version",
+          "api_version": "API-version",
           "checking_again": "Tjekker igen om {seconds}s",
           "refresh_error": "Release-status kunne ikke opdateres. Det næste automatiske tjek prøver igen.",
           "ignore": "Ignorer de næste 5 minutter",
@@ -445,6 +446,7 @@
           "title": "Du er nu på {channel}",
           "summary_prefix": "Din konto er blevet tildelt release-kanalen",
           "summary_suffix": "Denne enhed husker, at du har set denne besked.",
+          "bundle": "Bundle",
           "frontend": "Frontend",
           "api": "API",
           "frontend_version": "Frontend-version",
@@ -455,6 +457,17 @@
           "base_image": "Basis-image",
           "continue": "Fortsæt"
         },
+        "channel_selector": {
+          "title": "Release-kanal",
+          "subtitle": "Vælg hvilken tildelt release-kanal denne enhed skal bruge.",
+          "sidebar_title": "Release",
+          "default": "Standard",
+          "ready": "Klar",
+          "unavailable": "Ikke klar",
+          "release_bundle": "Release-bundle",
+          "frontend_version": "Frontend-version",
+          "api_version": "API-version"
+        },
         "common": {
           "yes": "ja",
           "no": "nej",
@@ -604,6 +617,18 @@
         "assignments": {
           "title": "Tildelinger",
           "subtitle": "Fastgør brugere, medarbejdere eller kunder til release-kanaler.",
+          "subject": "Emne",
+          "subject_message": "Søg efter brugere, medarbejdere eller kunder, eller skriv et manuelt emne som user:42.",
+          "subject_placeholder": "Søg eller skriv emne",
+          "subject_empty": "Ingen emner fundet",
+          "group_users": "Brugere",
+          "group_subusers": "Medarbejdere",
+          "group_customers": "Kunder",
+          "group_manual": "Manuel",
+          "manual_user": "Bruger #{id}",
+          "manual_subuser": "Medarbejder #{id}",
+          "manual_customer": "Kunde #{id}",
+          "manual_description": "Brug indtastet værdi {subject}",
           "subject_type": "Emnetype",
           "subject_type_message": "Vælg identitetstypen, der skal fastgøres.",
           "customer": "Kunde",
diff --git a/src/i18n/source/de/phrases/compat/configuration/index.json b/src/i18n/source/de/phrases/compat/configuration/index.json
index b6917a11..74f856dd 100644
--- a/src/i18n/source/de/phrases/compat/configuration/index.json
+++ b/src/i18n/source/de/phrases/compat/configuration/index.json
@@ -430,9 +430,10 @@
           "kicker": "Release Manager",
           "title": "Release-Kanal ist nicht bereit",
           "summary_prefix": "Dein Konto ist zugewiesen zu",
-          "summary_suffix": ", aber diesem Kanal fehlt die Konfiguration, um sein Release-Image zu laden.",
-          "frontend_url": "Frontend-URL",
-          "api_url": "API-URL",
+          "summary_suffix": ", aber diesem Kanal fehlt ein aktives Release-Bundle.",
+          "release_bundle": "Release-Bundle",
+          "frontend_version": "Frontend-Version",
+          "api_version": "API-Version",
           "checking_again": "Erneute Prüfung in {seconds}s",
           "refresh_error": "Release-Status konnte nicht aktualisiert werden. Die nächste automatische Prüfung versucht es erneut.",
           "ignore": "Nächste 5 Minuten ignorieren",
@@ -445,6 +446,7 @@
           "title": "Du bist jetzt auf {channel}",
           "summary_prefix": "Dein Konto wurde dem Release-Kanal",
           "summary_suffix": "zugewiesen. Dieses Gerät merkt sich, dass du diesen Hinweis gesehen hast.",
+          "bundle": "Bundle",
           "frontend": "Frontend",
           "api": "API",
           "frontend_version": "Frontend-Version",
@@ -455,6 +457,17 @@
           "base_image": "Basis-Image",
           "continue": "Fortfahren"
         },
+        "channel_selector": {
+          "title": "Release-Kanal",
+          "subtitle": "Wählen Sie, welchen zugewiesenen Release-Kanal dieses Gerät verwenden soll.",
+          "sidebar_title": "Release",
+          "default": "Standard",
+          "ready": "Bereit",
+          "unavailable": "Nicht bereit",
+          "release_bundle": "Release-Bundle",
+          "frontend_version": "Frontend-Version",
+          "api_version": "API-Version"
+        },
         "common": {
           "yes": "ja",
           "no": "nein",
@@ -604,6 +617,18 @@
         "assignments": {
           "title": "Zuweisungen",
           "subtitle": "Benutzer, Mitarbeiter oder Kunden an Release-Kanäle binden.",
+          "subject": "Subjekt",
+          "subject_message": "Benutzer, Subuser oder Kunden suchen oder ein manuelles Subjekt wie user:42 eingeben.",
+          "subject_placeholder": "Subjekt suchen oder eingeben",
+          "subject_empty": "Keine Subjekte gefunden",
+          "group_users": "Benutzer",
+          "group_subusers": "Subuser",
+          "group_customers": "Kunden",
+          "group_manual": "Manuell",
+          "manual_user": "Benutzer #{id}",
+          "manual_subuser": "Subuser #{id}",
+          "manual_customer": "Kunde #{id}",
+          "manual_description": "Eingegebenen Wert {subject} verwenden",
           "subject_type": "Subjekttyp",
           "subject_type_message": "Identitätstyp zum Binden auswählen.",
           "customer": "Customer",
diff --git a/src/i18n/source/en/phrases/compat/configuration/index.json b/src/i18n/source/en/phrases/compat/configuration/index.json
index 7098e92f..655925b2 100644
--- a/src/i18n/source/en/phrases/compat/configuration/index.json
+++ b/src/i18n/source/en/phrases/compat/configuration/index.json
@@ -430,9 +430,10 @@
           "kicker": "Release Manager",
           "title": "Release channel is not ready",
           "summary_prefix": "Your account is assigned to",
-          "summary_suffix": ", but that channel is missing the configuration needed to load its release image.",
-          "frontend_url": "Frontend URL",
-          "api_url": "API URL",
+          "summary_suffix": ", but that channel is missing an active release bundle.",
+          "release_bundle": "Release bundle",
+          "frontend_version": "Frontend version",
+          "api_version": "API version",
           "checking_again": "Checking again in {seconds}s",
           "refresh_error": "Release status could not be refreshed. The next automatic check will try again.",
           "ignore": "Ignore next 5 minutes",
@@ -445,6 +446,7 @@
           "title": "You are now on {channel}",
           "summary_prefix": "Your account has been assigned to the",
           "summary_suffix": "release channel. This device will remember that you have seen this notice.",
+          "bundle": "Bundle",
           "frontend": "Frontend",
           "api": "API",
           "frontend_version": "Frontend version",
@@ -455,6 +457,17 @@
           "base_image": "Base image",
           "continue": "Continue"
         },
+        "channel_selector": {
+          "title": "Release channel",
+          "subtitle": "Choose which assigned release channel this device should use.",
+          "sidebar_title": "Release",
+          "default": "Default",
+          "ready": "Ready",
+          "unavailable": "Not ready",
+          "release_bundle": "Release bundle",
+          "frontend_version": "Frontend version",
+          "api_version": "API version"
+        },
         "common": {
           "yes": "yes",
           "no": "no",
@@ -604,6 +617,18 @@
         "assignments": {
           "title": "Assignments",
           "subtitle": "Pin users, subusers, or customers to release channels.",
+          "subject": "Subject",
+          "subject_message": "Search users, subusers, or customers, or type a manual subject like user:42.",
+          "subject_placeholder": "Search or type subject",
+          "subject_empty": "No subjects found",
+          "group_users": "Users",
+          "group_subusers": "Subusers",
+          "group_customers": "Customers",
+          "group_manual": "Manual",
+          "manual_user": "User #{id}",
+          "manual_subuser": "Subuser #{id}",
+          "manual_customer": "Customer #{id}",
+          "manual_description": "Use typed value {subject}",
           "subject_type": "Subject type",
           "subject_type_message": "Choose the identity type to pin.",
           "customer": "Customer",
diff --git a/src/i18n/source/global/shared/configuration/index.json b/src/i18n/source/global/shared/configuration/index.json
index 4838cb2a..5f36e2ba 100644
--- a/src/i18n/source/global/shared/configuration/index.json
+++ b/src/i18n/source/global/shared/configuration/index.json
@@ -484,8 +484,9 @@
         "title": "@:{'phrases.compat.configuration.release_manager.channel_unavailable.title'}",
         "summary_prefix": "@:{'phrases.compat.configuration.release_manager.channel_unavailable.summary_prefix'}",
         "summary_suffix": "@:{'phrases.compat.configuration.release_manager.channel_unavailable.summary_suffix'}",
-        "frontend_url": "@:{'phrases.compat.configuration.release_manager.channel_unavailable.frontend_url'}",
-        "api_url": "@:{'phrases.compat.configuration.release_manager.channel_unavailable.api_url'}",
+        "release_bundle": "@:{'phrases.compat.configuration.release_manager.channel_unavailable.release_bundle'}",
+        "frontend_version": "@:{'phrases.compat.configuration.release_manager.channel_unavailable.frontend_version'}",
+        "api_version": "@:{'phrases.compat.configuration.release_manager.channel_unavailable.api_version'}",
         "checking_again": "@:{'phrases.compat.configuration.release_manager.channel_unavailable.checking_again'}",
         "refresh_error": "@:{'phrases.compat.configuration.release_manager.channel_unavailable.refresh_error'}",
         "ignore": "@:{'phrases.compat.configuration.release_manager.channel_unavailable.ignore'}",
@@ -498,6 +499,7 @@
         "title": "@:{'phrases.compat.configuration.release_manager.channel_switched.title'}",
         "summary_prefix": "@:{'phrases.compat.configuration.release_manager.channel_switched.summary_prefix'}",
         "summary_suffix": "@:{'phrases.compat.configuration.release_manager.channel_switched.summary_suffix'}",
+        "bundle": "@:{'phrases.compat.configuration.release_manager.channel_switched.bundle'}",
         "frontend": "@:{'phrases.compat.configuration.release_manager.channel_switched.frontend'}",
         "api": "@:{'phrases.compat.configuration.release_manager.channel_switched.api'}",
         "frontend_version": "@:{'phrases.compat.configuration.release_manager.channel_switched.frontend_version'}",
@@ -508,6 +510,17 @@
         "base_image": "@:{'phrases.compat.configuration.release_manager.channel_switched.base_image'}",
         "continue": "@:{'phrases.compat.configuration.release_manager.channel_switched.continue'}"
       },
+      "channel_selector": {
+        "title": "@:{'phrases.compat.configuration.release_manager.channel_selector.title'}",
+        "subtitle": "@:{'phrases.compat.configuration.release_manager.channel_selector.subtitle'}",
+        "sidebar_title": "@:{'phrases.compat.configuration.release_manager.channel_selector.sidebar_title'}",
+        "default": "@:{'phrases.compat.configuration.release_manager.channel_selector.default'}",
+        "ready": "@:{'phrases.compat.configuration.release_manager.channel_selector.ready'}",
+        "unavailable": "@:{'phrases.compat.configuration.release_manager.channel_selector.unavailable'}",
+        "release_bundle": "@:{'phrases.compat.configuration.release_manager.channel_selector.release_bundle'}",
+        "frontend_version": "@:{'phrases.compat.configuration.release_manager.channel_selector.frontend_version'}",
+        "api_version": "@:{'phrases.compat.configuration.release_manager.channel_selector.api_version'}"
+      },
       "common": {
         "yes": "@:{'phrases.compat.configuration.release_manager.common.yes'}",
         "no": "@:{'phrases.compat.configuration.release_manager.common.no'}",
@@ -657,6 +670,18 @@
       "assignments": {
         "title": "@:{'phrases.compat.configuration.release_manager.assignments.title'}",
         "subtitle": "@:{'phrases.compat.configuration.release_manager.assignments.subtitle'}",
+        "subject": "@:{'phrases.compat.configuration.release_manager.assignments.subject'}",
+        "subject_message": "@:{'phrases.compat.configuration.release_manager.assignments.subject_message'}",
+        "subject_placeholder": "@:{'phrases.compat.configuration.release_manager.assignments.subject_placeholder'}",
+        "subject_empty": "@:{'phrases.compat.configuration.release_manager.assignments.subject_empty'}",
+        "group_users": "@:{'phrases.compat.configuration.release_manager.assignments.group_users'}",
+        "group_subusers": "@:{'phrases.compat.configuration.release_manager.assignments.group_subusers'}",
+        "group_customers": "@:{'phrases.compat.configuration.release_manager.assignments.group_customers'}",
+        "group_manual": "@:{'phrases.compat.configuration.release_manager.assignments.group_manual'}",
+        "manual_user": "@:{'phrases.compat.configuration.release_manager.assignments.manual_user'}",
+        "manual_subuser": "@:{'phrases.compat.configuration.release_manager.assignments.manual_subuser'}",
+        "manual_customer": "@:{'phrases.compat.configuration.release_manager.assignments.manual_customer'}",
+        "manual_description": "@:{'phrases.compat.configuration.release_manager.assignments.manual_description'}",
         "subject_type": "@:{'phrases.compat.configuration.release_manager.assignments.subject_type'}",
         "subject_type_message": "@:{'phrases.compat.configuration.release_manager.assignments.subject_type_message'}",
         "customer": "@:{'phrases.compat.configuration.release_manager.assignments.customer'}",
diff --git a/src/i18n/source/no/phrases/compat/configuration/index.json b/src/i18n/source/no/phrases/compat/configuration/index.json
index 20fe8e7b..d8c287f4 100644
--- a/src/i18n/source/no/phrases/compat/configuration/index.json
+++ b/src/i18n/source/no/phrases/compat/configuration/index.json
@@ -430,9 +430,10 @@
           "kicker": "Release Manager",
           "title": "Release-kanalen er ikke klar",
           "summary_prefix": "Kontoen din er tildelt",
-          "summary_suffix": ", men kanalen mangler konfigurasjonen som trengs for å laste release-imaget.",
-          "frontend_url": "Frontend-URL",
-          "api_url": "API-URL",
+          "summary_suffix": ", men kanalen mangler en aktiv release-bundle.",
+          "release_bundle": "Release-bundle",
+          "frontend_version": "Frontend-versjon",
+          "api_version": "API-versjon",
           "checking_again": "Sjekker igjen om {seconds}s",
           "refresh_error": "Release-status kunne ikke oppdateres. Neste automatiske sjekk prøver igjen.",
           "ignore": "Ignorer de neste 5 minuttene",
@@ -445,6 +446,7 @@
           "title": "Du er nå på {channel}",
           "summary_prefix": "Kontoen din er tildelt release-kanalen",
           "summary_suffix": "Denne enheten husker at du har sett denne meldingen.",
+          "bundle": "Bundle",
           "frontend": "Frontend",
           "api": "API",
           "frontend_version": "Frontend-versjon",
@@ -455,6 +457,17 @@
           "base_image": "Basis-image",
           "continue": "Fortsett"
         },
+        "channel_selector": {
+          "title": "Release-kanal",
+          "subtitle": "Velg hvilken tildelt release-kanal denne enheten skal bruke.",
+          "sidebar_title": "Release",
+          "default": "Standard",
+          "ready": "Klar",
+          "unavailable": "Ikke klar",
+          "release_bundle": "Release-bundle",
+          "frontend_version": "Frontend-versjon",
+          "api_version": "API-versjon"
+        },
         "common": {
           "yes": "ja",
           "no": "nei",
@@ -604,6 +617,18 @@
         "assignments": {
           "title": "Tildelinger",
           "subtitle": "Fest brukere, medarbeidere eller kunder til release-kanaler.",
+          "subject": "Emne",
+          "subject_message": "Søk etter brukere, medarbeidere eller kunder, eller skriv et manuelt emne som user:42.",
+          "subject_placeholder": "Søk eller skriv emne",
+          "subject_empty": "Ingen emner funnet",
+          "group_users": "Brukere",
+          "group_subusers": "Medarbeidere",
+          "group_customers": "Kunder",
+          "group_manual": "Manuell",
+          "manual_user": "Bruker #{id}",
+          "manual_subuser": "Medarbeider #{id}",
+          "manual_customer": "Kunde #{id}",
+          "manual_description": "Bruk inntastet verdi {subject}",
           "subject_type": "Emnetype",
           "subject_type_message": "Vælg identitetstypen, der skal fastgøres.",
           "customer": "Kunde",
diff --git a/src/i18n/source/sv/phrases/compat/configuration/index.json b/src/i18n/source/sv/phrases/compat/configuration/index.json
index a94a8d41..2c887c9d 100644
--- a/src/i18n/source/sv/phrases/compat/configuration/index.json
+++ b/src/i18n/source/sv/phrases/compat/configuration/index.json
@@ -430,9 +430,10 @@
           "kicker": "Release Manager",
           "title": "Release-kanalen är inte klar",
           "summary_prefix": "Ditt konto är tilldelat",
-          "summary_suffix": ", men kanalen saknar konfigurationen som behövs för att läsa in dess release-image.",
-          "frontend_url": "Frontend-URL",
-          "api_url": "API-URL",
+          "summary_suffix": ", men kanalen saknar ett aktivt release-bundle.",
+          "release_bundle": "Release-bundle",
+          "frontend_version": "Frontend-version",
+          "api_version": "API-version",
           "checking_again": "Kontrollerar igen om {seconds}s",
           "refresh_error": "Release-status kunde inte uppdateras. Nästa automatiska kontroll försöker igen.",
           "ignore": "Ignorera de kommande 5 minuterna",
@@ -445,6 +446,7 @@
           "title": "Du är nu på {channel}",
           "summary_prefix": "Ditt konto har tilldelats release-kanalen",
           "summary_suffix": "Den här enheten kommer ihåg att du har sett detta meddelande.",
+          "bundle": "Bundle",
           "frontend": "Frontend",
           "api": "API",
           "frontend_version": "Frontend-version",
@@ -455,6 +457,17 @@
           "base_image": "Bas-image",
           "continue": "Fortsätt"
         },
+        "channel_selector": {
+          "title": "Release-kanal",
+          "subtitle": "Välj vilken tilldelad release-kanal den här enheten ska använda.",
+          "sidebar_title": "Release",
+          "default": "Standard",
+          "ready": "Klar",
+          "unavailable": "Inte klar",
+          "release_bundle": "Release-bundle",
+          "frontend_version": "Frontend-version",
+          "api_version": "API-version"
+        },
         "common": {
           "yes": "ja",
           "no": "nej",
@@ -604,6 +617,18 @@
         "assignments": {
           "title": "Tilldelningar",
           "subtitle": "Fäst användare, medarbetare eller kunder till release-kanaler.",
+          "subject": "Ämne",
+          "subject_message": "Sök efter användare, medarbetare eller kunder, eller skriv ett manuellt ämne som user:42.",
+          "subject_placeholder": "Sök eller skriv ämne",
+          "subject_empty": "Inga ämnen hittades",
+          "group_users": "Användare",
+          "group_subusers": "Medarbetare",
+          "group_customers": "Kunder",
+          "group_manual": "Manuell",
+          "manual_user": "Användare #{id}",
+          "manual_subuser": "Medarbetare #{id}",
+          "manual_customer": "Kund #{id}",
+          "manual_description": "Använd inmatat värde {subject}",
           "subject_type": "Ämnestyp",
           "subject_type_message": "Välj identitetstypen som ska fästas.",
           "customer": "Kunde",
diff --git a/src/services/releaseChannelAvailability.js b/src/services/releaseChannelAvailability.js
index a93ab8cf..4c2f6046 100644
--- a/src/services/releaseChannelAvailability.js
+++ b/src/services/releaseChannelAvailability.js
@@ -3,6 +3,7 @@ import { releaseRuntimeState } from "@/services/releaseTimeline.js";
 
 export const RELEASE_CHANNEL_IGNORE_STORAGE_KEY = "release_channel_unavailable_ignore_until";
 export const RELEASE_CHANNEL_SWITCH_NOTICE_STORAGE_KEY = "release_channel_switch_notice_seen";
+export const RELEASE_CHANNEL_SELECTION_STORAGE_KEY = "release_channel_selected_slug";
 export const RELEASE_CHANNEL_IGNORE_MS = 5 * 60 * 1000;
 export const RELEASE_CHANNEL_CHECK_INTERVAL_MS = 10 * 1000;
 
@@ -56,11 +57,50 @@ const writeSwitchNoticeMap = (map) => {
   }
 };
 
+const normalizeReleaseChannelSlug = (value) => {
+  const slug = String(value || "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "");
+  return slug.slice(0, 64);
+};
+
+const readSelectedChannelSlug = () => {
+  if (typeof window === "undefined") {
+    return "";
+  }
+
+  try {
+    return normalizeReleaseChannelSlug(window.localStorage.getItem(RELEASE_CHANNEL_SELECTION_STORAGE_KEY) || "");
+  } catch {
+    return "";
+  }
+};
+
+const writeSelectedChannelSlug = (slug) => {
+  if (typeof window === "undefined") {
+    return;
+  }
+
+  try {
+    if (slug) {
+      window.localStorage.setItem(RELEASE_CHANNEL_SELECTION_STORAGE_KEY, slug);
+    } else {
+      window.localStorage.removeItem(RELEASE_CHANNEL_SELECTION_STORAGE_KEY);
+    }
+  } catch {
+    // Storage is optional; the runtime endpoint will fall back to the assigned channel.
+  }
+};
+
 const state = reactive({
   now: Date.now(),
   ignoredUntilByChannel: readIgnoreMap(),
   switchNoticeSeenByKey: readSwitchNoticeMap(),
   switchNoticePrincipalKey: "",
+  selectedChannelSlug: readSelectedChannelSlug(),
 });
 
 let clockTimer = null;
@@ -72,7 +112,7 @@ export const setReleaseChannelSwitchNoticePrincipal = (principalKey) => {
 };
 
 export const releaseChannelKey = (channel) => {
-  const slug = String(channel?.slug || "").trim();
+  const slug = normalizeReleaseChannelSlug(channel?.slug || "");
   if (slug) {
     return slug;
   }
@@ -80,39 +120,16 @@ export const releaseChannelKey = (channel) => {
   return id ? `id:${id}` : "";
 };
 
-export const normalizeReleaseUrl = (value) => {
-  const raw = String(value || "").trim();
-  if (!raw) {
-    return "";
-  }
-
-  try {
-    const url = new URL(/^https?:\/\//i.test(raw) ? raw : `https://${raw}`);
-    return `${url.protocol}//${url.host}`;
-  } catch {
-    return raw.replace(/\/+$/, "");
-  }
-};
-
-const runtimeUrl = (runtime, key) => {
-  const camelKey = key === "frontend_base_url" ? "frontendBaseUrl" : "apiBaseUrl";
-  return normalizeReleaseUrl(runtime?.[camelKey] || runtime?.[key] || runtime?.channel?.[key]);
-};
-
 const hasOwn = (value, key) => Boolean(value && Object.prototype.hasOwnProperty.call(value, key));
 
-const hasExplicitRuntimeTargets = (runtime) => {
+const hasExplicitReleaseRuntime = (runtime) => {
   return (
-    hasOwn(runtime, "frontend_base_url") ||
-    hasOwn(runtime, "frontendBaseUrl") ||
-    hasOwn(runtime, "api_base_url") ||
-    hasOwn(runtime, "apiBaseUrl") ||
-    hasOwn(runtime?.channel, "frontend_base_url") ||
-    hasOwn(runtime?.channel, "api_base_url")
+    Boolean(runtime?.availability && typeof runtime.availability === "object" && runtime.availability.explicit !== false) ||
+    hasOwn(runtime, "versions")
   );
 };
 
-const runtimeAvailability = (runtime, frontendBaseUrl, apiBaseUrl) => {
+const runtimeAvailability = (runtime, channel) => {
   if (runtime?.availability && typeof runtime.availability === "object") {
     const missing = Array.isArray(runtime.availability.missing) ? runtime.availability.missing : [];
     const configured =
@@ -126,7 +143,7 @@ const runtimeAvailability = (runtime, frontendBaseUrl, apiBaseUrl) => {
     };
   }
 
-  if (!hasExplicitRuntimeTargets(runtime)) {
+  if (!hasOwn(runtime, "versions")) {
     return {
       configured: true,
       missing: [],
@@ -134,12 +151,26 @@ const runtimeAvailability = (runtime, frontendBaseUrl, apiBaseUrl) => {
     };
   }
 
-  const missing = [];
-  if (!frontendBaseUrl) {
-    missing.push("frontend_base_url");
+  const isDefaultChannel =
+    channel?.default_channel === true || channel?.default_channel === 1 || String(channel?.slug || "") === "stable";
+  if (isDefaultChannel) {
+    return {
+      configured: true,
+      missing: [],
+      status: "ready",
+    };
   }
-  if (!apiBaseUrl) {
-    missing.push("api_base_url");
+
+  const versions = runtime?.versions || {};
+  const missing = [];
+  if (!versions.bundle_id) {
+    missing.push("release_bundle");
+  }
+  if (!versions.frontend) {
+    missing.push("frontend_version");
+  }
+  if (!versions.api) {
+    missing.push("api_version");
   }
 
   return {
@@ -149,19 +180,89 @@ const runtimeAvailability = (runtime, frontendBaseUrl, apiBaseUrl) => {
   };
 };
 
+const channelDisplayName = (channel, fallback = "Release channel") => {
+  const slug = String(channel?.slug || "").trim();
+  return String(channel?.name || slug || fallback).trim();
+};
+
+const normalizeReleaseChannelOption = (entry = {}, runtime = {}) => {
+  const channel = entry?.channel && typeof entry.channel === "object" ? entry.channel : entry;
+  const channelSlug = normalizeReleaseChannelSlug(channel?.slug || "");
+  const channelName = channelDisplayName(channel);
+  const defaultChannel =
+    channel?.default_channel === true || channel?.default_channel === 1 || channelSlug === "stable";
+  const versions =
+    entry?.versions ||
+    (releaseChannelKey(channel) === releaseChannelKey(runtime?.channel) ? runtime?.versions || {} : {});
+  const availability =
+    entry?.availability && typeof entry.availability === "object"
+      ? entry.availability
+      : runtimeAvailability({ channel, versions }, channel);
+
+  return {
+    channel,
+    channelSlug,
+    channelName,
+    defaultChannel,
+    description: channel?.description || "",
+    versions,
+    availability,
+    configured: availability.configured !== false,
+    missing: Array.isArray(availability.missing) ? availability.missing : [],
+    status: availability.status || (availability.configured === false ? "unconfigured" : "ready"),
+  };
+};
+
+export const getReleaseChannelOptions = (runtime = {}) => {
+  const source = Array.isArray(runtime?.availableChannels)
+    ? runtime.availableChannels
+    : Array.isArray(runtime?.available_channels)
+      ? runtime.available_channels
+      : [];
+  const entries = source.length > 0 ? source : runtime?.channel ? [{ channel: runtime.channel }] : [];
+  const optionsByKey = new Map();
+
+  entries.forEach((entry) => {
+    const option = normalizeReleaseChannelOption(entry, runtime);
+    const key = releaseChannelKey(option.channel);
+    if (key && !optionsByKey.has(key)) {
+      optionsByKey.set(key, option);
+    }
+  });
+
+  if (runtime?.channel) {
+    const currentOption = normalizeReleaseChannelOption(
+      {
+        channel: runtime.channel,
+        versions: runtime.versions || {},
+        availability: runtime.availability || null,
+      },
+      runtime
+    );
+    const key = releaseChannelKey(currentOption.channel);
+    if (key && !optionsByKey.has(key)) {
+      optionsByKey.set(key, currentOption);
+    }
+  }
+
+  return [...optionsByKey.values()];
+};
+
+export const hasSelectableReleaseChannels = (runtime = {}) => {
+  const options = getReleaseChannelOptions(runtime);
+  const hasOnlyDefaultStable =
+    options.length === 1 && options[0].defaultChannel === true && options[0].channelSlug === "stable";
+  return options.length > 1 && !hasOnlyDefaultStable;
+};
+
 export const getReleaseChannelUnavailableStatus = (runtime = {}, now = Date.now(), ignoredUntil = 0) => {
   const channel = runtime?.channel || null;
-  const channelSlug = String(channel?.slug || "").trim();
-  const channelName = String(channel?.name || channelSlug || "Release channel").trim();
+  const channelSlug = normalizeReleaseChannelSlug(channel?.slug || "");
+  const channelName = channelDisplayName(channel);
   const isDefaultChannel =
     channel?.default_channel === true || channel?.default_channel === 1 || channelSlug === "stable";
-  const frontendBaseUrl = runtimeUrl(runtime, "frontend_base_url");
-  const apiBaseUrl = runtimeUrl(runtime, "api_base_url");
-  const explicitAvailability =
-    runtime?.availability?.explicit === false
-      ? false
-      : Boolean(runtime?.availability && typeof runtime.availability === "object") || hasExplicitRuntimeTargets(runtime);
-  const availability = runtimeAvailability(runtime, frontendBaseUrl, apiBaseUrl);
+  const explicitAvailability = hasExplicitReleaseRuntime(runtime);
+  const availability = runtimeAvailability(runtime, channel);
   const ignored = Number(ignoredUntil || 0) > now;
   const unavailable = Boolean(channelSlug) && !isDefaultChannel && availability.configured === false;
 
@@ -172,8 +273,6 @@ export const getReleaseChannelUnavailableStatus = (runtime = {}, now = Date.now(
     defaultChannel: isDefaultChannel,
     explicitAvailability,
     description: channel?.description || "",
-    frontendBaseUrl,
-    apiBaseUrl,
     missing: availability.missing,
     configured: availability.configured,
     unavailable,
@@ -191,6 +290,50 @@ export const releaseChannelUnavailableStatus = computed(() => {
   return getReleaseChannelUnavailableStatus(releaseRuntimeState, state.now, ignoredUntil);
 });
 
+export const releaseChannelOptions = computed(() => getReleaseChannelOptions(releaseRuntimeState));
+
+export const releaseChannelSelectorVisible = computed(() => hasSelectableReleaseChannels(releaseRuntimeState));
+
+export const selectedReleaseChannelSlug = computed(() => state.selectedChannelSlug);
+
+export const getSelectedReleaseChannelSlug = () => state.selectedChannelSlug || readSelectedChannelSlug();
+
+export const releaseChannelRuntimeRequestParams = () => {
+  const slug = getSelectedReleaseChannelSlug();
+  return slug ? { release_channel: slug } : {};
+};
+
+export const selectReleaseChannel = (channelOrSlug) => {
+  const slug = normalizeReleaseChannelSlug(
+    typeof channelOrSlug === "string" ? channelOrSlug : channelOrSlug?.slug || channelOrSlug?.channelSlug || ""
+  );
+  state.selectedChannelSlug = slug;
+  writeSelectedChannelSlug(slug);
+  return slug;
+};
+
+export const clearSelectedReleaseChannel = () => {
+  state.selectedChannelSlug = "";
+  writeSelectedChannelSlug("");
+};
+
+export const reconcileSelectedReleaseChannel = (runtime = releaseRuntimeState) => {
+  const hasExplicitOptions =
+    Array.isArray(runtime?.availableChannels) || Array.isArray(runtime?.available_channels);
+  const selected = getSelectedReleaseChannelSlug();
+  if (!hasExplicitOptions || !selected) {
+    return selected;
+  }
+
+  const hasSelectedOption = getReleaseChannelOptions(runtime).some((option) => option.channelSlug === selected);
+  if (!hasSelectedOption) {
+    clearSelectedReleaseChannel();
+    return "";
+  }
+
+  return selected;
+};
+
 export const releaseChannelSwitchNoticeKey = (channel, principalKey = state.switchNoticePrincipalKey) => {
   const channelKey = releaseChannelKey(channel);
   const principal = String(principalKey || "").trim();
@@ -304,47 +447,20 @@ export const stopReleaseChannelAvailabilityClock = () => {
   clockTimer = null;
 };
 
-export const buildReleaseFrontendRedirectUrl = (runtime = releaseRuntimeState, currentLocation = window.location) => {
-  const frontendBaseUrl = runtimeUrl(runtime, "frontend_base_url");
-  if (!frontendBaseUrl || !currentLocation) {
-    return null;
-  }
+export const buildReleaseFrontendRedirectUrl = () => null;
 
-  const target = new URL(frontendBaseUrl);
-  const currentOrigin = currentLocation.origin || `${currentLocation.protocol}//${currentLocation.host}`;
-  if (target.origin === currentOrigin) {
-    return null;
-  }
-
-  target.pathname = currentLocation.pathname || "/";
-  target.search = currentLocation.search || "";
-  target.hash = currentLocation.hash || "";
-  return target.toString();
-};
-
-export const redirectToConfiguredReleaseFrontend = (runtime = releaseRuntimeState) => {
-  const status = getReleaseChannelUnavailableStatus(runtime, Date.now(), 0);
-  if (!status.configured) {
-    return false;
-  }
-
-  const redirectUrl = buildReleaseFrontendRedirectUrl(runtime);
-  if (!redirectUrl) {
-    return false;
-  }
-
-  window.location.assign(redirectUrl);
-  return true;
-};
+export const redirectToConfiguredReleaseFrontend = () => false;
 
 export const __resetReleaseChannelAvailabilityForTests = () => {
   state.now = Date.now();
   state.ignoredUntilByChannel = {};
   state.switchNoticeSeenByKey = {};
   state.switchNoticePrincipalKey = "";
+  state.selectedChannelSlug = "";
   stopReleaseChannelAvailabilityClock();
   if (typeof window !== "undefined") {
     window.localStorage.removeItem(RELEASE_CHANNEL_IGNORE_STORAGE_KEY);
     window.localStorage.removeItem(RELEASE_CHANNEL_SWITCH_NOTICE_STORAGE_KEY);
+    window.localStorage.removeItem(RELEASE_CHANNEL_SELECTION_STORAGE_KEY);
   }
 };
diff --git a/src/services/releaseTimeline.js b/src/services/releaseTimeline.js
index 26cf6166..c9d1731a 100644
--- a/src/services/releaseTimeline.js
+++ b/src/services/releaseTimeline.js
@@ -39,9 +39,11 @@ const readTraceId = () => {
 const releaseRuntimeStateMutable = reactive({
   traceId: readTraceId(),
   channel: null,
+  availableChannels: [],
   versions: {
     frontend: null,
     api: null,
+    bundle_id: null,
   },
   frontendBaseUrl: null,
   apiBaseUrl: null,
@@ -69,16 +71,9 @@ export const releaseRuntimeState = readonly(releaseRuntimeStateMutable);
 
 const hasOwn = (value, key) => Boolean(value && Object.prototype.hasOwnProperty.call(value, key));
 
-const hasExplicitRuntimeTargets = (runtime) => {
-  return (
-    hasOwn(runtime, "frontend_base_url") ||
-    hasOwn(runtime, "frontendBaseUrl") ||
-    hasOwn(runtime, "api_base_url") ||
-    hasOwn(runtime, "apiBaseUrl") ||
-    hasOwn(runtime?.channel, "frontend_base_url") ||
-    hasOwn(runtime?.channel, "api_base_url")
-  );
-};
+const hasExplicitReleaseRuntime = (runtime) =>
+  Boolean(runtime?.availability && typeof runtime.availability === "object" && runtime.availability.explicit !== false) ||
+  hasOwn(runtime, "versions");
 
 export const configureReleaseRuntime = (runtime = {}) => {
   if (!runtime || typeof runtime !== "object") {
@@ -95,32 +90,43 @@ export const configureReleaseRuntime = (runtime = {}) => {
   }
 
   releaseRuntimeStateMutable.channel = runtime.channel || null;
+  releaseRuntimeStateMutable.availableChannels = Array.isArray(runtime.available_channels)
+    ? runtime.available_channels
+    : Array.isArray(runtime.availableChannels)
+      ? runtime.availableChannels
+      : [];
   releaseRuntimeStateMutable.versions = {
     frontend: runtime?.versions?.frontend || null,
     api: runtime?.versions?.api || null,
+    bundle_id: runtime?.versions?.bundle_id || null,
   };
-  const frontendBaseUrl =
-    runtime.frontend_base_url || runtime.frontendBaseUrl || runtime?.channel?.frontend_base_url || null;
-  const apiBaseUrl = runtime.api_base_url || runtime.apiBaseUrl || runtime?.channel?.api_base_url || null;
-  const missingRuntimeTargets = [];
-  if (!frontendBaseUrl) {
-    missingRuntimeTargets.push("frontend_base_url");
+  releaseRuntimeStateMutable.frontendBaseUrl = null;
+  releaseRuntimeStateMutable.apiBaseUrl = null;
+  const channel = runtime.channel || null;
+  const isDefaultChannel =
+    channel?.default_channel === true || channel?.default_channel === 1 || String(channel?.slug || "") === "stable";
+  const missingReleaseContent = [];
+  if (!isDefaultChannel && hasOwn(runtime, "versions")) {
+    if (!runtime?.versions?.bundle_id) {
+      missingReleaseContent.push("release_bundle");
+    }
+    if (!runtime?.versions?.frontend) {
+      missingReleaseContent.push("frontend_version");
+    }
+    if (!runtime?.versions?.api) {
+      missingReleaseContent.push("api_version");
+    }
   }
-  if (!apiBaseUrl) {
-    missingRuntimeTargets.push("api_base_url");
-  }
-  releaseRuntimeStateMutable.frontendBaseUrl = frontendBaseUrl;
-  releaseRuntimeStateMutable.apiBaseUrl = apiBaseUrl;
   releaseRuntimeStateMutable.availability = runtime.availability
     ? {
         ...runtime.availability,
         explicit: true,
       }
-    : hasExplicitRuntimeTargets(runtime)
+    : hasExplicitReleaseRuntime(runtime)
       ? {
-          configured: missingRuntimeTargets.length === 0,
-          missing: missingRuntimeTargets,
-          status: missingRuntimeTargets.length === 0 ? "ready" : "unconfigured",
+          configured: missingReleaseContent.length === 0,
+          missing: missingReleaseContent,
+          status: missingReleaseContent.length === 0 ? "ready" : "unconfigured",
           explicit: true,
         }
       : {
@@ -468,7 +474,8 @@ export const __resetReleaseTimelineForTests = () => {
   customTransport = null;
   releaseRuntimeStateMutable.traceId = "test-trace";
   releaseRuntimeStateMutable.channel = null;
-  releaseRuntimeStateMutable.versions = { frontend: null, api: null };
+  releaseRuntimeStateMutable.availableChannels = [];
+  releaseRuntimeStateMutable.versions = { frontend: null, api: null, bundle_id: null };
   releaseRuntimeStateMutable.frontendBaseUrl = null;
   releaseRuntimeStateMutable.apiBaseUrl = null;
   releaseRuntimeStateMutable.availability = {
diff --git a/src/services/superuserReleases.js b/src/services/superuserReleases.js
index c02eaa51..2d88df8a 100644
--- a/src/services/superuserReleases.js
+++ b/src/services/superuserReleases.js
@@ -169,8 +169,14 @@ export const updateReleaseChannel = (id, payload) =>
 export const rollbackReleaseChannel = (id) =>
   requestReleaseManager(`/superuser/releases/channels/${id}/rollback`, "POST", {});
 
+export const setReleaseChannelBundle = (id, payload) =>
+  requestReleaseManager(`/superuser/releases/channels/${id}/bundle`, "POST", payload);
+
 export const listReleaseAssignments = () => requestReleaseManager("/superuser/releases/assignments", "GET", {});
 
+export const searchReleaseAssignmentSubjects = (params = {}) =>
+  requestReleaseManager("/superuser/releases/assignment-subjects", "GET", params);
+
 export const createReleaseAssignment = (payload) =>
   requestReleaseManager("/superuser/releases/assignments", "POST", payload);
 
diff --git a/src/views/dashboards/superUserDashboard/configuration/ConfigurationReleaseManager.vue b/src/views/dashboards/superUserDashboard/configuration/ConfigurationReleaseManager.vue
index 1c8611d4..4eee8f56 100644
--- a/src/views/dashboards/superUserDashboard/configuration/ConfigurationReleaseManager.vue
+++ b/src/views/dashboards/superUserDashboard/configuration/ConfigurationReleaseManager.vue
@@ -1,5 +1,5 @@
 <script setup>
-import { computed, onBeforeUnmount, onMounted, reactive, ref, watch } from "vue";
+import { computed, onMounted, reactive, ref, watch } from "vue";
 import { BAutocomplete } from "buefy";
 import { useI18n } from "vue-i18n";
 import ActionSettingsWheelButton from "@/components/displays/buttons/ActionSettingsWheelButton.vue";
@@ -8,13 +8,9 @@ import PageTitle from "@/components/global/PageTitle.vue";
 import RestrictedPageWrapper from "@/components/page/wrappers/RestrictedPageWrapper.vue";
 import ConfigurationSubPageWrapper from "@/views/dashboards/superUserDashboard/configuration/ConfigurationSubPageWrapper.vue";
 import ConfigurationError from "@/components/displays/superuser/configuration/ConfigurationError.vue";
+import ReleaseAssignmentSubjectAutocomplete from "@/components/release/ReleaseAssignmentSubjectAutocomplete.vue";
 import ReleaseReplayInspector from "@/components/release/ReleaseReplayInspector.vue";
 import { SessionUser } from "@/components/session/token/SessionUser.vue";
-import {
-  isSearching as isSearchingCustomers,
-  searchCustomer,
-  searchCustomerResults,
-} from "@/components/search/economic/customerSearch.vue";
 import {
   clearReleaseManagerControlApiUrl,
   completeReleaseServiceSetIsolatedDataServices,
@@ -38,6 +34,7 @@ import {
   saveReleaseDeploymentTarget,
   releaseManagerControlApiCandidates,
   startReleaseDeployment,
+  setReleaseChannelBundle,
   setReleaseManagerControlApiUrl,
   testReleaseGithubAccess,
   updateReleaseConfig,
@@ -141,6 +138,10 @@ const bundleAccessResult = ref({
 const releaseFlowStep = ref(0);
 const showAdvancedDeployment = ref(false);
 const createdBundle = ref(null);
+const channelBundleSelection = reactive({
+  channel: null,
+  bundle_id: null,
+});
 
 const releaseConfigForm = reactive({
   github_token: "",
@@ -156,23 +157,19 @@ const channelForm = reactive({
   enabled: true,
   default_channel: false,
   rollout_percent: 0,
-  frontend_base_url: "",
-  api_base_url: "",
   replay_enabled: false,
   capture_level: "metadata",
   retention_days: 14,
 });
 
 const assignmentForm = reactive({
-  subject_type: "user",
+  subject_type: "",
   subject_id: "",
   channel_id: null,
   reason: "",
   expires_at: "",
 });
-const assignmentCustomerSearchQuery = ref("");
-const selectedAssignmentCustomer = ref(null);
-const showAssignmentCustomerResults = ref(false);
+const assignmentSubjectSelection = ref(null);
 
 const targetForm = reactive({
   id: null,
@@ -243,6 +240,7 @@ const targets = computed(() =>
 const deployments = computed(() => (Array.isArray(summary.value?.deployments) ? summary.value.deployments : []));
 const serviceSets = computed(() => (Array.isArray(summary.value?.service_sets) ? summary.value.service_sets : []));
 const bundles = computed(() => (Array.isArray(summary.value?.bundles) ? summary.value.bundles : []));
+const selectedChannelBundleOptions = computed(() => eligibleChannelBundles(channelBundleSelection.channel));
 const moduleHealth = computed(() => (Array.isArray(summary.value?.module_health) ? summary.value.module_health : []));
 const timelineSummary = computed(() => summary.value?.timeline || {});
 const suggestions = computed(() => summary.value?.suggestions || {});
@@ -260,12 +258,6 @@ const branchSuggestions = computed(() =>
     ...githubBranches.value.map((branch) => branch?.name || "").filter(Boolean),
   ])
 );
-const frontendUrlSuggestions = computed(() =>
-  Array.isArray(suggestions.value.frontend_base_urls) ? suggestions.value.frontend_base_urls : []
-);
-const apiUrlSuggestions = computed(() =>
-  Array.isArray(suggestions.value.api_base_urls) ? suggestions.value.api_base_urls : []
-);
 const healthUrlSuggestions = computed(() =>
   Array.isArray(suggestions.value.health_urls) ? suggestions.value.health_urls : []
 );
@@ -447,17 +439,12 @@ const canContinueReleaseFlow = computed(() => {
   }
   return true;
 });
-const isCustomerAssignmentSubject = computed(() => assignmentForm.subject_type === "customer");
 const canSubmitAssignment = computed(() => {
   if (!canManage.value) {
     return false;
   }
 
-  if (!isCustomerAssignmentSubject.value) {
-    return true;
-  }
-
-  return String(assignmentForm.subject_id || "").trim() !== "";
+  return Boolean(String(assignmentForm.subject_type || "").trim() && String(assignmentForm.subject_id || "").trim());
 });
 
 const stats = computed(() => [
@@ -553,82 +540,18 @@ async function submitReleaseSettingsGuide() {
   }
 }
 
-function positiveIntegerFromDigits(value) {
-  const text = String(value ?? "").trim();
-  if (!/^\d+$/.test(text)) {
-    return null;
-  }
-
-  const parsed = Number.parseInt(text, 10);
-  return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+function selectAssignmentSubject(subject) {
+  assignmentSubjectSelection.value = subject || null;
+  assignmentForm.subject_type = subject?.subject_type || "";
+  assignmentForm.subject_id = subject?.subject_id || "";
 }
 
-function normalizeAssignmentCustomer(customer) {
-  const customerNumber = positiveIntegerFromDigits(
-    customer?.customerNumber ?? customer?.customer_number ?? customer?.customer_id
-  );
-  if (!customerNumber) {
-    return null;
+function clearAssignmentSubject(resetSelection = false) {
+  if (resetSelection) {
+    assignmentSubjectSelection.value = null;
   }
-
-  return {
-    customerNumber,
-    name: customer?.name ?? customer?.customer_name ?? `#${customerNumber}`,
-  };
-}
-
-function assignmentCustomerLabel(customer) {
-  const normalizedCustomer = normalizeAssignmentCustomer(customer);
-  if (!normalizedCustomer) {
-    return "";
-  }
-
-  return `${normalizedCustomer.name} (${normalizedCustomer.customerNumber})`;
-}
-
-function resetAssignmentCustomerSearch() {
-  assignmentCustomerSearchQuery.value = "";
-  selectedAssignmentCustomer.value = null;
-  showAssignmentCustomerResults.value = false;
-  searchCustomer(null);
-}
-
-async function onAssignmentCustomerSearchInput() {
-  const query = assignmentCustomerSearchQuery.value.trim();
-
-  if (selectedAssignmentCustomer.value && query !== assignmentCustomerLabel(selectedAssignmentCustomer.value)) {
-    selectedAssignmentCustomer.value = null;
-  }
-
-  assignmentForm.subject_id = positiveIntegerFromDigits(query)?.toString() || "";
-
-  if (!query) {
-    showAssignmentCustomerResults.value = false;
-    searchCustomer(null);
-    return;
-  }
-
-  showAssignmentCustomerResults.value = true;
-  await searchCustomer(query);
-}
-
-function selectAssignmentCustomer(customer) {
-  const normalizedCustomer = normalizeAssignmentCustomer(customer);
-  if (!normalizedCustomer) {
-    return;
-  }
-
-  selectedAssignmentCustomer.value = normalizedCustomer;
-  assignmentForm.subject_id = normalizedCustomer.customerNumber.toString();
-  assignmentCustomerSearchQuery.value = assignmentCustomerLabel(normalizedCustomer);
-  showAssignmentCustomerResults.value = false;
-  searchCustomer(null);
-}
-
-function hideAssignmentCustomerResults() {
-  window.setTimeout(() => {
-    showAssignmentCustomerResults.value = false;
-  }, 200);
+  assignmentForm.subject_type = "";
+  assignmentForm.subject_id = "";
 }
 
 function syncControlApiUrl() {
@@ -744,31 +667,6 @@ function healthUrlForBaseUrl(app, value) {
   return `${baseUrl}${app === "api" ? "/ping" : "/health"}`;
 }
 
-function channelUrlOptions(kind) {
-  const app = kind === "api" ? "api" : "frontend";
-  const query = kind === "api" ? channelForm.api_base_url : channelForm.frontend_base_url;
-  const options = autocompleteOptions(kind === "api" ? apiUrlSuggestions.value : frontendUrlSuggestions.value, query, {
-    category: kind === "api" ? tr("autocomplete.api_url") : tr("autocomplete.frontend_url"),
-    description: tr("autocomplete.known_release_url"),
-    icon: kind === "api" ? "fas fa-server" : "fas fa-window-maximize",
-  });
-  const deployUrl = baseUrlFromValue(query || options[0]?.value || "");
-  const deployDomain = loadBalancerDomainValue(deployUrl);
-  if (deployUrl && deployDomain && coolifyInstances.value.length > 0 && canDeploy.value) {
-    options.unshift({
-      value: deployUrl,
-      title: tr("autocomplete.deploy_here_with_coolify", { app: valueLabel("app", app) }),
-      description: tr("autocomplete.prepare_coolify_target"),
-      category: tr("autocomplete.coolify_ssl"),
-      action: "coolify_ssl",
-      app,
-      icon: "fas fa-cloud-upload-alt",
-      tag: "SSL",
-    });
-  }
-  return options.slice(0, 9);
-}
-
 function repositoryOptions(query) {
   return autocompleteOptions(repositorySuggestions.value, query, {
     category: tr("autocomplete.github_repository"),
@@ -905,21 +803,6 @@ function controlApiOptions() {
   });
 }
 
-function selectChannelUrl(kind, option) {
-  if (!option) {
-    return;
-  }
-  const value = baseUrlFromValue(optionValue(option));
-  if (kind === "api") {
-    channelForm.api_base_url = value;
-  } else {
-    channelForm.frontend_base_url = value;
-  }
-  if (option.action === "coolify_ssl") {
-    prepareCoolifySslTarget(kind === "api" ? "api" : "frontend", value);
-  }
-}
-
 function selectTargetField(field, option) {
   if (!option) {
     return;
@@ -1018,8 +901,6 @@ function applyChannelPreset(preset) {
     enabled: true,
     default_channel: Boolean(preset.default_channel),
     rollout_percent: Number(preset.rollout_percent || 0),
-    frontend_base_url: firstAvailable(frontendUrlSuggestions.value),
-    api_base_url: firstAvailable(apiUrlSuggestions.value),
     replay_enabled: Boolean(preset.replay_enabled),
     capture_level: preset.capture_level || "metadata",
     retention_days: Number(preset.retention_days || 14),
@@ -1051,11 +932,7 @@ function applyTargetPreset(preset) {
 }
 
 function applyUrlSuggestion(kind, value) {
-  if (kind === "frontend") {
-    channelForm.frontend_base_url = value;
-  } else if (kind === "api") {
-    channelForm.api_base_url = value;
-  } else {
+  if (kind === "health") {
     targetForm.health_url = value;
   }
 }
@@ -1303,6 +1180,40 @@ function bundleApp(bundle, app) {
   return bundle?.apps?.[app] || {};
 }
 
+function channelVersionLabel(channel, app) {
+  const version = channel?.versions?.[app] || null;
+  return version?.version_label || version?.commit_sha || "--";
+}
+
+function channelActiveBundleLabel(channel) {
+  const bundleId = channel?.versions?.bundle_id;
+  return bundleId ? `#${bundleId}` : "--";
+}
+
+function channelVersionSummary(channel) {
+  return `${tr("tables.frontend")}: ${channelVersionLabel(channel, "frontend")} / ${tr("tables.api")}: ${channelVersionLabel(channel, "api")}`;
+}
+
+function eligibleChannelBundles(channel) {
+  if (!channel?.id) {
+    return [];
+  }
+  const eligibleStatuses = new Set(["deployed", "promoted", "active"]);
+  return bundles.value.filter(
+    (bundle) => Number(bundle.channel_id) === Number(channel.id) && eligibleStatuses.has(String(bundle.status || "").toLowerCase())
+  );
+}
+
+function openSetChannelBundle(channel) {
+  channelBundleSelection.channel = channel;
+  channelBundleSelection.bundle_id = channel?.versions?.bundle_id || eligibleChannelBundles(channel)[0]?.id || null;
+}
+
+function clearSetChannelBundle() {
+  channelBundleSelection.channel = null;
+  channelBundleSelection.bundle_id = null;
+}
+
 function selectedBundleChannel() {
   return (
     channels.value.find((channel) => Number(channel.id) === Number(bundleForm.channel_id)) ||
@@ -1684,8 +1595,6 @@ function editChannel(channel) {
     enabled: Boolean(channel.enabled),
     default_channel: Boolean(channel.default_channel),
     rollout_percent: Number(channel.rollout_percent || 0),
-    frontend_base_url: channel.frontend_base_url || "",
-    api_base_url: channel.api_base_url || "",
     replay_enabled: Boolean(channel.replay_enabled),
     capture_level: channel.capture_level || "metadata",
     retention_days: Number(channel.retention_days || 14),
@@ -1702,8 +1611,6 @@ function resetChannelForm() {
     enabled: true,
     default_channel: false,
     rollout_percent: 0,
-    frontend_base_url: "",
-    api_base_url: "",
     replay_enabled: false,
     capture_level: "metadata",
     retention_days: 14,
@@ -1724,14 +1631,14 @@ async function saveChannel() {
 }
 
 async function saveAssignment() {
-  if (isCustomerAssignmentSubject.value && !assignmentForm.subject_id) {
+  if (!assignmentForm.subject_type || !assignmentForm.subject_id) {
     return;
   }
 
   await run("assignment:save", async () => {
     await createReleaseAssignment({ ...assignmentForm });
-    Object.assign(assignmentForm, { subject_id: "", reason: "", expires_at: "" });
-    resetAssignmentCustomerSearch();
+    Object.assign(assignmentForm, { subject_type: "", subject_id: "", reason: "", expires_at: "" });
+    clearAssignmentSubject(true);
     await load();
   });
 }
@@ -1844,6 +1751,20 @@ async function rollbackChannel(channel) {
   });
 }
 
+async function saveChannelBundleSelection() {
+  const channel = channelBundleSelection.channel;
+  const bundleId = Number(channelBundleSelection.bundle_id || 0);
+  if (!channel?.id || !bundleId) {
+    return;
+  }
+
+  await run(`channel:${channel.id}:bundle`, async () => {
+    await setReleaseChannelBundle(channel.id, { bundle_id: bundleId });
+    clearSetChannelBundle();
+    await load();
+  });
+}
+
 async function run(key, callback) {
   busy.value = key;
   errors.value = [];
@@ -1886,11 +1807,11 @@ function canDeployBundle(bundle) {
   if (!canDeploy.value) {
     return false;
   }
-  return !["promoted", "queued", "deploying"].includes(normalizedBundleStatus(bundle));
+  return !["queued", "deploying"].includes(normalizedBundleStatus(bundle));
 }
 
 function bundleDeployLabel(bundle) {
-  return ["active", "deployed"].includes(normalizedBundleStatus(bundle))
+  return ["active", "deployed", "promoted"].includes(normalizedBundleStatus(bundle))
     ? trFallback("actions.redeploy", "Redeploy")
     : tr("actions.deploy");
 }
@@ -1941,22 +1862,6 @@ watch(
   }
 );
 
-watch(
-  () => assignmentForm.subject_type,
-  (subjectType) => {
-    showAssignmentCustomerResults.value = false;
-    searchCustomer(null);
-
-    if (subjectType === "customer") {
-      assignmentCustomerSearchQuery.value = assignmentForm.subject_id ? String(assignmentForm.subject_id) : "";
-      selectedAssignmentCustomer.value = null;
-      return;
-    }
-
-    resetAssignmentCustomerSearch();
-  }
-);
-
 watch(
   () => targetForm.repository,
   (repository) => {
@@ -2058,10 +1963,6 @@ watch(
   );
 });
 
-onBeforeUnmount(() => {
-  searchCustomer(null);
-});
-
 onMounted(async () => {
   await load();
   await loadReleaseConfig();
@@ -2247,8 +2148,8 @@ onMounted(async () => {
                   <tr>
                     <th>{{ tr("tables.channel") }}</th>
                     <th>{{ tr("tables.rollout") }}</th>
-                    <th>{{ tr("tables.frontend") }}</th>
-                    <th>{{ tr("tables.api") }}</th>
+                    <th>{{ trFallback("tables.bundle", "Bundle") }}</th>
+                    <th>{{ trFallback("tables.versions", "Versions") }}</th>
                     <th>{{ tr("tables.replay") }}</th>
                     <th class="release-action-cell">{{ tr("tables.actions") }}</th>
                   </tr>
@@ -2260,8 +2161,8 @@ onMounted(async () => {
                       <div class="release-muted">{{ channel.slug }}</div>
                     </td>
                     <td>{{ channel.rollout_percent }}%</td>
-                    <td>{{ channel.versions?.frontend?.version_label || "--" }}</td>
-                    <td>{{ channel.versions?.api?.version_label || "--" }}</td>
+                    <td>{{ channelActiveBundleLabel(channel) }}</td>
+                    <td>{{ channelVersionSummary(channel) }}</td>
                     <td>
                       <b-tag :class="statusClass(channel.capture_level)">
                         {{ channel.replay_enabled ? valueLabel("capture_level", channel.capture_level) : tr("common.off") }}
@@ -2273,6 +2174,12 @@ onMounted(async () => {
                         :data-testid="`release-channel-actions-${channel.id}`"
                       >
                         <template #actions>
+                          <ActionSettingsWheelItem
+                            icon="fas fa-layer-group"
+                            :label="trFallback('actions.set_bundle', 'Set bundle')"
+                            :click-action="() => openSetChannelBundle(channel)"
+                            :disabled="!canDeploy || eligibleChannelBundles(channel).length === 0"
+                          />
                           <ActionSettingsWheelItem
                             icon="fas fa-edit"
                             :label="tr('actions.edit')"
@@ -2292,6 +2199,46 @@ onMounted(async () => {
               </table>
             </div>
 
+            <div
+              v-if="channelBundleSelection.channel"
+              class="release-inline-panel mt-3"
+              data-testid="release-channel-bundle-picker"
+            >
+              <div data-testid="release-channel-bundle-summary">
+                <strong>{{ trFallback("channels.set_bundle", "Set channel bundle") }}</strong>
+                <p class="release-muted">
+                  {{ channelBundleSelection.channel.name }} / {{ channelBundleSelection.channel.slug }}
+                </p>
+              </div>
+              <b-field :label="trFallback('tables.bundle', 'Bundle')">
+                <b-select v-model.number="channelBundleSelection.bundle_id" expanded data-testid="release-channel-bundle-select">
+                  <option
+                    v-for="bundle in selectedChannelBundleOptions"
+                    :key="bundle.id"
+                    :value="bundle.id"
+                  >
+                    #{{ bundle.id }} {{ bundle.version_label || "--" }} / {{ statusLabel(bundle.status) }}
+                  </option>
+                </b-select>
+              </b-field>
+              <div class="release-form-actions">
+                <b-button
+                  type="is-dark"
+                  icon-left="save"
+                  icon-pack="fas"
+                  data-testid="release-channel-bundle-save"
+                  :disabled="!channelBundleSelection.bundle_id || !canDeploy"
+                  :loading="busy === `channel:${channelBundleSelection.channel.id}:bundle`"
+                  @click="saveChannelBundleSelection"
+                >
+                  {{ trFallback("actions.set_bundle", "Set bundle") }}
+                </b-button>
+                <b-button icon-left="times" icon-pack="fas" @click="clearSetChannelBundle">
+                  {{ t("common.cancel") }}
+                </b-button>
+              </div>
+            </div>
+
             <div class="table-container mt-3">
               <table class="table is-fullwidth is-hoverable">
                 <thead>
@@ -2360,54 +2307,6 @@ onMounted(async () => {
                   placeholder="5"
                 />
               </b-field>
-              <b-field :label="tr('channels.frontend_url')" :message="tr('channels.frontend_url_message')">
-                <BAutocomplete
-                  v-model="channelForm.frontend_base_url"
-                  :data="channelUrlOptions('frontend')"
-                  field="value"
-                  :placeholder="tr('channels.frontend_url_placeholder')"
-                  open-on-focus
-                  keep-first
-                  expanded
-                  @select="(option) => selectChannelUrl('frontend', option)"
-                >
-                  <template #default="slotProps">
-                    <div class="release-autocomplete-option" :class="{ 'is-action': slotProps.option.action }">
-                      <i :class="slotProps.option.icon" aria-hidden="true"></i>
-                      <span>
-                        <strong>{{ slotProps.option.title }}</strong>
-                        <small>{{ slotProps.option.description }}</small>
-                      </span>
-                      <b-tag v-if="slotProps.option.tag" type="is-info">{{ slotProps.option.tag }}</b-tag>
-                    </div>
-                  </template>
-                  <template #empty>{{ tr("channels.no_matching_release_url") }}</template>
-                </BAutocomplete>
-              </b-field>
-              <b-field :label="tr('channels.api_url')" :message="tr('channels.api_url_message')">
-                <BAutocomplete
-                  v-model="channelForm.api_base_url"
-                  :data="channelUrlOptions('api')"
-                  field="value"
-                  :placeholder="tr('channels.api_url_placeholder')"
-                  open-on-focus
-                  keep-first
-                  expanded
-                  @select="(option) => selectChannelUrl('api', option)"
-                >
-                  <template #default="slotProps">
-                    <div class="release-autocomplete-option" :class="{ 'is-action': slotProps.option.action }">
-                      <i :class="slotProps.option.icon" aria-hidden="true"></i>
-                      <span>
-                        <strong>{{ slotProps.option.title }}</strong>
-                        <small>{{ slotProps.option.description }}</small>
-                      </span>
-                      <b-tag v-if="slotProps.option.tag" type="is-info">{{ slotProps.option.tag }}</b-tag>
-                    </div>
-                  </template>
-                  <template #empty>{{ tr("channels.no_matching_api_url") }}</template>
-                </BAutocomplete>
-              </b-field>
               <b-field :label="tr('channels.replay_capture')" :message="tr('channels.replay_capture_message')">
                 <b-select v-model="channelForm.capture_level" expanded>
                   <option value="metadata">{{ valueLabel("capture_level", "metadata") }}</option>
@@ -2437,26 +2336,6 @@ onMounted(async () => {
               </div>
             </form>
 
-            <div class="release-chip-row mt-3">
-              <b-button
-                v-for="url in frontendUrlSuggestions"
-                :key="`frontend-${url}`"
-                size="is-small"
-                type="is-light"
-                @click="applyUrlSuggestion('frontend', url)"
-              >
-                {{ tr("channels.frontend_chip", { url }) }}
-              </b-button>
-              <b-button
-                v-for="url in apiUrlSuggestions"
-                :key="`api-${url}`"
-                size="is-small"
-                type="is-light"
-                @click="applyUrlSuggestion('api', url)"
-              >
-                {{ tr("channels.api_chip", { url }) }}
-              </b-button>
-            </div>
           </ConfigurationCategory>
 
           <ConfigurationCategory
@@ -2483,65 +2362,11 @@ onMounted(async () => {
             </div>
 
             <form class="release-form" data-testid="release-assignment-form" @submit.prevent="saveAssignment">
-              <b-field :label="tr('assignments.subject_type')" :message="tr('assignments.subject_type_message')">
-                <b-select v-model="assignmentForm.subject_type" expanded data-testid="release-assignment-subject-type">
-                  <option value="user">{{ valueLabel("subject_type", "user") }}</option>
-                  <option value="subuser">{{ valueLabel("subject_type", "subuser") }}</option>
-                  <option value="customer">{{ valueLabel("subject_type", "customer") }}</option>
-                </b-select>
-              </b-field>
-              <div v-if="isCustomerAssignmentSubject" class="release-customer-search">
-                <b-field :label="tr('assignments.customer')" :message="tr('assignments.customer_message')">
-                  <b-input
-                    v-model="assignmentCustomerSearchQuery"
-                    :placeholder="tr('assignments.customer_placeholder')"
-                    autocomplete="off"
-                    required
-                    icon="search"
-                    icon-pack="fas"
-                    :loading="isSearchingCustomers"
-                    data-testid="release-assignment-customer-search"
-                    @input="onAssignmentCustomerSearchInput"
-                    @focus="showAssignmentCustomerResults = assignmentCustomerSearchQuery.trim() !== ''"
-                    @blur="hideAssignmentCustomerResults"
-                  />
-                </b-field>
-                <div
-                  v-if="
-                    showAssignmentCustomerResults &&
-                    assignmentCustomerSearchQuery.trim() &&
-                    searchCustomerResults.length > 0
-                  "
-                  class="release-customer-search__results"
-                  data-testid="release-assignment-customer-results"
-                >
-                  <button
-                    v-for="customer in searchCustomerResults"
-                    :key="customer.customerNumber || customer.customer_number"
-                    class="release-customer-search__result"
-                    type="button"
-                    :data-testid="`release-assignment-customer-option-${
-                      customer.customerNumber || customer.customer_number
-                    }`"
-                    @mousedown.prevent
-                    @click="selectAssignmentCustomer(customer)"
-                  >
-                    <span class="icon is-small">
-                      <i class="fas fa-user"></i>
-                    </span>
-                    <span>
-                      <strong>{{ customer.name || customer.customer_name }}</strong>
-                      <small>#{{ customer.customerNumber || customer.customer_number }}</small>
-                    </span>
-                  </button>
-                </div>
-              </div>
-              <b-field v-else :label="tr('assignments.subject_id')" :message="tr('assignments.subject_id_message')">
-                <b-input
-                  v-model="assignmentForm.subject_id"
-                  :placeholder="tr('assignments.subject_id_placeholder')"
-                  required
-                  data-testid="release-assignment-subject-id"
+              <b-field :label="tr('assignments.subject')" :message="tr('assignments.subject_message')">
+                <ReleaseAssignmentSubjectAutocomplete
+                  :model-value="assignmentSubjectSelection"
+                  @update:model-value="selectAssignmentSubject"
+                  @clear="clearAssignmentSubject(false)"
                 />
               </b-field>
               <b-field :label="tr('assignments.channel')" :message="tr('assignments.channel_message')">
@@ -3953,6 +3778,27 @@ onMounted(async () => {
   padding: 0.875rem;
 }
 
+.release-inline-panel {
+  align-items: start;
+  background: #ffffff;
+  border: 1px solid #d8dee8;
+  border-radius: 6px;
+  display: grid;
+  gap: 0.875rem;
+  grid-template-columns: minmax(180px, 0.8fr) minmax(220px, 1fr) auto;
+  padding: 0.875rem;
+}
+
+.release-inline-panel > .field {
+  margin-bottom: 0;
+}
+
+@media (max-width: 768px) {
+  .release-inline-panel {
+    grid-template-columns: 1fr;
+  }
+}
+
 .release-service-set-card {
   display: grid;
   gap: 0.65rem;
@@ -4228,56 +4074,6 @@ onMounted(async () => {
   margin-bottom: 0;
 }
 
-.release-customer-search {
-  min-width: 0;
-  position: relative;
-}
-
-.release-customer-search__results {
-  background: #ffffff;
-  border: 1px solid #d8dee8;
-  border-radius: 6px;
-  box-shadow: 0 12px 26px rgba(23, 32, 51, 0.14);
-  left: 0;
-  margin-top: 0.35rem;
-  max-height: min(16rem, 42vh);
-  overflow-y: auto;
-  position: absolute;
-  right: 0;
-  z-index: 40;
-}
-
-.release-customer-search__result {
-  align-items: center;
-  background: #ffffff;
-  border: 0;
-  color: #172033;
-  cursor: pointer;
-  display: grid;
-  gap: 0.5rem;
-  grid-template-columns: auto minmax(0, 1fr);
-  min-height: 2.75rem;
-  padding: 0.55rem 0.75rem;
-  text-align: left;
-  width: 100%;
-}
-
-.release-customer-search__result:hover,
-.release-customer-search__result:focus-visible {
-  background: #f7fafc;
-}
-
-.release-customer-search__result strong,
-.release-customer-search__result small {
-  display: block;
-  overflow-wrap: anywhere;
-}
-
-.release-customer-search__result small {
-  color: #667085;
-  font-size: 0.8rem;
-}
-
 .release-autocomplete-option {
   align-items: start;
   display: grid;
diff --git a/tests/e2e/release-channel-switched.spec.js b/tests/e2e/release-channel-switched.spec.js
index 0b0f389c..a662ffff 100644
--- a/tests/e2e/release-channel-switched.spec.js
+++ b/tests/e2e/release-channel-switched.spec.js
@@ -1,9 +1,7 @@
 import { expect, test } from "@playwright/test";
 import { mockApi, seedAuthenticatedState } from "./support/network.js";
 
-const baseUrl = process.env.PLAYWRIGHT_BASE_URL || "http://127.0.0.1:5173";
-
-const availableRuntime = (frontendBaseUrl) => ({
+const availableRuntime = () => ({
   generated_at: "2026-05-19T09:30:00.000Z",
   trace_id: "trace-switched-channel",
   channel: {
@@ -13,15 +11,12 @@ const availableRuntime = (frontendBaseUrl) => ({
     description: "Early production validation before broader rollout.",
     enabled: true,
     default_channel: false,
-    frontend_base_url: frontendBaseUrl,
-    api_base_url: "https://api-canary.example.test",
   },
   versions: {
     frontend: { version_label: "frontend-canary", commit_sha: "c0ffee" },
     api: { version_label: "api-canary", commit_sha: "feedface" },
+    bundle_id: 31,
   },
-  frontend_base_url: frontendBaseUrl,
-  api_base_url: "https://api-canary.example.test",
   availability: {
     configured: true,
     missing: [],
@@ -49,7 +44,7 @@ async function boot(page) {
       id: 77,
       customer_number: 990077,
       runtime_config: {
-        release: availableRuntime(baseUrl),
+        release: availableRuntime(),
       },
     },
   });
@@ -61,14 +56,17 @@ test("users assigned to a configured release channel see the switched notice onc
 
   await page.goto("/user", { waitUntil: "domcontentloaded" });
   const notice = page.getByTestId("release-channel-switched-page");
-  await expect(notice).toBeVisible();
+  await expect(notice).toBeVisible({ timeout: 30_000 });
   await expect(notice).toContainText("You are now on Canary");
   await expect(notice).toContainText("Early production validation");
+  await expect(page.getByTestId("release-channel-switched-details")).toContainText("#31");
   await expect(page.getByTestId("release-channel-switched-details")).toContainText("frontend-canary");
   await expect(page.getByTestId("release-channel-switched-details")).toContainText("api-canary");
 
+  const currentUrl = page.url();
   await page.getByTestId("release-channel-switched-continue").click();
   await expect(notice).toHaveCount(0);
+  await expect(page).toHaveURL(currentUrl);
 
   await page.goto("/user", { waitUntil: "domcontentloaded" });
   await expect(page.getByTestId("release-channel-switched-page")).toHaveCount(0);
diff --git a/tests/e2e/release-channel-unavailable.spec.js b/tests/e2e/release-channel-unavailable.spec.js
index 6b40da3c..e7283a1c 100644
--- a/tests/e2e/release-channel-unavailable.spec.js
+++ b/tests/e2e/release-channel-unavailable.spec.js
@@ -17,15 +17,11 @@ const unavailableRuntime = {
     description: "Early production validation before broader rollout.",
     enabled: true,
     default_channel: false,
-    frontend_base_url: null,
-    api_base_url: null,
   },
-  versions: { frontend: null, api: null },
-  frontend_base_url: null,
-  api_base_url: null,
+  versions: { frontend: null, api: null, bundle_id: null },
   availability: {
     configured: false,
-    missing: ["frontend_base_url", "api_base_url"],
+    missing: ["release_bundle", "frontend_version", "api_version"],
     status: "unconfigured",
   },
   capture_policy: {
@@ -36,15 +32,13 @@ const unavailableRuntime = {
   },
 };
 
-const availableRuntime = (frontendBaseUrl) => ({
+const availableRuntime = () => ({
   ...unavailableRuntime,
-  channel: {
-    ...unavailableRuntime.channel,
-    frontend_base_url: frontendBaseUrl,
-    api_base_url: "https://api-canary.example.test",
+  versions: {
+    frontend: { version_label: "frontend-canary", commit_sha: "c0ffee" },
+    api: { version_label: "api-canary", commit_sha: "feedface" },
+    bundle_id: 31,
   },
-  frontend_base_url: frontendBaseUrl,
-  api_base_url: "https://api-canary.example.test",
   availability: {
     configured: true,
     missing: [],
@@ -81,8 +75,9 @@ test("users assigned to an unconfigured release channel can ignore the guard tem
   await expect(guard).toBeVisible();
   await expect(guard).toContainText("Release channel is not ready");
   await expect(guard).toContainText("Canary");
-  await expect(page.getByTestId("release-channel-missing")).toContainText("Frontend URL");
-  await expect(page.getByTestId("release-channel-missing")).toContainText("API URL");
+  await expect(page.getByTestId("release-channel-missing")).toContainText("Release bundle");
+  await expect(page.getByTestId("release-channel-missing")).toContainText("Frontend version");
+  await expect(page.getByTestId("release-channel-missing")).toContainText("API version");
   await expect(page.getByTestId("release-channel-next-check")).toContainText("Checking again in");
 
   await page.getByTestId("release-channel-ignore").click();
@@ -129,7 +124,9 @@ test("users assigned to an unconfigured release channel can check again when it
   const guard = page.getByTestId("release-channel-unavailable-page");
   await expect(guard).toBeVisible();
 
-  releaseRuntime = availableRuntime(new URL(page.url()).origin);
+  const currentUrl = page.url();
+  releaseRuntime = availableRuntime();
   await page.getByTestId("release-channel-check-again").click();
   await expect(guard).toHaveCount(0);
+  await expect(page).toHaveURL(currentUrl);
 });
diff --git a/tests/e2e/release-manager.spec.js b/tests/e2e/release-manager.spec.js
index 46e2403d..f3af8bf0 100644
--- a/tests/e2e/release-manager.spec.js
+++ b/tests/e2e/release-manager.spec.js
@@ -32,6 +32,7 @@ function createReleaseState() {
     nextServiceSetId: 2,
     nextBundleId: 1,
     nextCoolifyTargetId: 20,
+    assignmentPayloads: [],
     channels: [
       {
         id: 1,
@@ -365,6 +366,71 @@ function channelSlug(state, id) {
   return state.channels.find((channel) => Number(channel.id) === Number(id))?.slug || "stable";
 }
 
+function addDeployedBundle(state, overrides = {}) {
+  const serviceSet = state.serviceSets[0];
+  const channelId = Number(overrides.channel_id || serviceSet?.channel_id || 2);
+  const id = state.nextBundleId++;
+  const bundle = {
+    id,
+    channel_id: channelId,
+    channel_slug: channelSlug(state, channelId),
+    service_set_id: serviceSet?.id || 1,
+    service_set_name: serviceSet?.name || "Service set",
+    version_label: overrides.version_label || "stable-bundle-2026-05-19",
+    status: "deployed",
+    apps: {
+      frontend: {
+        version_id: id * 10 + 1,
+        deployment_id: null,
+        repository: "truckwash/front-end-vue",
+        branch: DEFAULT_RELEASE_BRANCH,
+        commit_sha: "c0ffee",
+      },
+      api: {
+        version_id: id * 10 + 2,
+        deployment_id: null,
+        repository: "truckwash/backend-php",
+        branch: "release/canary",
+        commit_sha: "feedface",
+      },
+    },
+  };
+  state.bundles.unshift(bundle);
+  return bundle;
+}
+
+function setActiveBundle(state, bundle) {
+  if (!bundle) return null;
+  for (const entry of state.bundles) {
+    if (
+      Number(entry.channel_id) === Number(bundle.channel_id) &&
+      Number(entry.id) !== Number(bundle.id) &&
+      entry.status === "promoted"
+    ) {
+      entry.status = "superseded";
+    }
+  }
+  for (const set of state.serviceSets) {
+    set.active = Number(set.id) === Number(bundle.service_set_id);
+  }
+  bundle.status = "promoted";
+  const channel = state.channels.find((entry) => Number(entry.id) === Number(bundle.channel_id));
+  if (channel) {
+    channel.versions = {
+      frontend: {
+        version_label: bundle.version_label,
+        commit_sha: bundle.apps?.frontend?.commit_sha || "",
+      },
+      api: {
+        version_label: bundle.version_label,
+        commit_sha: bundle.apps?.api?.commit_sha || "",
+      },
+      bundle_id: bundle.id,
+    };
+  }
+  return channel;
+}
+
 function isolatedDataService(state, kind, stackName = "isolated-stack") {
   const id = state.nextCoolifyTargetId++;
   return {
@@ -414,9 +480,13 @@ async function boot(page, state = createReleaseState()) {
       runtime_config: {
         release: {
           trace_id: "trace-e2e",
-          channel: { slug: "canary", name: "Canary" },
-          versions: { frontend: { version_label: "frontend-canary" } },
-          capture_policy: { enabled: true, capture_level: "full_redacted" },
+          channel: { slug: "stable", name: "Stable", default_channel: true },
+          versions: {
+            frontend: { version_label: "frontend-2026.05.19", commit_sha: "abc123" },
+            api: { version_label: "api-2026.05.19", commit_sha: "def456" },
+          },
+          availability: { configured: true, missing: [], status: "ready" },
+          capture_policy: { enabled: true, capture_level: "metadata" },
         },
       },
     },
@@ -456,6 +526,51 @@ async function installReleaseMocks(page, state) {
       return;
     }
 
+    if (pathname.endsWith("/superuser/releases/assignment-subjects") && method === "GET") {
+      const query = (url.searchParams.get("search") || "").toLowerCase();
+      const limit = Math.max(1, Math.min(10, Number(url.searchParams.get("limit") || 5)));
+      const subjects = [
+        {
+          subject_type: "user",
+          subject_id: "42",
+          label: "Acme Dispatcher - Customer #424242 / dispatcher@example.test",
+          title: "Acme Dispatcher",
+          description: "Customer #424242 / dispatcher@example.test",
+          icon: "fas fa-user",
+          source: "users",
+        },
+        {
+          subject_type: "subuser",
+          subject_id: "77",
+          label: "Driver Alex - @driveralex / driver@example.test",
+          title: "Driver Alex",
+          description: "@driveralex / driver@example.test",
+          icon: "fas fa-id-badge",
+          source: "subusers",
+        },
+        {
+          subject_type: "customer",
+          subject_id: "424242",
+          label: "Acme Transport - Customer #424242",
+          title: "Acme Transport",
+          description: "Customer #424242",
+          icon: "fas fa-building",
+          source: "customers",
+        },
+      ].filter((subject) => {
+        if (!query) return true;
+        return [subject.subject_type, subject.subject_id, subject.label, subject.title, subject.description].some(
+          (value) =>
+            String(value || "")
+              .toLowerCase()
+              .includes(query)
+        );
+      });
+
+      await route.fulfill(json({ data: subjects.slice(0, limit) }));
+      return;
+    }
+
     if (pathname.endsWith("/superuser/releases/config") && method === "GET") {
       await route.fulfill(
         json({
@@ -636,8 +751,24 @@ async function installReleaseMocks(page, state) {
       return;
     }
 
+    if (/\/superuser\/releases\/channels\/\d+\/bundle$/.test(pathname) && method === "POST") {
+      const channelId = Number(pathname.match(/channels\/(\d+)\/bundle/)?.[1] || 0);
+      const payload = request.postDataJSON?.() || {};
+      const bundle = state.bundles.find(
+        (entry) => Number(entry.id) === Number(payload.bundle_id) && Number(entry.channel_id) === channelId
+      );
+      if (!bundle || !["deployed", "promoted", "active"].includes(bundle.status)) {
+        await route.fulfill(json({ message: "Only deployed release bundles can be set on a channel." }, 409));
+        return;
+      }
+      const channel = setActiveBundle(state, bundle);
+      await route.fulfill(json({ data: { channel, versions: channel?.versions || {}, bundle } }));
+      return;
+    }
+
     if (pathname.endsWith("/superuser/releases/assignments") && method === "POST") {
       const payload = request.postDataJSON?.() || {};
+      state.assignmentPayloads.push(payload);
       const assignment = {
         ...payload,
         id: state.nextAssignmentId++,
@@ -817,22 +948,8 @@ async function installReleaseMocks(page, state) {
     if (/\/superuser\/releases\/bundles\/\d+\/promote$/.test(pathname) && method === "POST") {
       const id = Number(pathname.match(/bundles\/(\d+)\/promote/)?.[1] || 0);
       const bundle = state.bundles.find((entry) => entry.id === id);
-      if (bundle) {
-        for (const entry of state.bundles) {
-          if (
-            Number(entry.channel_id) === Number(bundle.channel_id) &&
-            Number(entry.id) !== Number(bundle.id) &&
-            entry.status === "promoted"
-          ) {
-            entry.status = "superseded";
-          }
-        }
-        for (const set of state.serviceSets) {
-          set.active = Number(set.id) === Number(bundle.service_set_id);
-        }
-        bundle.status = "promoted";
-      }
-      await route.fulfill(json({ data: { bundle } }));
+      const channel = setActiveBundle(state, bundle);
+      await route.fulfill(json({ data: { channel, versions: channel?.versions || {}, bundle } }));
       return;
     }
 
@@ -951,8 +1068,42 @@ async function selectReleaseTab(page, name) {
     .click();
 }
 
+test("channel bundle picker keeps summary, field, and actions aligned", async ({ page }) => {
+  const state = createReleaseState();
+  addDeployedBundle(state, { channel_id: 2 });
+  await boot(page, state);
+  await page.goto("/superuser/configuration/releases", { waitUntil: "domcontentloaded" });
+
+  await expect(page.getByTestId("release-manager-page")).toBeVisible({ timeout: 30_000 });
+  const channelRow = page
+    .getByTestId("release-channels-overview")
+    .locator("tbody tr")
+    .filter({ hasText: "Canary" })
+    .first();
+  await channelRow.locator('[data-testid^="release-channel-actions-"] button').first().click();
+  await page.getByRole("button", { name: "Set bundle" }).click();
+
+  const channelBundlePicker = page.getByTestId("release-channel-bundle-picker");
+  await expect(channelBundlePicker).toBeVisible();
+  await expect(channelBundlePicker.getByRole("button", { name: "Cancel" })).toBeVisible();
+  if ((page.viewportSize()?.width || 0) > 768) {
+    const [summaryBox, labelBox, selectBox, saveBox] = await Promise.all([
+      page.getByTestId("release-channel-bundle-summary").boundingBox(),
+      channelBundlePicker.locator(".field > .label").first().boundingBox(),
+      page.getByTestId("release-channel-bundle-select").boundingBox(),
+      page.getByTestId("release-channel-bundle-save").boundingBox(),
+    ]);
+    expect(summaryBox).toBeTruthy();
+    expect(labelBox).toBeTruthy();
+    expect(selectBox).toBeTruthy();
+    expect(saveBox).toBeTruthy();
+    expect(Math.abs(summaryBox.y - labelBox.y)).toBeLessThanOrEqual(4);
+    expect(Math.abs(selectBox.y - saveBox.y)).toBeLessThanOrEqual(4);
+  }
+});
+
 test("superusers manage release channels, assignments, deployments, and replay", async ({ page }) => {
-  await boot(page);
+  const state = await boot(page);
   await page.goto("/superuser/configuration/releases", { waitUntil: "domcontentloaded" });
 
   await expect(page.getByTestId("release-manager-page")).toBeVisible({ timeout: 30_000 });
@@ -986,6 +1137,8 @@ test("superusers manage release channels, assignments, deployments, and replay",
   await expandActiveReleaseCategory(page);
   await page.getByTestId("release-channel-presets").getByText("Internal").click();
   await expect(page.getByTestId("release-channel-form").getByPlaceholder("slug")).toHaveValue("internal");
+  await expect(page.getByTestId("release-channel-form")).not.toContainText("Frontend URL");
+  await expect(page.getByTestId("release-channel-form")).not.toContainText("API URL");
   await page.getByTestId("release-channel-form").getByRole("button", { name: "Create" }).click();
 
   await selectReleaseTab(page, "Overview");
@@ -993,17 +1146,39 @@ test("superusers manage release channels, assignments, deployments, and replay",
 
   await selectReleaseTab(page, "Assignments");
   await expandActiveReleaseCategory(page);
-  await page.getByTestId("release-assignment-subject-type").selectOption("customer");
-  await page.getByTestId("release-assignment-customer-search").fill("Acme");
-  await expect(page.getByTestId("release-assignment-customer-results")).toContainText("Acme Transport");
-  await expect(page.getByTestId("release-assignment-customer-search")).toBeFocused();
-  await page.getByTestId("release-assignment-customer-option-424242").click();
-  await expect(page.getByTestId("release-assignment-customer-search")).toHaveValue("Acme Transport (424242)");
+  const assignmentSubjectInput = page.getByTestId("release-assignment-subject-search");
+  await assignmentSubjectInput.fill("Acme");
+  await expect(page.getByTestId("release-assignment-subject-group-user")).toContainText("Users");
+  await expect(page.getByTestId("release-assignment-subject-option-user-42")).toContainText("Acme Dispatcher");
+  await expect(page.getByTestId("release-assignment-subject-group-customer")).toContainText("Customers");
+  await expect(page.getByTestId("release-assignment-subject-option-customer-424242")).toContainText("Acme Transport");
+  await assignmentSubjectInput.fill("Driver");
+  await expect(page.getByTestId("release-assignment-subject-group-subuser")).toContainText("Subusers");
+  await expect(page.getByTestId("release-assignment-subject-option-subuser-77")).toContainText("Driver Alex");
+  await assignmentSubjectInput.fill("Acme");
+  await page.getByTestId("release-assignment-subject-option-customer-424242").click();
+  await expect(assignmentSubjectInput).toHaveValue("Acme Transport - Customer #424242");
   await page.getByTestId("release-assignment-form").getByRole("button", { name: "Assign" }).click();
+  expect(state.assignmentPayloads[state.assignmentPayloads.length - 1]).toMatchObject({
+    subject_type: "customer",
+    subject_id: "424242",
+  });
   await expect(page.getByTestId("release-assignments-table")).toContainText("customer:424242");
   await expect(
     page.getByTestId("release-assignments-table").locator('[data-testid^="release-assignment-actions-"]').first()
   ).toBeVisible();
+  await assignmentSubjectInput.fill("909");
+  await expect(page.getByTestId("release-assignment-subject-group-manual")).toContainText("Manual");
+  await expect(page.getByTestId("release-assignment-subject-manual-user-909")).toContainText("User #909");
+  await expect(page.getByTestId("release-assignment-subject-manual-subuser-909")).toContainText("Subuser #909");
+  await expect(page.getByTestId("release-assignment-subject-manual-customer-909")).toContainText("Customer #909");
+  await page.getByTestId("release-assignment-subject-manual-subuser-909").click();
+  await page.getByTestId("release-assignment-form").getByRole("button", { name: "Assign" }).click();
+  expect(state.assignmentPayloads[state.assignmentPayloads.length - 1]).toMatchObject({
+    subject_type: "subuser",
+    subject_id: "909",
+  });
+  await expect(page.getByTestId("release-assignments-table")).toContainText("subuser:909");
 
   await selectReleaseTab(page, "Integrations");
   await expandActiveReleaseCategory(page);
@@ -1047,11 +1222,14 @@ test("superusers manage release channels, assignments, deployments, and replay",
   await expect(bundleFlow.getByPlaceholder(DEFAULT_RELEASE_BRANCH).nth(1)).toHaveValue(DEFAULT_RELEASE_BRANCH);
   await expect(bundleFlow.getByText("Container image")).toHaveCount(0);
   await bundleFlow.getByRole("button", { name: "Next" }).click();
-  await expect(page.getByTestId("release-bundle-review-stack")).toContainText("Frontend");
-  await expect(page.getByTestId("release-bundle-review-stack")).toContainText("PHP backend");
-  await expect(page.getByTestId("release-bundle-review-stack")).toContainText("Database");
-  await expect(page.getByTestId("release-bundle-review-stack")).toContainText("Redis");
-  await expect(page.getByTestId("release-bundle-review-stack")).toContainText("Minio");
+  const bundleReviewStack = page.getByTestId("release-bundle-review-stack");
+  await expect(bundleReviewStack).toBeVisible();
+  const bundleReviewText = await bundleReviewStack.textContent();
+  expect(bundleReviewText).toContain("Frontend");
+  expect(bundleReviewText).toContain("PHP backend");
+  expect(bundleReviewText).toContain("Database");
+  expect(bundleReviewText).toContain("Redis");
+  expect(bundleReviewText).toContain("Minio");
   await page.getByTestId("release-bundle-deploy-submit").click();
   await expect(page.getByTestId("release-created-bundle")).toContainText("Bundle deployed");
   await expect(page.getByTestId("release-bundles-table")).toContainText("truckwash/front-end-vue");
@@ -1059,6 +1237,10 @@ test("superusers manage release channels, assignments, deployments, and replay",
   await expect(
     page.getByTestId("release-bundles-table").locator('[data-testid^="release-bundle-actions-"]').first()
   ).toBeVisible();
+  const createdBundle = state.bundles[0];
+  const createdBundleChannel = state.channels.find(
+    (channel) => Number(channel.id) === Number(createdBundle.channel_id)
+  );
   const deployedBundleRow = page.getByTestId("release-bundles-table").locator("tbody tr").first();
   await deployedBundleRow.locator('[data-testid^="release-bundle-actions-"] button').first().click();
   await expect(deployedBundleRow.getByRole("button", { name: "Redeploy" })).toBeEnabled();
@@ -1073,6 +1255,21 @@ test("superusers manage release channels, assignments, deployments, and replay",
   await failedDeploymentRow.locator('[data-testid^="release-deployment-actions-"] button').first().click();
   await expect(failedDeploymentRow.getByRole("button", { name: "Promote" })).toBeDisabled();
 
+  await page.keyboard.press("Escape");
+  await selectReleaseTab(page, "Overview");
+  const channelRow = page
+    .getByTestId("release-channels-overview")
+    .locator("tbody tr")
+    .filter({ hasText: createdBundleChannel.name })
+    .first();
+  await channelRow.locator('[data-testid^="release-channel-actions-"] button').first().click();
+  await page.getByRole("button", { name: "Set bundle" }).click();
+  await expect(page.getByTestId("release-channel-bundle-picker")).toBeVisible();
+  await page.getByTestId("release-channel-bundle-select").selectOption(String(createdBundle.id));
+  await page.getByTestId("release-channel-bundle-save").click();
+  await expect(page.getByTestId("release-channels-overview")).toContainText(`#${createdBundle.id}`);
+  expect(createdBundleChannel.versions.bundle_id).toBe(createdBundle.id);
+
   await selectReleaseTab(page, "Replay");
   await expandActiveReleaseCategory(page);
   await page.getByTestId("release-replay-form").getByPlaceholder("Target id or channel slug").fill("42");
diff --git a/tests/unit/release-channel-availability.spec.js b/tests/unit/release-channel-availability.spec.js
index ffbe1a03..fa5b4e38 100644
--- a/tests/unit/release-channel-availability.spec.js
+++ b/tests/unit/release-channel-availability.spec.js
@@ -4,11 +4,17 @@ import {
   acknowledgeReleaseChannelSwitch,
   buildReleaseFrontendRedirectUrl,
   getReleaseChannelSwitchedStatus,
+  getReleaseChannelOptions,
   getReleaseChannelUnavailableStatus,
+  hasSelectableReleaseChannels,
   ignoreUnavailableReleaseChannel,
+  reconcileSelectedReleaseChannel,
   RELEASE_CHANNEL_IGNORE_MS,
   RELEASE_CHANNEL_IGNORE_STORAGE_KEY,
+  RELEASE_CHANNEL_SELECTION_STORAGE_KEY,
   RELEASE_CHANNEL_SWITCH_NOTICE_STORAGE_KEY,
+  releaseChannelRuntimeRequestParams,
+  selectReleaseChannel,
   __resetReleaseChannelAvailabilityForTests,
 } from "@/services/releaseChannelAvailability.js";
 
@@ -20,19 +26,25 @@ const canaryRuntime = {
     description: "Early validation channel",
     default_channel: false,
   },
-  frontend_base_url: "",
-  api_base_url: "",
+  versions: {
+    frontend: null,
+    api: null,
+    bundle_id: null,
+  },
   availability: {
     configured: false,
-    missing: ["frontend_base_url", "api_base_url"],
+    missing: ["release_bundle", "frontend_version", "api_version"],
     status: "unconfigured",
   },
 };
 
 const configuredCanaryRuntime = {
   ...canaryRuntime,
-  frontend_base_url: "https://canary.example.test",
-  api_base_url: "https://api-canary.example.test",
+  versions: {
+    frontend: { version_label: "frontend-canary", commit_sha: "c0ffee" },
+    api: { version_label: "api-canary", commit_sha: "feedface" },
+    bundle_id: 31,
+  },
   availability: {
     configured: true,
     missing: [],
@@ -50,7 +62,7 @@ describe("release channel availability", () => {
 
     expect(status.shouldBlock).toBe(true);
     expect(status.channelSlug).toBe("canary");
-    expect(status.missing).toEqual(["frontend_base_url", "api_base_url"]);
+    expect(status.missing).toEqual(["release_bundle", "frontend_version", "api_version"]);
   });
 
   it("does not block the stable default channel even when runtime targets are absent", () => {
@@ -62,7 +74,7 @@ describe("release channel availability", () => {
       },
       availability: {
         configured: false,
-        missing: ["frontend_base_url"],
+        missing: ["release_bundle"],
       },
     });
 
@@ -70,6 +82,86 @@ describe("release channel availability", () => {
     expect(status.shouldBlock).toBe(false);
   });
 
+  it("exposes selectable runtime channels when a non-default assignment is available", () => {
+    const runtime = {
+      channel: configuredCanaryRuntime.channel,
+      versions: configuredCanaryRuntime.versions,
+      availability: configuredCanaryRuntime.availability,
+      availableChannels: [
+        {
+          channel: {
+            slug: "stable",
+            name: "Stable",
+            default_channel: true,
+          },
+          availability: {
+            configured: true,
+            missing: [],
+            status: "ready",
+          },
+        },
+        {
+          channel: configuredCanaryRuntime.channel,
+          versions: configuredCanaryRuntime.versions,
+          availability: configuredCanaryRuntime.availability,
+        },
+      ],
+    };
+
+    const options = getReleaseChannelOptions(runtime);
+
+    expect(options.map((option) => option.channelSlug)).toEqual(["stable", "canary"]);
+    expect(hasSelectableReleaseChannels(runtime)).toBe(true);
+  });
+
+  it("hides the selector when only the default stable channel is available", () => {
+    expect(
+      hasSelectableReleaseChannels({
+        channel: {
+          slug: "stable",
+          name: "Stable",
+          default_channel: true,
+        },
+        availableChannels: [
+          {
+            channel: {
+              slug: "stable",
+              name: "Stable",
+              default_channel: true,
+            },
+          },
+        ],
+      })
+    ).toBe(false);
+  });
+
+  it("stores the selected release channel for runtime refresh requests", () => {
+    const selectedSlug = selectReleaseChannel({ slug: "canary" });
+
+    expect(selectedSlug).toBe("canary");
+    expect(window.localStorage.getItem(RELEASE_CHANNEL_SELECTION_STORAGE_KEY)).toBe("canary");
+    expect(releaseChannelRuntimeRequestParams()).toEqual({ release_channel: "canary" });
+  });
+
+  it("clears a stored selection when the runtime no longer offers that channel", () => {
+    selectReleaseChannel("canary");
+
+    const selectedSlug = reconcileSelectedReleaseChannel({
+      availableChannels: [
+        {
+          channel: {
+            slug: "stable",
+            name: "Stable",
+            default_channel: true,
+          },
+        },
+      ],
+    });
+
+    expect(selectedSlug).toBe("");
+    expect(window.localStorage.getItem(RELEASE_CHANNEL_SELECTION_STORAGE_KEY)).toBeNull();
+  });
+
   it("does not block legacy runtime payloads that omit availability and target URLs", () => {
     const runtime = {
       channel: {
@@ -134,12 +226,15 @@ describe("release channel availability", () => {
     expect(anonymousStatus.shouldShow).toBe(false);
   });
 
-  it("builds a same-path redirect for a configured channel frontend", () => {
+  it("does not build a channel-specific frontend redirect", () => {
     const redirectUrl = buildReleaseFrontendRedirectUrl(
       {
         channel: { slug: "beta", default_channel: false },
-        frontend_base_url: "https://beta.example.test",
-        api_base_url: "https://api-beta.example.test",
+        versions: {
+          frontend: { version_label: "frontend-beta" },
+          api: { version_label: "api-beta" },
+          bundle_id: 52,
+        },
       },
       {
         origin: "https://app.example.test",
@@ -149,6 +244,6 @@ describe("release channel availability", () => {
       }
     );
 
-    expect(redirectUrl).toBe("https://beta.example.test/user/bookings?page=2#next");
+    expect(redirectUrl).toBeNull();
   });
 });
diff --git a/tests/unit/release-channel-selector.spec.js b/tests/unit/release-channel-selector.spec.js
new file mode 100644
index 00000000..d377a291
--- /dev/null
+++ b/tests/unit/release-channel-selector.spec.js
@@ -0,0 +1,71 @@
+// @vitest-environment jsdom
+import { afterEach, describe, expect, it } from "vitest";
+import { mount } from "@vue/test-utils";
+import i18n from "@/i18n";
+import ReleaseChannelSelector from "@/components/release/ReleaseChannelSelector.vue";
+import { __resetReleaseChannelAvailabilityForTests } from "@/services/releaseChannelAvailability.js";
+import { configureReleaseRuntime, __resetReleaseTimelineForTests } from "@/services/releaseTimeline.js";
+
+const configureSelectableChannels = () => {
+  configureReleaseRuntime({
+    channel: {
+      slug: "stable",
+      name: "Stable",
+      default_channel: true,
+    },
+    available_channels: [
+      {
+        channel: {
+          slug: "stable",
+          name: "Stable",
+          default_channel: true,
+        },
+        availability: {
+          configured: true,
+          missing: [],
+          status: "ready",
+        },
+      },
+      {
+        channel: {
+          slug: "canary",
+          name: "Canary",
+          default_channel: false,
+        },
+        availability: {
+          configured: false,
+          missing: ["release_bundle"],
+          status: "unconfigured",
+        },
+      },
+    ],
+  });
+};
+
+describe("ReleaseChannelSelector", () => {
+  afterEach(() => {
+    __resetReleaseChannelAvailabilityForTests();
+    __resetReleaseTimelineForTests();
+  });
+
+  it("renders available release channels and emits the selected channel", async () => {
+    configureSelectableChannels();
+    i18n.global.locale.value = "en";
+
+    const wrapper = mount(ReleaseChannelSelector, {
+      global: {
+        plugins: [i18n],
+      },
+    });
+
+    expect(wrapper.find('[data-testid="release-channel-selector"]').exists()).toBe(true);
+    expect(wrapper.text()).toContain("Stable");
+    expect(wrapper.text()).toContain("Canary");
+    expect(wrapper.text()).toContain("Release bundle");
+
+    await wrapper.find('[data-testid="release-channel-option-canary"]').trigger("click");
+
+    expect(wrapper.emitted("select")).toHaveLength(1);
+    expect(wrapper.emitted("select")[0][0].channelSlug).toBe("canary");
+  });
+});
diff --git a/tests/unit/release-timeline.spec.js b/tests/unit/release-timeline.spec.js
index 8b70e5b2..ae216044 100644
--- a/tests/unit/release-timeline.spec.js
+++ b/tests/unit/release-timeline.spec.js
@@ -30,13 +30,16 @@ describe("release timeline runtime", () => {
     configureReleaseRuntime({
       trace_id: "trace-123",
       channel: { slug: "canary", name: "Canary" },
-      versions: { frontend: { version_label: "abc123" }, api: null },
+      available_channels: [{ channel: { slug: "stable", name: "Stable", default_channel: true } }],
+      versions: { frontend: { version_label: "abc123" }, api: null, bundle_id: 31 },
       capture_policy: { enabled: true, capture_level: "full_redacted", retention_days: 7 },
     });
 
     expect(releaseRuntimeState.channel.slug).toBe("canary");
+    expect(releaseRuntimeState.availableChannels).toHaveLength(1);
     expect(releaseRuntimeState.traceId).toBe("trace-123");
     expect(releaseRuntimeState.versions.frontend.version_label).toBe("abc123");
+    expect(releaseRuntimeState.versions.bundle_id).toBe(31);
   });
 
   it("redacts sensitive payload keys recursively", () => {