diff --git a/tests/test_h3_window_planner.py b/tests/test_h3_window_planner.py
index e22bccd6..d6f68d3f 100644
--- a/tests/test_h3_window_planner.py
+++ b/tests/test_h3_window_planner.py
@@ -381,7 +381,10 @@ def test_ui_and_runtime_use_explicit_prompt_arrays(self):
         handler = (APP / "wgp.py").read_text(encoding="utf-8")
         launch = (APP / "_launch_runtime.py").read_text(encoding="utf-8")
         llm_router = (APP / "routers" / "llm.py").read_text(encoding="utf-8")
-        store = (ROOT / "ui" / "src" / "stores" / "useStore.ts").read_text(encoding="utf-8")
+        store = (
+            (ROOT / "ui" / "src" / "stores" / "useStore.ts").read_text(encoding="utf-8")
+            + (ROOT / "ui" / "src" / "stores" / "llmSlice.ts").read_text(encoding="utf-8")
+        )
         advanced = (ROOT / "ui" / "src" / "components" / "Sidebar" / "AdvancedSettings.tsx").read_text(encoding="utf-8")
         prompt_input = (ROOT / "ui" / "src" / "components" / "Sidebar" / "PromptInput.tsx").read_text(encoding="utf-8")
         main_content = (ROOT / "ui" / "src" / "components" / "MainContent" / "MainContent.tsx").read_text(encoding="utf-8")
diff --git a/tests/test_minimax_h3.py b/tests/test_minimax_h3.py
index 4caaf6c0..f92dbb49 100644
--- a/tests/test_minimax_h3.py
+++ b/tests/test_minimax_h3.py
@@ -37,6 +37,7 @@
 _FULL_DEFAULT_PATH = _APP / "defaults" / "minimax_h3_full.json"
 _REF2VA_FULL_DEFAULT_PATH = _APP / "defaults" / "minimax_h3_ref2va_full.json"
 _STORE_PATH = _ROOT / "ui" / "src" / "stores" / "useStore.ts"
+_LLM_SLICE_PATH = _ROOT / "ui" / "src" / "stores" / "llmSlice.ts"
 _PROMPT_INPUT_PATH = _ROOT / "ui" / "src" / "components" / "Sidebar" / "PromptInput.tsx"
 _DURATION_SLIDER_PATH = _ROOT / "ui" / "src" / "components" / "Sidebar" / "DurationSlider.tsx"
 _ADVANCED_SETTINGS_PATH = _ROOT / "ui" / "src" / "components" / "Sidebar" / "AdvancedSettings.tsx"
@@ -985,6 +986,7 @@ def test_omni_reference_request_and_ui_are_wired_end_to_end(self):
         main = _read(_MAIN_PATH)
         wgp = _read(_WGP_PATH)
         store = _read(_STORE_PATH)
+        llm_slice = _read(_LLM_SLICE_PATH)
         section = _read(_OMNI_REFERENCE_SECTION_PATH)
         generate_button = _read(_GENERATE_BUTTON_PATH)
         self.assertIn('if _generation_model_def.get("omni_reference"):', launch)
@@ -998,9 +1000,9 @@ def test_omni_reference_request_and_ui_are_wired_end_to_end(self):
         self.assertIn("num_condition_video_rows", main)
         self.assertIn("const omniReferences = state.params.minimax_h3_references ?? []", store)
         self.assertIn("delete params.minimax_h3_references", store)
-        self.assertIn("reference_context: referenceContext", store)
-        self.assertIn("intent=AUDIO REUSE / PERFORMANCE DRIVER", store)
-        self.assertIn("intent=VOICE REFERENCE", store)
+        self.assertIn("reference_context: media.referenceContext", llm_slice)
+        self.assertIn("intent=AUDIO REUSE / PERFORMANCE DRIVER", llm_slice)
+        self.assertIn("intent=VOICE REFERENCE", llm_slice)
         self.assertIn('draggable', section)
         self.assertIn("Include soundtrack", section)
         self.assertIn("Attach audio", section)
@@ -1016,11 +1018,11 @@ def test_omni_reference_request_and_ui_are_wired_end_to_end(self):
         )
 
     def test_non_sliding_h3_enhance_request_stays_one_timeline(self):
-        store = _read(_STORE_PATH)
+        llm_slice = _read(_LLM_SLICE_PATH)
         prompt_input = _read(_PROMPT_INPUT_PATH)
         expected = "supportsSlidingWindows = state.modelOptions?.sliding_window === true"
-        self.assertIn(expected, store)
-        self.assertIn("supportsSlidingWindows && stride > 0", store)
+        self.assertIn(expected, llm_slice)
+        self.assertIn("supportsSlidingWindows && stride > 0", llm_slice)
         self.assertIn("supportsSlidingWindows = modelOptions?.sliding_window === true", prompt_input)
         self.assertIn("supportsSlidingWindows && stride > 0", prompt_input)
 
