diff --git a/frontend/src/components/ExpertButton.vue b/frontend/src/components/ExpertButton.vue
index 4bbbda9d21..546b8f9d02 100644
--- a/frontend/src/components/ExpertButton.vue
+++ b/frontend/src/components/ExpertButton.vue
@@ -56,7 +56,7 @@ export default {
             return this.featuresCheck.isAiFeatureEnabled
         },
         showExpertButton () {
-            return this.isAiEnabled && !this.isExpertDrawerOpen
+            return this.isAiEnabled && !this.isExpertDrawerOpen && !this.rightDrawer.expertSuppressed
         },
         showMcpToggle () {
             return this.isAiEnabled && this.featuresCheck.isMcpThirdPartyFeatureEnabled
@@ -260,6 +260,11 @@ export default {
         color: var(--ff-color-text-default);
     }
 
+    &:only-child {
+        border-left: none;
+        border-radius: 5px;
+    }
+
     &--waiting {
         /* The -dot token, not -text: this is a standalone indicator, not text on a tinted pill */
         color: var(--ff-color-status-warning-dot);
diff --git a/frontend/src/components/expert/components/ExpertChatInput.vue b/frontend/src/components/expert/components/ExpertChatInput.vue
index c609d2d027..d99d942308 100644
--- a/frontend/src/components/expert/components/ExpertChatInput.vue
+++ b/frontend/src/components/expert/components/ExpertChatInput.vue
@@ -1,6 +1,7 @@
 <template>
     <div ref="resizeTarget" class="ff-expert-input" :style="containerStyle">
         <resize-bar
+            v-if="expertSurface !== 'overview'"
             :is-resizing="isInputResizing"
             direction="horizontal"
             @mousedown="onStartResize"
@@ -247,6 +248,7 @@ export default {
         },
         showSuggestions () {
             if (this.expertSurface === 'onboarding') return false
+            if (this.expertSurface === 'overview') return false
             if (this.isInsightsAgent) return false
             if (this.suggestionUsed || this.suggestions.length === 0) return false
             if (this.inputText.length > 0 || this.hasUserTurns) return false
diff --git a/frontend/src/pages/team/Home/Expert/index.vue b/frontend/src/pages/team/Home/Expert/index.vue
new file mode 100644
index 0000000000..708420bb21
--- /dev/null
+++ b/frontend/src/pages/team/Home/Expert/index.vue
@@ -0,0 +1,318 @@
+<template>
+    <ff-page>
+        <template #header>
+            <ff-page-header>
+                <template #breadcrumbs>
+                    <ff-nav-breadcrumb>Home</ff-nav-breadcrumb>
+                </template>
+            </ff-page-header>
+        </template>
+
+        <div
+            class="ff-expert-home"
+            data-el="expert-home"
+            :class="{ 'is-composing': stage !== 'idle', 'is-conversing': stage === 'conversing' }"
+            :data-stage="stage"
+        >
+            <ff-button
+                kind="tertiary"
+                size="small"
+                class="ff-expert-home__back"
+                data-action="collapse-expert"
+                @click="stage = 'idle'"
+            >
+                <template #icon-left>
+                    <ChevronLeftIcon />
+                </template>
+                Back
+            </ff-button>
+
+            <div v-if="canSwitchAgent" class="ff-expert-home__mode" data-el="expert-home-mode">
+                <ExpertModeSwitcher />
+            </div>
+
+            <div
+                class="ff-expert-home__expert"
+                data-el="expert-home-surface"
+                @input="onComposerInput"
+            >
+                <ExpertPanel />
+            </div>
+
+            <ff-button
+                v-if="canResume"
+                kind="tertiary"
+                size="small"
+                class="ff-expert-home__resume"
+                data-action="resume-conversation"
+                @click="stage = 'conversing'"
+            >
+                <span v-if="liveTurns > 0">
+                    Continue your conversation
+                    <span class="ff-expert-home__resume-count">
+                        · {{ liveTurns }} {{ liveTurns === 1 ? 'message' : 'messages' }}
+                    </span>
+                </span>
+                <span v-else>Open the Expert</span>
+            </ff-button>
+        </div>
+    </ff-page>
+</template>
+
+<script setup lang="ts">
+import { ChevronLeftIcon } from '@heroicons/vue/20/solid'
+import { computed, onBeforeUnmount, onMounted, provide, ref, watch } from 'vue'
+
+import ExpertPanel from '@/components/expert/Expert.vue'
+import ExpertModeSwitcher from '@/components/expert/components/ExpertModeSwitcher.vue'
+import { useAccountSettingsStore } from '@/stores/account-settings.js'
+import { useContextStore } from '@/stores/context.js'
+import { SUPPORT_AGENT } from '@/stores/product-expert-agents.js'
+import { useProductExpertStore } from '@/stores/product-expert.js'
+import { useUxDrawersStore } from '@/stores/ux-drawers.js'
+
+defineOptions({ name: 'TeamHomeExpert' })
+
+provide('expert-surface', 'overview')
+
+const contextStore = useContextStore()
+const settingsStore = useAccountSettingsStore()
+const expertStore = useProductExpertStore() as ReturnType<typeof useProductExpertStore> & {
+    messages: { _type: string }[]
+    isWaitingForResponse: boolean
+    isSessionExpired: boolean
+    isInsightsAgent: boolean
+    hasSelectedCapabilities: boolean
+}
+const drawersStore = useUxDrawersStore()
+
+const canSwitchAgent = computed<boolean>(() => {
+    const features = settingsStore.featuresCheck
+    return !!features.isExpertAssistantFeatureEnabled && !!features.isExpertInsightsFeatureEnabled
+})
+
+type Stage = 'idle' | 'composing' | 'conversing'
+
+const stage = ref<Stage>('idle')
+const liveTurns = computed<number>(() => expertStore.messages.filter(message => message._type === 'human').length)
+
+const canResume = computed<boolean>(() =>
+    liveTurns.value > 0 ||
+    expertStore.isWaitingForResponse ||
+    expertStore.isSessionExpired ||
+    (expertStore.isInsightsAgent && !expertStore.hasSelectedCapabilities)
+)
+
+function onComposerInput () {
+    if (stage.value === 'idle') {
+        stage.value = 'composing'
+    }
+}
+
+watch(liveTurns, (now: number, before: number) => {
+    if (now > before) {
+        stage.value = 'conversing'
+    }
+})
+
+onMounted(() => {
+    const features = settingsStore.featuresCheck
+    if (features.isExpertAssistantFeatureEnabled && !features.isExpertInsightsFeatureEnabled) {
+        expertStore.setAgentMode(SUPPORT_AGENT)
+    }
+    expertStore.resumeSessionTimer()
+    drawersStore.suppressExpertDrawer()
+    if (drawersStore.rightDrawer.state) {
+        drawersStore.closeRightDrawer({ preserveExpertState: true })
+    }
+})
+
+onBeforeUnmount(() => {
+    drawersStore.releaseExpertDrawer()
+    if (!contextStore.isImmersiveEditor && drawersStore.rightDrawer.expertState.open) {
+        expertStore.openAssistantDrawer({ openPinned: drawersStore.rightDrawer.expertState.pinned })
+    }
+})
+</script>
+
+<style scoped lang="scss">
+
+$ff-expand: 480ms;
+$ff-ease: cubic-bezier(0.4, 0, 0.2, 1);
+$ff-column: 820px;
+
+.ff-expert-home {
+    display: flex;
+    flex-direction: column;
+    flex: 1;
+    min-height: 0;
+    padding: 24px 22px 28px;
+    position: relative;
+
+    &__back {
+        position: absolute;
+        top: 0;
+        left: 0;
+        z-index: 1;
+        transition: opacity 220ms ease, visibility 220ms;
+    }
+
+    &:not(.is-composing) &__back {
+        opacity: 0;
+        visibility: hidden;
+        pointer-events: none;
+    }
+
+    &__resume {
+        align-self: center;
+        min-height: 0;
+        margin-top: 14px;
+        max-height: 6rem;
+        overflow: hidden;
+        transition: max-height $ff-expand $ff-ease, opacity 220ms ease,
+                    margin-top $ff-expand $ff-ease, padding $ff-expand $ff-ease,
+                    visibility $ff-expand;
+    }
+
+    &__resume-count {
+        color: var(--ff-color-text-subtle);
+    }
+
+    &.is-conversing &__resume {
+        max-height: 0;
+        padding-top: 0;
+        padding-bottom: 0;
+        margin-top: 0;
+        opacity: 0;
+        visibility: hidden;
+        pointer-events: none;
+    }
+
+    &__mode {
+        align-self: center;
+        display: flex;
+        justify-content: center;
+        width: 100%;
+        max-width: $ff-column;
+        max-height: 0;
+        margin-bottom: 0;
+        opacity: 0;
+        visibility: hidden;
+        overflow: hidden;
+        pointer-events: none;
+        transition: max-height $ff-expand $ff-ease, opacity 220ms ease,
+                    margin-bottom $ff-expand $ff-ease, visibility $ff-expand;
+    }
+
+    &.is-conversing &__mode {
+        max-height: 6rem;
+        margin-bottom: 10px;
+        opacity: 1;
+        visibility: visible;
+        pointer-events: auto;
+    }
+
+    &__expert {
+        display: flex;
+        flex-direction: column;
+        flex: 0 1 auto;
+        min-height: 0;
+        margin-top: 28px;
+        transition: flex-grow $ff-expand $ff-ease, margin-top $ff-expand $ff-ease;
+    }
+
+    &.is-conversing &__expert {
+        flex-grow: 1;
+        margin-top: 0;
+    }
+
+    &__expert :deep(.ff-expert) {
+        height: auto;
+        flex: 1;
+        min-height: 0;
+        background: transparent;
+    }
+
+    &__expert :deep(.messages-container),
+    &__expert :deep(.ff-expert-input) {
+        width: 100%;
+        max-width: $ff-column;
+        margin-left: auto;
+        margin-right: auto;
+    }
+
+    &__expert :deep(.messages-container) {
+        max-height: 0;
+        padding-top: 0;
+        padding-bottom: 0;
+        opacity: 0;
+        transition: max-height $ff-expand $ff-ease, opacity 300ms ease;
+    }
+
+    &.is-conversing &__expert :deep(.messages-container) {
+        max-height: 70vh;
+        padding-top: 1rem;
+        padding-bottom: 1rem;
+        opacity: 1;
+    }
+
+    &__expert :deep(.ff-expert-input) {
+        border-top: none;
+        background: transparent;
+        min-height: 0;
+        padding: 0;
+    }
+
+    &__expert {
+        :deep(.input-wrapper) {
+            flex-direction: row;
+            align-items: stretch;
+            border-width: 1px;
+            border-color: var(--ff-color-border);
+            border-radius: 12px;
+            background: var(--ff-color-bg-app);
+        }
+
+        :deep(.chat-input) {
+            padding: 1.15rem 0.5rem 1.15rem 1.25rem;
+            font-size: 0.9375rem;
+            background: transparent;
+        }
+
+        :deep(.actions) {
+            display: flex;
+            align-items: center;
+            padding: 0 0.6rem 0 0;
+            flex: 0 0 auto;
+        }
+
+        :deep(.action-buttons) {
+            max-height: 0;
+            opacity: 0;
+            visibility: hidden;
+            margin-bottom: 0;
+            overflow: hidden;
+            transition: max-height $ff-expand $ff-ease, opacity 260ms ease,
+                        margin-bottom $ff-expand $ff-ease, visibility $ff-expand;
+        }
+    }
+
+    &.is-conversing &__expert :deep(.action-buttons) {
+        max-height: 6rem;
+        opacity: 1;
+        visibility: visible;
+        margin-bottom: 0.5rem;
+    }
+}
+
+@media (prefers-reduced-motion: reduce) {
+    .ff-expert-home__back,
+    .ff-expert-home__resume,
+    .ff-expert-home__mode,
+    .ff-expert-home__expert,
+    .ff-expert-home__expert :deep(.messages-container),
+    .ff-expert-home__expert :deep(.action-buttons) {
+        transition: none;
+    }
+}
+</style>
diff --git a/frontend/src/pages/team/Home/index.vue b/frontend/src/pages/team/Home/index.vue
index 8954b80b94..c832f5548c 100644
--- a/frontend/src/pages/team/Home/index.vue
+++ b/frontend/src/pages/team/Home/index.vue
@@ -1,5 +1,7 @@
 <template>
-    <ff-page>
+    <TeamHomeExpert v-if="isExpertHome" />
+
+    <ff-page v-else>
         <template #header>
             <ff-page-header>
                 <template #breadcrumbs>
@@ -153,6 +155,7 @@ import ConfirmInstanceDeleteDialog from '../../instance/Settings/dialogs/Confirm
 import DeviceCredentialsDialog from '../Devices/dialogs/DeviceCredentialsDialog.vue'
 import TeamDeviceCreateDialog from '../Devices/dialogs/TeamDeviceCreateDialog.vue'
 
+import TeamHomeExpert from './Expert/index.vue'
 import DashboardSection from './components/DashboardSection.vue'
 import RecentlyModifiedDevices from './components/RecentlyModifiedDevices.vue'
 import RecentlyModifiedInstances from './components/RecentlyModifiedInstances.vue'
@@ -167,6 +170,7 @@ import { useUxToursStore } from '@/stores/ux-tours.js'
 export default {
     name: 'TeamHome',
     components: {
+        TeamHomeExpert,
         EmptyState,
         DeviceCredentialsDialog,
         ConfirmInstanceDeleteDialog,
@@ -206,6 +210,9 @@ export default {
     },
     computed: {
         ...mapState(useUxToursStore, ['tours']),
+        isExpertHome () {
+            return !!this.featuresCheck?.isExpertAssistantFeatureEnabled
+        },
         ...mapState(useContextStore, ['team']),
         ...mapState(useAccountStore, ['pendingTeamChange']),
         ...mapState(useAccountSettingsStore, ['featuresCheck']),
@@ -234,26 +241,40 @@ export default {
             return false
         }
     },
+    watch: {
+        isExpertHome (expert) {
+            if (!expert && this.loading) {
+                this.loadDashboard()
+            }
+        }
+    },
     async mounted () {
-        if ('billing_session' in this.$route.query) {
-            this.$nextTick(() => {
-                // Clear the query param so a reload of the page does re-trigger
-                // the notification
-                this.$router.replace({ query: '' })
-                // allow the Alerts service to have subscription by wrapping in nextTick
-                Alerts.emit('Thanks for signing up to FlowFuse!', 'confirmation')
-            })
+        if (this.isExpertHome) {
+            return
         }
 
-        this.getInstanceStateCounts()
-        this.getDeviceStateCounts()
-        this.getRecentActivity()
-            .finally(() => {
-                this.loading = false
-            })
-            .catch(e => e)
+        this.loadDashboard()
     },
     methods: {
+        loadDashboard () {
+            if ('billing_session' in this.$route.query) {
+                this.$nextTick(() => {
+                    // Clear the query param so a reload of the page does re-trigger
+                    // the notification
+                    this.$router.replace({ query: '' })
+                    // allow the Alerts service to have subscription by wrapping in nextTick
+                    Alerts.emit('Thanks for signing up to FlowFuse!', 'confirmation')
+                })
+            }
+
+            this.getInstanceStateCounts()
+            this.getDeviceStateCounts()
+            this.getRecentActivity()
+                .finally(() => {
+                    this.loading = false
+                })
+                .catch(e => e)
+        },
         getRecentActivity () {
             return TeamAPI.getTeamAuditLog(this.team.id, { }, null, 50)
                 .then((response) => {
diff --git a/frontend/src/stores/ux-drawers.js b/frontend/src/stores/ux-drawers.js
index 56bdf0e286..06e6a2f5d0 100644
--- a/frontend/src/stores/ux-drawers.js
+++ b/frontend/src/stores/ux-drawers.js
@@ -34,6 +34,7 @@ export const useUxDrawersStore = defineStore('ux-drawers', {
                 pinned: true,
                 open: true
             },
+            expertSuppressed: false,
             component: null,
             header: null,
             wider: false,
@@ -80,12 +81,15 @@ export const useUxDrawersStore = defineStore('ux-drawers', {
                 return
             }
 
+            if (this.rightDrawer.expertSuppressed && component.name === 'ExpertDrawer') return
+
             // Don't allow opening while drawer is currently closing
             if (this.rightDrawer.closing) return
 
             if (this.rightDrawer.state && component.name === this.rightDrawer.component?.name) return
 
             const openDrawer = () => {
+                if (this.rightDrawer.expertSuppressed && component.name === 'ExpertDrawer') return
                 if (component.name === 'ExpertDrawer') {
                     // save the ExpertDrawer pinned/open state (expertState is persistent)
                     this.rightDrawer.expertState.pinned = fixed
@@ -232,6 +236,14 @@ export const useUxDrawersStore = defineStore('ux-drawers', {
             }
         },
 
+        suppressExpertDrawer () {
+            this.rightDrawer.expertSuppressed = true
+        },
+
+        releaseExpertDrawer () {
+            this.rightDrawer.expertSuppressed = false
+        },
+
         // Editor Immersive Drawer actions
         toggleEditorImmersiveDrawer () {
             this.editorImmersiveDrawer.state = !this.editorImmersiveDrawer.state
diff --git a/test/unit/frontend/components/ExpertButton.spec.js b/test/unit/frontend/components/ExpertButton.spec.js
index d7c34e54e7..bba31866ad 100644
--- a/test/unit/frontend/components/ExpertButton.spec.js
+++ b/test/unit/frontend/components/ExpertButton.spec.js
@@ -27,7 +27,7 @@ const accountSettingsStore = reactive({
 })
 
 const uxDrawersStore = reactive({
-    rightDrawer: { state: false, fixed: false, expertState: { pinned: false } }
+    rightDrawer: { state: false, fixed: false, expertSuppressed: false, expertState: { pinned: false } }
 })
 
 const expertStore = reactive({ openAssistantDrawer: vi.fn() })
@@ -65,6 +65,7 @@ describe('ExpertButton', () => {
         mcpStore.status = 'off'
         mcpStore.clientCount = 0
         contextStore.team = null
+        uxDrawersStore.rightDrawer.expertSuppressed = false
     })
 
     afterEach(() => {
@@ -125,4 +126,17 @@ describe('ExpertButton', () => {
             expect(mcpStore.resume).not.toHaveBeenCalled()
         })
     })
+
+    describe('suppression', () => {
+        it('hides the Expert button while suppressed, keeping the MCP toggle', async () => {
+            const wrapper = mountButton()
+            expect(wrapper.find('[data-el="expert-button"]').exists()).toBe(true)
+
+            uxDrawersStore.rightDrawer.expertSuppressed = true
+            await wrapper.vm.$nextTick()
+
+            expect(wrapper.find('[data-el="expert-button"]').exists()).toBe(false)
+            expect(wrapper.find('[data-el="mcp-toggle"]').exists()).toBe(true)
+        })
+    })
 })
diff --git a/test/unit/frontend/pages/team/Home/Expert.spec.js b/test/unit/frontend/pages/team/Home/Expert.spec.js
new file mode 100644
index 0000000000..2e9f5c558f
--- /dev/null
+++ b/test/unit/frontend/pages/team/Home/Expert.spec.js
@@ -0,0 +1,278 @@
+import { enableAutoUnmount, flushPromises, mount } from '@vue/test-utils'
+import { afterEach, describe, expect, test, vi } from 'vitest'
+import { reactive } from 'vue'
+
+enableAutoUnmount(afterEach)
+
+const mocks = vi.hoisted(() => ({
+    accountAuthStore: { user: { name: 'Noley Holland' } },
+    contextStore: { isImmersiveEditor: false },
+    settingsStore: { featuresCheck: { isExpertAssistantFeatureEnabled: true, isExpertInsightsFeatureEnabled: false } },
+    expertStore: {
+        messages: [],
+        isWaitingForResponse: false,
+        isSessionExpired: false,
+        isInsightsAgent: false,
+        hasSelectedCapabilities: true,
+        openAssistantDrawer: vi.fn(),
+        setPendingInput: vi.fn(),
+        setAgentMode: vi.fn(),
+        resumeSessionTimer: vi.fn()
+    },
+    drawersStore: {
+        rightDrawer: { state: false, expertState: { pinned: true, open: true }, expertSuppressed: false },
+        suppressExpertDrawer: vi.fn(),
+        releaseExpertDrawer: vi.fn(),
+        closeRightDrawer: vi.fn()
+    }
+}))
+
+vi.mock('@/stores/account-auth.js', () => ({ useAccountAuthStore: () => mocks.accountAuthStore }))
+vi.mock('@/stores/context.js', () => ({ useContextStore: () => mocks.contextStore }))
+vi.mock('@/stores/account-settings.js', () => ({ useAccountSettingsStore: () => mocks.settingsStore }))
+vi.mock('@/stores/product-expert.js', () => ({ useProductExpertStore: () => mocks.expertStore }))
+vi.mock('@/stores/ux-drawers.js', () => ({ useUxDrawersStore: () => mocks.drawersStore }))
+
+vi.mock('@/components/expert/Expert.vue', () => ({
+    default: { name: 'ExpertPanel', template: '<div data-stub="expert-panel" />' }
+}))
+vi.mock('@/components/expert/components/ExpertModeSwitcher.vue', () => ({
+    default: { name: 'ExpertModeSwitcher', template: '<div data-stub="mode-switcher" />' }
+}))
+
+import ExpertPage from '../../../../../../frontend/src/pages/team/Home/Expert/index.vue'
+
+mocks.expertStore = reactive(mocks.expertStore)
+
+async function mountPage () {
+    const wrapper = mount(ExpertPage, {
+        global: {
+            stubs: {
+                // a `true` stub drops the default slot, so nothing below would render
+                'ff-page': { template: '<div><slot name="header" /><slot /></div>' },
+                'ff-page-header': { template: '<div><slot name="breadcrumbs" /></div>' },
+                'ff-nav-breadcrumb': { template: '<span><slot /></span>' }
+            }
+        }
+    })
+    await flushPromises()
+    return wrapper
+}
+
+describe('TeamHomeExpert', () => {
+    test('suppresses the side panel on mount and releases it on unmount', async () => {
+        mocks.drawersStore.suppressExpertDrawer.mockClear()
+        mocks.drawersStore.releaseExpertDrawer.mockClear()
+        mocks.drawersStore.rightDrawer.state = true
+
+        const wrapper = await mountPage()
+        expect(mocks.drawersStore.suppressExpertDrawer).toHaveBeenCalledTimes(1)
+        expect(mocks.drawersStore.closeRightDrawer).toHaveBeenCalledWith({ preserveExpertState: true })
+        expect(mocks.drawersStore.releaseExpertDrawer).not.toHaveBeenCalled()
+
+        wrapper.unmount()
+        expect(mocks.drawersStore.releaseExpertDrawer).toHaveBeenCalledTimes(1)
+    })
+
+    test('does not close a drawer that is not open, which would deafen the app for 300ms', async () => {
+        mocks.drawersStore.closeRightDrawer.mockClear()
+        mocks.drawersStore.rightDrawer.state = false
+
+        await mountPage()
+
+        expect(mocks.drawersStore.closeRightDrawer).not.toHaveBeenCalled()
+    })
+
+    test('does not hand the panel back into an immersive editor, which has none', async () => {
+        mocks.contextStore.isImmersiveEditor = true
+        mocks.drawersStore.rightDrawer.expertState = { pinned: true, open: true }
+        mocks.expertStore.openAssistantDrawer.mockClear()
+
+        const wrapper = await mountPage()
+        wrapper.unmount()
+
+        expect(mocks.expertStore.openAssistantDrawer).not.toHaveBeenCalled()
+        mocks.contextStore.isImmersiveEditor = false
+    })
+
+    test('hands the panel back on the way out, exactly as the user left it', async () => {
+        for (const expertState of [{ pinned: true, open: true }, { pinned: false, open: true }]) {
+            mocks.drawersStore.rightDrawer.expertState = { ...expertState }
+            mocks.expertStore.openAssistantDrawer.mockClear()
+
+            const wrapper = await mountPage()
+            expect(mocks.expertStore.openAssistantDrawer).not.toHaveBeenCalled()
+
+            wrapper.unmount()
+            expect(mocks.expertStore.openAssistantDrawer).toHaveBeenCalledWith({ openPinned: expertState.pinned })
+            expect(mocks.drawersStore.rightDrawer.expertState).toEqual(expertState)
+        }
+
+        mocks.drawersStore.rightDrawer.expertState = { pinned: false, open: false }
+        mocks.expertStore.openAssistantDrawer.mockClear()
+        const shut = await mountPage()
+        shut.unmount()
+        expect(mocks.expertStore.openAssistantDrawer).not.toHaveBeenCalled()
+    })
+
+    test('lands idle with the composer mounted', async () => {
+        mocks.expertStore.messages = []
+        const wrapper = await mountPage()
+
+        expect(wrapper.find('[data-el="expert-home"]').attributes('data-stage')).toBe('idle')
+        expect(wrapper.find('[data-stub="expert-panel"]').exists()).toBe(true)
+    })
+
+    test('typing moves to composing, which fades the surroundings but sends nothing', async () => {
+        mocks.expertStore.messages = []
+        const wrapper = await mountPage()
+
+        await wrapper.find('[data-el="expert-home-surface"]').trigger('input')
+
+        const root = wrapper.find('[data-el="expert-home"]')
+        expect(root.attributes('data-stage')).toBe('composing')
+        expect(root.classes()).toContain('is-composing')
+        expect(root.classes()).not.toContain('is-conversing')
+    })
+
+    test('sending is what opens the transcript, not typing', async () => {
+        mocks.expertStore.messages = []
+        const wrapper = await mountPage()
+        await wrapper.find('[data-el="expert-home-surface"]').trigger('input')
+        expect(wrapper.find('[data-el="expert-home"]').classes()).not.toContain('is-conversing')
+
+        mocks.expertStore.messages = [{ _type: 'human' }]
+        await wrapper.vm.$nextTick()
+
+        const root = wrapper.find('[data-el="expert-home"]')
+        expect(root.attributes('data-stage')).toBe('conversing')
+        expect(root.classes()).toContain('is-conversing')
+    })
+
+    test('back returns to idle from either stage', async () => {
+        mocks.expertStore.messages = []
+        const wrapper = await mountPage()
+        await wrapper.find('[data-el="expert-home-surface"]').trigger('input')
+
+        await wrapper.find('[data-action="collapse-expert"]').trigger('click')
+        expect(wrapper.find('[data-el="expert-home"]').attributes('data-stage')).toBe('idle')
+
+        mocks.expertStore.messages = [{ _type: 'human' }]
+        await wrapper.vm.$nextTick()
+        expect(wrapper.find('[data-el="expert-home"]').attributes('data-stage')).toBe('conversing')
+
+        await wrapper.find('[data-action="collapse-expert"]').trigger('click')
+        expect(wrapper.find('[data-el="expert-home"]').attributes('data-stage')).toBe('idle')
+    })
+
+    test('the composer is never unmounted across any stage change', async () => {
+        mocks.expertStore.messages = []
+        const wrapper = await mountPage()
+        const before = wrapper.findComponent({ name: 'ExpertPanel' })
+
+        await wrapper.find('[data-el="expert-home-surface"]').trigger('input')
+        mocks.expertStore.messages = [{ _type: 'human' }]
+        await wrapper.vm.$nextTick()
+        await wrapper.find('[data-action="collapse-expert"]').trigger('click')
+
+        expect(wrapper.findComponent({ name: 'ExpertPanel' }).vm).toBe(before.vm)
+    })
+
+    test('forces Support only when Insights is unavailable, matching openAssistantDrawer', async () => {
+        // agentMode persists to sessionStorage and this page offers no toggle when there is
+        // only one agent, so forcing it with both available would strand an Insights user
+        mocks.settingsStore.featuresCheck = {
+            isExpertAssistantFeatureEnabled: true,
+            isExpertInsightsFeatureEnabled: false
+        }
+        mocks.expertStore.setAgentMode.mockClear()
+        await mountPage()
+        expect(mocks.expertStore.setAgentMode).toHaveBeenCalledWith('support-agent')
+
+        mocks.settingsStore.featuresCheck = {
+            isExpertAssistantFeatureEnabled: true,
+            isExpertInsightsFeatureEnabled: true
+        }
+        mocks.expertStore.setAgentMode.mockClear()
+        await mountPage()
+        expect(mocks.expertStore.setAgentMode).not.toHaveBeenCalled()
+    })
+
+    test('resumes the session expiry timer, which only openAssistantDrawer otherwise does', async () => {
+        // Expert.vue clears the interval on unmount and sessionStartTime is persisted, so
+        // without this a returning user types into a session that has silently expired
+        mocks.expertStore.resumeSessionTimer.mockClear()
+        await mountPage()
+        expect(mocks.expertStore.resumeSessionTimer).toHaveBeenCalledTimes(1)
+    })
+
+    test('offers the mode toggle only when there are two agents to pick between', async () => {
+        mocks.settingsStore.featuresCheck = {
+            isExpertAssistantFeatureEnabled: true,
+            isExpertInsightsFeatureEnabled: true
+        }
+        expect((await mountPage()).find('[data-stub="mode-switcher"]').exists()).toBe(true)
+
+        mocks.settingsStore.featuresCheck = {
+            isExpertAssistantFeatureEnabled: true,
+            isExpertInsightsFeatureEnabled: false
+        }
+        expect((await mountPage()).find('[data-stub="mode-switcher"]').exists()).toBe(false)
+    })
+
+    describe('the resume control', () => {
+        afterEach(() => {
+            mocks.expertStore.isWaitingForResponse = false
+            mocks.expertStore.isSessionExpired = false
+            mocks.expertStore.isInsightsAgent = false
+            mocks.expertStore.hasSelectedCapabilities = true
+        })
+
+        test('is absent with nothing to return to, and counts user turns when there is', async () => {
+            mocks.expertStore.messages = []
+            expect((await mountPage()).find('[data-action="resume-conversation"]').exists()).toBe(false)
+
+            mocks.expertStore.messages = [{ _type: 'human' }, { _type: 'ai' }, { _type: 'human' }]
+            expect((await mountPage()).find('[data-action="resume-conversation"]').text()).toContain('2 messages')
+        })
+
+        test('appears in every state where the composer disables itself', async () => {
+            // each of these hides the control that would clear it — Stop, Start over and the
+            // capabilities selector all live behind the conversing stage
+            const deadEnds = [
+                { isWaitingForResponse: true },
+                { isSessionExpired: true },
+                { isInsightsAgent: true, hasSelectedCapabilities: false }
+            ]
+            for (const state of deadEnds) {
+                Object.assign(mocks.expertStore, state)
+                mocks.expertStore.messages = []
+                const wrapper = await mountPage()
+                expect(wrapper.find('[data-action="resume-conversation"]').exists()).toBe(true)
+                mocks.expertStore.isWaitingForResponse = false
+                mocks.expertStore.isSessionExpired = false
+                mocks.expertStore.isInsightsAgent = false
+                mocks.expertStore.hasSelectedCapabilities = true
+            }
+        })
+
+        test('survives into composing, since a new message joins the same thread', async () => {
+            mocks.expertStore.messages = [{ _type: 'human' }]
+            const wrapper = await mountPage()
+            await wrapper.find('[data-el="expert-home-surface"]').trigger('input')
+
+            expect(wrapper.find('[data-el="expert-home"]').attributes('data-stage')).toBe('composing')
+            expect(wrapper.find('[data-action="resume-conversation"]').exists()).toBe(true)
+        })
+
+        test('clicking it opens the conversation', async () => {
+            mocks.expertStore.messages = [{ _type: 'human' }]
+            const wrapper = await mountPage()
+
+            await wrapper.find('[data-action="resume-conversation"]').trigger('click')
+
+            expect(wrapper.find('[data-el="expert-home"]').attributes('data-stage')).toBe('conversing')
+            expect(mocks.expertStore.messages).toHaveLength(1)
+        })
+    })
+})
diff --git a/test/unit/frontend/pages/team/Home/index.spec.js b/test/unit/frontend/pages/team/Home/index.spec.js
new file mode 100644
index 0000000000..b4a643fff0
--- /dev/null
+++ b/test/unit/frontend/pages/team/Home/index.spec.js
@@ -0,0 +1,98 @@
+import { enableAutoUnmount, flushPromises, mount } from '@vue/test-utils'
+import { afterEach, describe, expect, test, vi } from 'vitest'
+import { reactive } from 'vue'
+
+enableAutoUnmount(afterEach)
+
+const mocks = vi.hoisted(() => ({
+    contextStore: { team: { id: 't1', slug: 'ateam' } },
+    settingsStore: { featuresCheck: {} },
+    accountStore: { pendingTeamChange: false },
+    toursStore: { tours: {} },
+    teamAPI: {
+        getTeamInstanceCounts: vi.fn().mockResolvedValue({}),
+        getTeamAuditLog: vi.fn().mockResolvedValue({ log: [] })
+    }
+}))
+
+vi.mock('@/stores/context.js', () => ({ useContextStore: () => mocks.contextStore }))
+vi.mock('@/stores/account-settings.js', () => ({ useAccountSettingsStore: () => mocks.settingsStore }))
+vi.mock('@/stores/account.js', () => ({ useAccountStore: () => mocks.accountStore }))
+vi.mock('@/stores/ux-tours.js', () => ({ useUxToursStore: () => mocks.toursStore }))
+vi.mock('@/api/team.js', () => ({ default: mocks.teamAPI }))
+
+vi.mock('@/pages/team/Home/Expert/index.vue', () => ({
+    default: { name: 'TeamHomeExpert', template: '<div data-stub="expert-home" />' }
+}))
+
+import Home from '../../../../../../frontend/src/pages/team/Home/index.vue'
+
+mocks.contextStore = reactive(mocks.contextStore)
+mocks.settingsStore = reactive(mocks.settingsStore)
+
+async function mountHome ({ expert = false } = {}) {
+    mocks.settingsStore.featuresCheck = { isExpertAssistantFeatureEnabled: expert }
+    const wrapper = mount(Home, {
+        global: {
+            stubs: {
+                'ff-page': { template: '<div><slot name="header" /><slot /></div>' },
+                'ff-page-header': { template: '<div><slot name="breadcrumbs" /></div>' },
+                'ff-nav-breadcrumb': true,
+                'ff-loading': true,
+                'ff-button': true,
+                DashboardSection: { template: '<div data-stub="dashboard-section"><slot /></div>' },
+                RecentlyModifiedInstances: true,
+                RecentlyModifiedDevices: true,
+                InstanceStat: true,
+                AuditLog: true,
+                EmptyState: true,
+                TeamDeviceCreateDialog: true,
+                DeviceCredentialsDialog: true,
+                ConfirmInstanceDeleteDialog: true
+            },
+            directives: { 'ff-tooltip': {} },
+            mocks: {
+                $route: { query: {}, params: { team_slug: 'ateam' } },
+                $router: { push: vi.fn(), replace: vi.fn() }
+            }
+        }
+    })
+    await flushPromises()
+    return wrapper
+}
+
+describe('team Home variant switch', () => {
+    test('picks the variant off the gate', async () => {
+        let wrapper = await mountHome({ expert: false })
+        expect(wrapper.find('[data-stub="dashboard-section"]').exists()).toBe(true)
+        expect(wrapper.find('[data-stub="expert-home"]').exists()).toBe(false)
+
+        wrapper = await mountHome({ expert: true })
+        expect(wrapper.find('[data-stub="expert-home"]').exists()).toBe(true)
+        expect(wrapper.find('[data-stub="dashboard-section"]').exists()).toBe(false)
+    })
+
+    test('fetches dashboard data only for the variant that shows it', async () => {
+        mocks.teamAPI.getTeamInstanceCounts.mockClear()
+        mocks.teamAPI.getTeamAuditLog.mockClear()
+        await mountHome({ expert: true })
+        expect(mocks.teamAPI.getTeamInstanceCounts).not.toHaveBeenCalled()
+        expect(mocks.teamAPI.getTeamAuditLog).not.toHaveBeenCalled()
+
+        await mountHome({ expert: false })
+        expect(mocks.teamAPI.getTeamInstanceCounts).toHaveBeenCalled()
+        expect(mocks.teamAPI.getTeamAuditLog).toHaveBeenCalled()
+    })
+
+    test('swaps to the dashboard when the Expert feature is turned off mid-visit', async () => {
+        const wrapper = await mountHome({ expert: true })
+        expect(wrapper.find('[data-stub="expert-home"]').exists()).toBe(true)
+
+        mocks.settingsStore.featuresCheck = { isExpertAssistantFeatureEnabled: false }
+        await flushPromises()
+
+        expect(mocks.teamAPI.getTeamAuditLog).toHaveBeenCalled()
+        expect(wrapper.find('[data-stub="dashboard-section"]').exists()).toBe(true)
+        expect(wrapper.find('[data-stub="expert-home"]').exists()).toBe(false)
+    })
+})
diff --git a/test/unit/frontend/stores/product-expert.spec.js b/test/unit/frontend/stores/product-expert.spec.js
index 857945312e..3cba45fa35 100644
--- a/test/unit/frontend/stores/product-expert.spec.js
+++ b/test/unit/frontend/stores/product-expert.spec.js
@@ -52,11 +52,14 @@ vi.mock('@/components/drawers/expert/ExpertDrawer.vue', () => ({
     default: { name: 'ExpertDrawer' }
 }))
 
+const drawersState = {
+    rightDrawer: { expertSuppressed: false, expertState: { pinned: false, open: false } },
+    openRightDrawer: vi.fn(),
+    setRightDrawerWider: vi.fn()
+}
+
 vi.mock('@/stores/ux-drawers.js', () => ({
-    useUxDrawersStore: vi.fn(() => ({
-        openRightDrawer: vi.fn(),
-        setRightDrawerWider: vi.fn()
-    }))
+    useUxDrawersStore: vi.fn(() => drawersState)
 }))
 
 const { dispatch, getToolDefinitions, invokeAction } = vi.hoisted(() => ({
@@ -907,3 +910,20 @@ describe('product-expert store', () => {
         })
     })
 })
+
+describe('openAssistantDrawer promise contract', () => {
+    afterEach(() => {
+        drawersState.rightDrawer.expertSuppressed = false
+    })
+
+    it('always returns a thenable, so wakeUpAssistant can chain hydrateClient off it', async () => {
+        // wakeUpAssistant chains .then() off this; returning undefined crashes it
+        const store = useProductExpertStore()
+        drawersState.rightDrawer.expertSuppressed = true
+
+        const result = store.openAssistantDrawer({ openPinned: false })
+
+        expect(typeof result?.then).toBe('function')
+        await result
+    })
+})
diff --git a/test/unit/frontend/stores/ux-drawers.spec.js b/test/unit/frontend/stores/ux-drawers.spec.js
index 605e0abdd3..bbbc87dba8 100644
--- a/test/unit/frontend/stores/ux-drawers.spec.js
+++ b/test/unit/frontend/stores/ux-drawers.spec.js
@@ -676,4 +676,38 @@ describe('ux-drawers store', () => {
             vi.advanceTimersByTime(300)
         })
     })
+
+    describe('expert drawer suppression', () => {
+        it('suppress and release toggle the flag, off by default', () => {
+            const store = useUxDrawersStore()
+            expect(store.rightDrawer.expertSuppressed).toBe(false)
+            store.suppressExpertDrawer()
+            expect(store.rightDrawer.expertSuppressed).toBe(true)
+            store.releaseExpertDrawer()
+            expect(store.rightDrawer.expertSuppressed).toBe(false)
+        })
+
+        it('refuses to open the Expert drawer while suppressed, without touching the saved preference', () => {
+            const store = useUxDrawersStore()
+            store.rightDrawer.expertState.pinned = false
+            store.rightDrawer.expertState.open = false
+            store.suppressExpertDrawer()
+
+            store.openRightDrawer({ component: { name: 'ExpertDrawer' }, fixed: true })
+
+            expect(store.rightDrawer.state).toBe(false)
+            expect(store.rightDrawer.component).toBe(null)
+            expect(store.rightDrawer.expertState).toEqual({ pinned: false, open: false })
+        })
+
+        it('still opens other drawers while the Expert drawer is suppressed', () => {
+            const store = useUxDrawersStore()
+            store.suppressExpertDrawer()
+
+            store.openRightDrawer({ component: FakeComponent })
+
+            expect(store.rightDrawer.state).toBe(true)
+            expect(store.rightDrawer.component.name).toBe('FakeComponent')
+        })
+    })
 })