diff --git a/ui/src/stores/llmSlice.ts b/ui/src/stores/llmSlice.ts
new file mode 100644
index 00000000..f260468d
--- /dev/null
+++ b/ui/src/stores/llmSlice.ts
@@ -0,0 +1,327 @@
+import * as api from '../api/client'
+import type {
+  GenerateParams,
+  GenerationMode,
+  H3WindowPlan,
+  LlmModelOption,
+  LlmStatus,
+  ModelOptions,
+  ProductionProfile,
+  ServicesConfig,
+} from '../types'
+import type { SliceCreator, SliceSet } from './storeApi'
+
+export const UNLOADED_LLM_STATUS: LlmStatus = {
+  loaded: false,
+  model_id: null,
+  device: null,
+  provider: '',
+}
+
+export type LlmSlice = {
+  llmStatus: LlmStatus | null
+  llmLoading: boolean
+  llmModels: LlmModelOption[]
+  loadLlmStatus: () => Promise<void>
+  loadLlmModels: () => Promise<void>
+  loadLlm: () => Promise<void>
+  unloadLlm: () => Promise<void>
+  isEnhancing: boolean
+  enhancePrompt: (ttsMode?: string) => Promise<void>
+  h3WindowPlan: H3WindowPlan | null
+  updateH3WindowPrompt: (index: number, prompt: string) => void
+  clearH3WindowPlan: () => void
+}
+
+/** Host fields the LLM drawer reads or writes without owning generate. */
+export type LlmSliceHost = LlmSlice & {
+  servicesConfig: ServicesConfig | null
+  productionProfile: ProductionProfile
+  params: GenerateParams
+  generationMode: GenerationMode
+  startImage: File | null
+  endImage: File | null
+  imageRefs: File[]
+  modelOptions: ModelOptions | null
+  slidingWindowOverlap: number
+  durationSeconds: number
+  slidingWindowSeconds: number
+  slidingWindowLocked: boolean
+  ttsVoiceCount: number
+  _autoParseSpkeakerNames: (text: string, force?: boolean) => void
+}
+
+type EnhanceMedia = {
+  imagePaths: string[]
+  referenceContext?: string
+}
+
+type EnhanceWindowLayout = {
+  fps: number
+  discardFrames: number
+  windowCount: number
+  shouldPlanH3Windows: boolean
+}
+
+function omniAudioLabel(note: string, intent: string, audioIndex: number): string {
+  if (intent === 'drive') {
+    return `<Audio ${audioIndex}>: ${note}; intent=AUDIO REUSE / PERFORMANCE DRIVER; retention=partially_copy; preserve its audible timeline and synchronize action to it`
+  }
+  if (intent === 'style') {
+    return `<Audio ${audioIndex}>: ${note}; intent=AUDIO REFERENCE; retention=weak_reference; borrow only rhythm/style/texture and do not copy the source signal or words`
+  }
+  return `<Audio ${audioIndex}>: ${note}; intent=VOICE REFERENCE; retention=reference; use timbre/emotion/delivery for new scripted dialogue without copying source words, timing, or waveform`
+}
+
+function collectOmniEnhanceMedia(params: GenerateParams): EnhanceMedia {
+  const imagePaths: string[] = []
+  let pictureIndex = 0
+  let videoIndex = 0
+  let audioIndex = 0
+  const labelLines: string[] = []
+  for (const reference of params.minimax_h3_references ?? []) {
+    const note = (reference.role || reference.filename || 'reference').trim()
+    if (reference.type === 'audio') {
+      labelLines.push(omniAudioLabel(note, reference.audio_intent ?? 'voice', ++audioIndex))
+      continue
+    }
+    if (reference.type === 'image') {
+      labelLines.push(`<Picture ${++pictureIndex}>: visual identity/appearance reference for ${note}; retention=reference for identity only; do not reproduce its background, framing, composition, or pose`)
+      if (reference.path) imagePaths.push(reference.path)
+      continue
+    }
+    const nextVideoIndex = videoIndex + 1
+    if ((reference.has_audio || reference.audio_path) && reference.include_audio !== false) {
+      labelLines.push(omniAudioLabel(
+        `soundtrack paired with <Video ${nextVideoIndex}>`,
+        'drive',
+        ++audioIndex,
+      ))
+    }
+    videoIndex = nextVideoIndex
+    labelLines.push(`<Video ${videoIndex}>: motion/camera/scene/timing reference for ${note}`)
+  }
+  return { imagePaths, referenceContext: labelLines.join('\n') }
+}
+
+async function uploadBestEffort(file: File, imagePaths: string[]): Promise<void> {
+  try {
+    const uploaded = await api.uploadImage(file)
+    imagePaths.push(uploaded.path)
+  } catch { /* best effort */ }
+}
+
+async function collectEnhanceMedia(state: LlmSliceHost): Promise<EnhanceMedia> {
+  if (state.modelOptions?.omni_reference === true) {
+    return collectOmniEnhanceMedia(state.params)
+  }
+  const imagePaths: string[] = []
+  if (state.generationMode === 'image') {
+    for (const ref of state.imageRefs) {
+      await uploadBestEffort(ref, imagePaths)
+    }
+    return { imagePaths }
+  }
+  if (state.startImage) {
+    await uploadBestEffort(state.startImage, imagePaths)
+  } else if (state.params.image_start && typeof state.params.image_start === 'string') {
+    imagePaths.push(state.params.image_start)
+  }
+  return { imagePaths }
+}
+
+function enhanceWindowLayout(state: LlmSliceHost): EnhanceWindowLayout {
+  const fps = state.modelOptions?.fps ?? 16
+  const swDefaults = (state.modelOptions as Record<string, unknown> | null)?.sliding_window_defaults as Record<string, number> | undefined
+  const discardFrames = swDefaults?.discard_last_frames ?? 0
+  const overlapSec = state.slidingWindowOverlap / fps
+  const discardSec = discardFrames / fps
+  const stride = state.slidingWindowSeconds - discardSec - overlapSec
+  const supportsSlidingWindows = state.modelOptions?.sliding_window === true
+  const windowCount = supportsSlidingWindows && stride > 0 && state.durationSeconds > state.slidingWindowSeconds
+    ? 1 + Math.ceil((state.durationSeconds - state.slidingWindowSeconds + discardSec) / stride)
+    : 1
+  return {
+    fps,
+    discardFrames,
+    windowCount,
+    shouldPlanH3Windows: (
+      state.generationMode === 'video'
+      && state.modelOptions?.sliding_window_auto_prompt_pacing === true
+      && state.params.image_mode !== 2
+      && windowCount > 1
+    ),
+  }
+}
+
+async function appendEndImage(state: LlmSliceHost, imagePaths: string[]): Promise<void> {
+  if (state.endImage) {
+    await uploadBestEffort(state.endImage, imagePaths)
+    return
+  }
+  if (state.params.image_end && typeof state.params.image_end === 'string') {
+    imagePaths.push(state.params.image_end)
+  }
+}
+
+async function applyH3WindowPlan(
+  state: LlmSliceHost,
+  set: SliceSet<LlmSliceHost>,
+  imagePaths: string[],
+  layout: EnhanceWindowLayout,
+): Promise<void> {
+  // The ordinary H3 enhancer writes one complete Context-IR timeline.
+  // Multi-window H3 instead needs a structured storyboard whose prompts
+  // contain only their own local actions. Include both endpoint images
+  // so the planner can preserve the requested visual trajectory.
+  await appendEndImage(state, imagePaths)
+  const { params } = state
+  const plan = await api.planH3Windows({
+    prompt: params.prompt,
+    model_type: params.model_type,
+    resolution: params.resolution,
+    total_frames: Math.max(1, Math.round(state.durationSeconds * layout.fps)),
+    window_frames: Math.max(1, Math.round(state.slidingWindowSeconds * layout.fps)),
+    overlap_frames: state.slidingWindowOverlap,
+    discard_frames: layout.discardFrames,
+    sliding_window_memory_override: state.slidingWindowLocked,
+    has_start_image: !!(state.startImage || params.image_start),
+    has_end_image: !!(state.endImage || params.image_end),
+    image_paths: imagePaths.length > 0 ? imagePaths : undefined,
+  })
+  const effectiveWindowFrames = plan.effective_window_frames || plan.window_frames
+  set(s => ({
+    h3WindowPlan: plan,
+    slidingWindowSeconds: effectiveWindowFrames / layout.fps,
+    // Clicking Enhance on a multi-window H3 First/Last job is an
+    // explicit request to plan the idea across those windows. Turn the
+    // planner back on even when an old saved setting left legacy mode
+    // disabled; otherwise the ordinary H3 enhancer flattens every
+    // window into one globally timed screenplay.
+    params: {
+      ...s.params,
+      sliding_window_size: effectiveWindowFrames,
+      minimax_h3_window_storyboard: true,
+    },
+    isEnhancing: false,
+  }))
+}
+
+function timedModeFields(state: LlmSliceHost, windowCount: number) {
+  if (state.generationMode !== 'video' && state.generationMode !== 'avatar') {
+    return {
+      duration_seconds: undefined as number | undefined,
+      window_count: undefined as number | undefined,
+      window_size_seconds: undefined as number | undefined,
+    }
+  }
+  return {
+    duration_seconds: state.durationSeconds,
+    window_count: windowCount,
+    window_size_seconds: state.slidingWindowSeconds,
+  }
+}
+
+export const createLlmSlice: SliceCreator<LlmSlice, LlmSliceHost> = (set, get) => ({
+  llmStatus: null,
+  llmLoading: false,
+  llmModels: [],
+  loadLlmStatus: async () => {
+    try {
+      const status = await api.fetchLlmStatus()
+      set({ llmStatus: status })
+    } catch (e) {
+      console.error('Failed to load LLM status:', e)
+    }
+  },
+  loadLlmModels: async () => {
+    try {
+      const provider = get().servicesConfig?.llm_provider || get().productionProfile.text.provider
+      const data = await api.fetchLlmModels(provider)
+      set({ llmModels: data.models })
+    } catch (e) {
+      console.error('Failed to load LLM models:', e)
+    }
+  },
+  loadLlm: async () => {
+    set({ llmLoading: true })
+    try {
+      const result = await api.loadLlm()
+      set({
+        llmStatus: {
+          loaded: result.loaded,
+          model_id: result.model_id,
+          device: result.device,
+          provider: result.provider || '',
+        },
+        llmLoading: false,
+      })
+    } catch (e) {
+      console.error('Failed to load LLM:', e)
+      set({ llmLoading: false })
+    }
+  },
+  unloadLlm: async () => {
+    try {
+      await api.unloadLlm()
+      set({ llmStatus: UNLOADED_LLM_STATUS })
+    } catch (e) {
+      console.error('Failed to unload LLM:', e)
+    }
+  },
+
+  isEnhancing: false,
+  h3WindowPlan: null,
+  updateH3WindowPrompt: (index, prompt) => set(s => {
+    if (!s.h3WindowPlan || index < 0 || index >= s.h3WindowPlan.windows.length) return {}
+    const windows = s.h3WindowPlan.windows.map((window, windowIndex) => (
+      windowIndex === index ? { ...window, prompt } : window
+    ))
+    return {
+      h3WindowPlan: {
+        ...s.h3WindowPlan,
+        windows,
+        window_prompts: windows.map(window => window.prompt),
+      },
+    }
+  }),
+  clearH3WindowPlan: () => set({ h3WindowPlan: null }),
+  enhancePrompt: async (ttsMode?: string) => {
+    const state = get()
+    if (!state.params.prompt.trim()) return
+    set({ isEnhancing: true })
+    try {
+      const media = await collectEnhanceMedia(state)
+      const layout = enhanceWindowLayout(state)
+      if (layout.shouldPlanH3Windows) {
+        await applyH3WindowPlan(state, set, media.imagePaths, layout)
+        return
+      }
+      const timed = timedModeFields(state, layout.windowCount)
+      const result = await api.llmEnhancePrompt({
+        prompt: state.params.prompt,
+        mode: state.generationMode,
+        model_type: state.params.model_type,
+        max_new_tokens: (state.generationMode === 'audio' && ttsMode) ? 2048 : undefined,
+        image_paths: media.imagePaths.length > 0 ? media.imagePaths : undefined,
+        duration_seconds: timed.duration_seconds,
+        window_count: timed.window_count,
+        window_size_seconds: timed.window_size_seconds,
+        activated_loras: state.params.activated_loras.length > 0 ? state.params.activated_loras : undefined,
+        tts_enhance_mode: ttsMode || undefined,
+        tts_voice_count: state.ttsVoiceCount || undefined,
+        reference_context: media.referenceContext,
+      })
+      set(s => ({
+        params: { ...s.params, prompt: result.enhanced },
+        isEnhancing: false,
+      }))
+      if (ttsMode && get().ttsVoiceCount > 0) {
+        get()._autoParseSpkeakerNames(result.enhanced, true)
+      }
+    } catch (e) {
+      console.error('Failed to enhance prompt:', e)
+      set({ isEnhancing: false })
+    }
+  },
+})
diff --git a/ui/src/stores/storeApi.ts b/ui/src/stores/storeApi.ts
index acf787da..0905ef4b 100644
--- a/ui/src/stores/storeApi.ts
+++ b/ui/src/stores/storeApi.ts
@@ -6,23 +6,22 @@ export type SliceSet<T> = (
 
 export type SliceGet<T> = () => T
 
-export type SliceCreator<T> = (set: SliceSet<T>, get: SliceGet<T>) => T
+export type SliceCreator<TSlice, THost extends TSlice = TSlice> = (
+  set: SliceSet<THost>,
+  get: SliceGet<THost>,
+) => TSlice
 
 /**
  * Bind a slice to the full store. `TStore` must include the slice keys, so a
  * `Partial<TSlice>` is a valid store update without `as never`.
+ *
+ * `THost` defaults to the slice itself. A slice may declare a wider host when
+ * it reads or writes sibling fields without owning those domains.
  */
 export function bindSlice<TSlice extends object, TStore extends TSlice>(
   set: SliceSet<TStore>,
   get: SliceGet<TStore>,
-  create: SliceCreator<TSlice>,
+  create: SliceCreator<TSlice, TStore>,
 ): TSlice {
-  const sliceSet: SliceSet<TSlice> = partial => {
-    if (typeof partial === 'function') {
-      set(state => partial(state) as Partial<TStore>)
-      return
-    }
-    set(partial as Partial<TStore>)
-  }
-  return create(sliceSet, get)
+  return create(set, get)
 }
diff --git a/ui/src/stores/useStore.ts b/ui/src/stores/useStore.ts
index 39e3105f..57ca6475 100644
--- a/ui/src/stores/useStore.ts
+++ b/ui/src/stores/useStore.ts
@@ -1,5 +1,5 @@
 import { create } from 'zustand'
-import type { GenerateParams, OutputFile, MediaFilter, AspectRatio, ResolutionPreset, ScailResolutionProfile, GenerationDetails, GenerationJob, ModelFamily, ModelDef, GenerationMode, ModelOptions, SystemConfig, SettingsTab, OutputMetadata, MultiClip, ServicesConfig, ProductionProfile, LlmStatus, LlmModelOption, AudioAnalysisResult, PlannedClip, ClipPlan, DirectorClipImage, DirectorImageGenProgress, SpeakerMapping, DirectorSkill, DirectorShotImageGuidance, ShortFilmCharacter, ShortFilmPath, MusicVideoTreatment, CivitAIModel, CivitAIDownload, PipelineListItem, PipelineRepairState, SavedPipelineState, SystemDetectResponse, SystemStats, RecastCharacterMapping, RepaintRegionMapping, H3WindowPlan, DirectorV2PlanJob, DirectorV2PlanResponse } from '../types'
+import type { GenerateParams, OutputFile, MediaFilter, AspectRatio, ResolutionPreset, ScailResolutionProfile, GenerationDetails, GenerationJob, ModelFamily, ModelDef, GenerationMode, ModelOptions, SystemConfig, SettingsTab, OutputMetadata, MultiClip, ServicesConfig, ProductionProfile, AudioAnalysisResult, PlannedClip, ClipPlan, DirectorClipImage, DirectorImageGenProgress, SpeakerMapping, DirectorSkill, DirectorShotImageGuidance, ShortFilmCharacter, ShortFilmPath, MusicVideoTreatment, CivitAIModel, CivitAIDownload, PipelineListItem, PipelineRepairState, SavedPipelineState, SystemDetectResponse, SystemStats, RecastCharacterMapping, RepaintRegionMapping, H3WindowPlan, DirectorV2PlanJob, DirectorV2PlanResponse } from '../types'
 import { DEFAULT_DIRECT_VIDEO_MASTER_PROMPT } from '../types'
 import * as api from '../api/client'
 import { type FamilyId, type ThemeMode, type ThemePrefs } from '../lib/theme'
@@ -18,6 +18,7 @@ import { createSidebarSlice } from './sidebarSlice'
 import { bindSlice } from './storeApi'
 import { createThemeSlice } from './themeSlice'
 import { createGallerySlice } from './gallerySlice'
+import { createLlmSlice, UNLOADED_LLM_STATUS, type LlmSlice } from './llmSlice'
 import { markJobsCancelling, prependJob, removeJob, updateJob, withJobs } from './jobReducers'
 import {
   extractSingleClipStudioParams,
@@ -1060,7 +1061,7 @@ interface ScheduledPromptSubmission {
   total: number
 }
 
-interface AppState {
+interface AppState extends LlmSlice {
   // Generation mode (top-level: image/video/audio/avatar)
   generationMode: GenerationMode
   setGenerationMode: (mode: GenerationMode) => void
@@ -1695,22 +1696,6 @@ interface AppState {
   loadProductionProfile: () => Promise<void>
   updateProductionProfile: (profile: ProductionProfile) => Promise<void>
 
-  // LLM state
-  llmStatus: LlmStatus | null
-  llmLoading: boolean
-  llmModels: LlmModelOption[]
-  loadLlmStatus: () => Promise<void>
-  loadLlmModels: () => Promise<void>
-  loadLlm: () => Promise<void>
-  unloadLlm: () => Promise<void>
-
-  // Prompt enhancement
-  isEnhancing: boolean
-  enhancePrompt: (ttsMode?: string) => Promise<void>
-  h3WindowPlan: H3WindowPlan | null
-  updateH3WindowPrompt: (index: number, prompt: string) => void
-  clearH3WindowPlan: () => void
-
   // Director (Music Video Director)
   sidebarMode: 'director' | 'studio'
   directorStep: 'upload' | 'analyze' | 'structure' | 'style' | 'plan' | 'review' | 'generate_images' | 'plan_video' | 'review_video'
@@ -2232,6 +2217,7 @@ export const useStore = create<AppState>((set, get) => {
   ...bindSlice(set, get, createSidebarSlice),
   ...bindSlice(set, get, createRetakeDialogSlice),
   ...bindSlice(set, get, createGallerySlice),
+  ...bindSlice(set, get, createLlmSlice),
   ...developerMode,
   setDeveloperMode: (enabled: boolean) => {
     developerMode.setDeveloperMode(enabled)
@@ -4453,7 +4439,7 @@ export const useStore = create<AppState>((set, get) => {
     if (get().llmStatus?.loaded) {
       try {
         await api.unloadLlm()
-        set({ llmStatus: { loaded: false, model_id: null, device: null, provider: '' } })
+        set({ llmStatus: UNLOADED_LLM_STATUS })
       } catch { /* best-effort */ }
     }
 
@@ -6922,222 +6908,6 @@ export const useStore = create<AppState>((set, get) => {
     }
   },
 
-  // LLM state
-  llmStatus: null,
-  llmLoading: false,
-  llmModels: [],
-  loadLlmStatus: async () => {
-    try {
-      const status = await api.fetchLlmStatus()
-      set({ llmStatus: status })
-    } catch (e) {
-      console.error('Failed to load LLM status:', e)
-    }
-  },
-  loadLlmModels: async () => {
-    try {
-      const provider = get().servicesConfig?.llm_provider || get().productionProfile.text.provider
-      const data = await api.fetchLlmModels(provider)
-      set({ llmModels: data.models })
-    } catch (e) {
-      console.error('Failed to load LLM models:', e)
-    }
-  },
-  loadLlm: async () => {
-    set({ llmLoading: true })
-    try {
-      const result = await api.loadLlm()
-      set({ llmStatus: { loaded: result.loaded, model_id: result.model_id, device: result.device, provider: result.provider || '' }, llmLoading: false })
-    } catch (e) {
-      console.error('Failed to load LLM:', e)
-      set({ llmLoading: false })
-    }
-  },
-  unloadLlm: async () => {
-    try {
-      await api.unloadLlm()
-      set({ llmStatus: { loaded: false, model_id: null, device: null, provider: '' } })
-    } catch (e) {
-      console.error('Failed to unload LLM:', e)
-    }
-  },
-
-  // Prompt enhancement
-  isEnhancing: false,
-  h3WindowPlan: null,
-  updateH3WindowPrompt: (index, prompt) => set(s => {
-    if (!s.h3WindowPlan || index < 0 || index >= s.h3WindowPlan.windows.length) return {}
-    const windows = s.h3WindowPlan.windows.map((window, windowIndex) => (
-      windowIndex === index ? { ...window, prompt } : window
-    ))
-    return {
-      h3WindowPlan: {
-        ...s.h3WindowPlan,
-        windows,
-        window_prompts: windows.map(window => window.prompt),
-      },
-    }
-  }),
-  clearH3WindowPlan: () => set({ h3WindowPlan: null }),
-  enhancePrompt: async (ttsMode?: string) => {
-    const state = get()
-    const { params, generationMode, startImage, endImage, imageRefs } = state
-    if (!params.prompt.trim()) return
-    set({ isEnhancing: true })
-    try {
-      // Collect images relevant to the CURRENT mode only
-      const imagePaths: string[] = []
-      let referenceContext: string | undefined
-      const isOmniReference = state.modelOptions?.omni_reference === true
-
-      if (isOmniReference) {
-        let pictureIndex = 0
-        let videoIndex = 0
-        let audioIndex = 0
-        const labelLines: string[] = []
-        for (const reference of params.minimax_h3_references ?? []) {
-          const note = (reference.role || reference.filename || 'reference').trim()
-          if (reference.type === 'audio') {
-            const intent = reference.audio_intent ?? 'voice'
-            if (intent === 'drive') {
-              labelLines.push(`<Audio ${++audioIndex}>: ${note}; intent=AUDIO REUSE / PERFORMANCE DRIVER; retention=partially_copy; preserve its audible timeline and synchronize action to it`)
-            } else if (intent === 'style') {
-              labelLines.push(`<Audio ${++audioIndex}>: ${note}; intent=AUDIO REFERENCE; retention=weak_reference; borrow only rhythm/style/texture and do not copy the source signal or words`)
-            } else {
-              labelLines.push(`<Audio ${++audioIndex}>: ${note}; intent=VOICE REFERENCE; retention=reference; use timbre/emotion/delivery for new scripted dialogue without copying source words, timing, or waveform`)
-            }
-          } else if (reference.type === 'image') {
-            labelLines.push(`<Picture ${++pictureIndex}>: visual identity/appearance reference for ${note}; retention=reference for identity only; do not reproduce its background, framing, composition, or pose`)
-            if (reference.path) imagePaths.push(reference.path)
-          } else {
-            const nextVideoIndex = videoIndex + 1
-            if ((reference.has_audio || reference.audio_path) && reference.include_audio !== false) {
-              labelLines.push(`<Audio ${++audioIndex}>: soundtrack paired with <Video ${nextVideoIndex}>; intent=AUDIO REUSE / PERFORMANCE DRIVER; retention=partially_copy; preserve its audible timeline and synchronize action to it`)
-            }
-            videoIndex = nextVideoIndex
-            labelLines.push(`<Video ${videoIndex}>: motion/camera/scene/timing reference for ${note}`)
-          }
-        }
-        referenceContext = labelLines.join('\n')
-      } else if (generationMode === 'image') {
-        // Image mode: send reference images only
-        for (const ref of imageRefs) {
-          try {
-            const uploaded = await api.uploadImage(ref)
-            imagePaths.push(uploaded.path)
-          } catch { /* best effort */ }
-        }
-      } else {
-        // Video/Avatar mode: send start image only
-        if (startImage) {
-          try {
-            const uploaded = await api.uploadImage(startImage)
-            imagePaths.push(uploaded.path)
-          } catch { /* best effort */ }
-        } else if (params.image_start && typeof params.image_start === 'string') {
-          imagePaths.push(params.image_start as string)
-        }
-      }
-
-      // Include duration/window info for video models
-      const fps = state.modelOptions?.fps ?? 16
-      const swDefaults = (state.modelOptions as Record<string, unknown> | null)?.sliding_window_defaults as Record<string, number> | undefined
-      const discardFrames = swDefaults?.discard_last_frames ?? 0
-      const overlapSec = state.slidingWindowOverlap / fps
-      const discardSec = discardFrames / fps
-      const stride = state.slidingWindowSeconds - discardSec - overlapSec
-      const supportsSlidingWindows = state.modelOptions?.sliding_window === true
-      const windowCount = supportsSlidingWindows && stride > 0 && state.durationSeconds > state.slidingWindowSeconds
-        ? 1 + Math.ceil((state.durationSeconds - state.slidingWindowSeconds + discardSec) / stride)
-        : 1
-
-      const shouldPlanH3Windows = (
-        generationMode === 'video'
-        && state.modelOptions?.sliding_window_auto_prompt_pacing === true
-        && params.image_mode !== 2
-        && windowCount > 1
-      )
-      if (shouldPlanH3Windows) {
-        // The ordinary H3 enhancer writes one complete Context-IR timeline.
-        // Multi-window H3 instead needs a structured storyboard whose prompts
-        // contain only their own local actions. Include both endpoint images
-        // so the planner can preserve the requested visual trajectory.
-        if (endImage) {
-          try {
-            const uploaded = await api.uploadImage(endImage)
-            imagePaths.push(uploaded.path)
-          } catch { /* best effort */ }
-        } else if (params.image_end && typeof params.image_end === 'string') {
-          imagePaths.push(params.image_end)
-        }
-        const plan = await api.planH3Windows({
-          prompt: params.prompt,
-          model_type: params.model_type,
-          resolution: params.resolution,
-          total_frames: Math.max(1, Math.round(state.durationSeconds * fps)),
-          window_frames: Math.max(1, Math.round(state.slidingWindowSeconds * fps)),
-          overlap_frames: state.slidingWindowOverlap,
-          discard_frames: discardFrames,
-          sliding_window_memory_override: state.slidingWindowLocked,
-          has_start_image: !!(startImage || params.image_start),
-          has_end_image: !!(endImage || params.image_end),
-          image_paths: imagePaths.length > 0 ? imagePaths : undefined,
-        })
-        const effectiveWindowFrames = plan.effective_window_frames || plan.window_frames
-        set(s => ({
-          h3WindowPlan: plan,
-          slidingWindowSeconds: effectiveWindowFrames / fps,
-          // Clicking Enhance on a multi-window H3 First/Last job is an
-          // explicit request to plan the idea across those windows. Turn the
-          // planner back on even when an old saved setting left legacy mode
-          // disabled; otherwise the ordinary H3 enhancer flattens every
-          // window into one globally timed screenplay.
-          params: {
-            ...s.params,
-            sliding_window_size: effectiveWindowFrames,
-            minimax_h3_window_storyboard: true,
-          },
-          isEnhancing: false,
-        }))
-        return
-      }
-
-      // TTS dialogue needs more tokens for longer conversations
-      const maxTokens = (generationMode === 'audio' && ttsMode) ? 2048 : undefined
-
-      const result = await api.llmEnhancePrompt({
-        prompt: params.prompt,
-        mode: generationMode,
-        model_type: params.model_type,
-        max_new_tokens: maxTokens,
-        image_paths: imagePaths.length > 0 ? imagePaths : undefined,
-        duration_seconds: (generationMode === 'video' || generationMode === 'avatar') ? state.durationSeconds : undefined,
-        window_count: (generationMode === 'video' || generationMode === 'avatar') ? windowCount : undefined,
-        window_size_seconds: (generationMode === 'video' || generationMode === 'avatar') ? state.slidingWindowSeconds : undefined,
-        activated_loras: params.activated_loras.length > 0 ? params.activated_loras : undefined,
-        tts_enhance_mode: ttsMode || undefined,
-        tts_voice_count: state.ttsVoiceCount || undefined,
-        reference_context: referenceContext,
-      })
-      set(s => ({
-        params: { ...s.params, prompt: result.enhanced },
-        isEnhancing: false,
-      }))
-      // Auto-parse speaker names from the enhanced text whenever there are
-      // voice slots to fill. Previously gated to dialogue mode only; the user
-      // expects monologue enhance ("Peter: Hello world.") to also populate
-      // voice slot 1 with "Peter". `force=true` overrides the manual flag
-      // — enhance creates a fresh script, so previous user-edited names are
-      // no longer relevant.
-      if (ttsMode && get().ttsVoiceCount > 0) {
-        get()._autoParseSpkeakerNames(result.enhanced, true)
-      }
-    } catch (e) {
-      console.error('Failed to enhance prompt:', e)
-      set({ isEnhancing: false })
-    }
-  },
-
   // Director (Music Video Director)
   sidebarMode: 'studio' as const,
   directorSkill: null,
@@ -8364,7 +8134,7 @@ export const useStore = create<AppState>((set, get) => {
     if (get().llmStatus?.loaded) {
       try {
         await api.unloadLlm()
-        set({ llmStatus: { loaded: false, model_id: null, device: null, provider: '' } })
+        set({ llmStatus: UNLOADED_LLM_STATUS })
       } catch { /* best-effort */ }
     }
 
diff --git a/ui/tests/architectureSlices.test.mjs b/ui/tests/architectureSlices.test.mjs
index 9ce018a2..ea8ba2c5 100644
--- a/ui/tests/architectureSlices.test.mjs
+++ b/ui/tests/architectureSlices.test.mjs
@@ -257,6 +257,7 @@ test('gallery slice keeps workspace and output filters through the public facade
   assert.equal('settingsOpen' in isolated, false)
   assert.equal('startGeneration' in isolated, false)
   assert.equal('loadSettingsFromOutput' in isolated, false)
+  assert.equal('loadLlm' in isolated, false)
 
   const { useStore } = await import('../src/stores/useStore.ts')
   useStore.setState({
@@ -273,6 +274,71 @@ test('gallery slice keeps workspace and output filters through the public facade
   assert.equal(useStore.getState().galleryFeedAtTop, true)
 })
 
+test('LLM slice keeps status, models and enhance through the public facade', async () => {
+  const { createLlmSlice } = await import('../src/stores/llmSlice.ts')
+  let state
+  const set = update => {
+    const partial = typeof update === 'function' ? update(state) : update
+    state = { ...state, ...partial }
+  }
+  state = createLlmSlice(set, () => state)
+  assert.equal(state.llmStatus, null)
+  assert.equal(state.llmLoading, false)
+  assert.deepEqual(state.llmModels, [])
+  assert.equal(state.isEnhancing, false)
+  assert.equal(state.h3WindowPlan, null)
+
+  const window = {
+    index: 1,
+    title: 'open',
+    start_frame: 0,
+    end_frame: 24,
+    start_seconds: 0,
+    end_seconds: 1,
+    opening_state: '',
+    closing_state: '',
+    prompt: 'a man walks',
+  }
+  set({
+    h3WindowPlan: {
+      source_prompt: 'walk',
+      signature: 'sig',
+      planned_by: 'llm',
+      total_frames: 24,
+      window_frames: 24,
+      window_count: 1,
+      resolution: '540p',
+      model_type: 'minimax_h3',
+      windows: [window],
+      window_prompts: [window.prompt],
+    },
+  })
+  state.updateH3WindowPrompt(0, 'a woman walks')
+  assert.equal(state.h3WindowPlan.windows[0].prompt, 'a woman walks')
+  assert.deepEqual(state.h3WindowPlan.window_prompts, ['a woman walks'])
+  state.updateH3WindowPrompt(-1, 'ignored')
+  assert.equal(state.h3WindowPlan.windows[0].prompt, 'a woman walks')
+  state.clearH3WindowPlan()
+  assert.equal(state.h3WindowPlan, null)
+
+  const isolated = createLlmSlice(set, () => state)
+  assert.equal('startGeneration' in isolated, false)
+  assert.equal('stopGeneration' in isolated, false)
+  assert.equal('settingsOpen' in isolated, false)
+  assert.equal('reconnectJobs' in isolated, false)
+
+  const { useStore } = await import('../src/stores/useStore.ts')
+  assert.equal(typeof useStore.getState().loadLlmStatus, 'function')
+  assert.equal(typeof useStore.getState().loadLlmModels, 'function')
+  assert.equal(typeof useStore.getState().loadLlm, 'function')
+  assert.equal(typeof useStore.getState().unloadLlm, 'function')
+  assert.equal(typeof useStore.getState().enhancePrompt, 'function')
+  assert.equal(typeof useStore.getState().updateH3WindowPrompt, 'function')
+  assert.equal(typeof useStore.getState().clearH3WindowPlan, 'function')
+  useStore.getState().clearH3WindowPlan()
+  assert.equal(useStore.getState().h3WindowPlan, null)
+})
+
 test('composed slices bind without as-never casts at the useStore call site', async () => {
   const fs = await import('node:fs/promises')
   const source = await fs.readFile(new URL('../src/stores/useStore.ts', import.meta.url), 'utf8')
@@ -280,6 +346,7 @@ test('composed slices bind without as-never casts at the useStore call site', as
   assert.match(composition, /bindSlice\(set, get, createSettingsSlice\)/)
   assert.match(composition, /bindSlice\(set, get, createThemeSlice\)/)
   assert.match(composition, /bindSlice\(set, get, createGallerySlice\)/)
+  assert.match(composition, /bindSlice\(set, get, createLlmSlice\)/)
   assert.doesNotMatch(composition, /as never/)
 })