refactor: FSD 구조 강화 및 파일 500줄 제한에 따른 대규모 리팩토링

- SpaceWorkspaceWidget 로직을 전용 훅 및 유틸리티로 분리 (900줄 -> 300줄)
- useSpaceWorkspaceSelection 훅을 기능별(영속성, 진단 등) 소형 훅으로 분리
- SpaceToolsDockWidget의 상태 및 핸들러 로직 추출
- 거대 i18n 번역 파일(ko.ts)을 도메인별 메시지 파일로 구조화
- AdminConsoleWidget 누락분 추가 및 미디어 엔티티 타입 오류 수정

src/widgets/space-workspace/model/types.ts

@@ -0,0 +1,15 @@
+export type WorkspaceMode = 'setup' | 'focus';
+export type SessionEntryPoint = 'space-setup' | 'goal-complete' | 'resume-restore';
+
+export type SelectionOverride = {
+  sound: boolean;
+  timer: boolean;
+};
+
+export interface StoredWorkspaceSelection {
+  sceneId?: string;
+  timerPresetId?: string;
+  soundPresetId?: string;
+  goal?: string;
+  override?: Partial<SelectionOverride>;
+}

src/widgets/space-workspace/model/useSpaceWorkspaceSelection.ts

@@ -0,0 +1,440 @@
+'use client';
+
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import type { SceneAssetMap } from '@/entities/media';
+import {
+  getSceneById,
+  normalizeSceneId,
+  SCENE_THEMES,
+  type SceneTheme,
+} from '@/entities/scene';
+import {
+  SOUND_PRESETS,
+  type GoalChip,
+} from '@/entities/session';
+import type { FocusSession } from '@/features/focus-session';
+import { preferencesApi } from '@/features/preferences/api/preferencesApi';
+import { copy } from '@/shared/i18n';
+import type { HudStatusLinePayload } from '@/shared/lib/useHudStatusLine';
+import type { SelectionOverride } from './types';
+import {
+  readStoredWorkspaceSelection,
+  resolveTimerLabelFromPresetId,
+  resolveTimerPresetIdFromLabel,
+} from './workspaceSelection';
+import { useWorkspacePersistence } from './useWorkspacePersistence';
+import { useWorkspaceMediaDiagnostics } from './useWorkspaceMediaDiagnostics';
+
+interface UseSpaceWorkspaceSelectionParams {
+  initialSceneId: string;
+  initialGoal: string;
+  initialTimerLabel: string;
+  sceneQuery: string | null;
+  goalQuery: string;
+  soundQuery: string | null;
+  timerQuery: string | null;
+  hasQueryOverrides: boolean;
+  currentSession: FocusSession | null;
+  sceneAssetMap: SceneAssetMap;
+  selectedPresetId: string;
+  setSelectedPresetId: (presetId: string) => void;
+  shouldPlaySound: boolean;
+  unlockPlayback: (requestedUrl?: string | null) => Promise<boolean>;
+  resolveSoundPlaybackUrl: (presetId: string) => string | null;
+  pushStatusLine: (payload: HudStatusLinePayload) => void;
+  updateCurrentSelection: (payload: {
+    sceneId?: string;
+    soundPresetId?: string | null;
+  }) => Promise<FocusSession | null>;
+  mediaCatalogError: string | null;
+  usedFallbackManifest: boolean;
+  hasResolvedManifest: boolean;
+}
+
+const getVisibleSetupScenes = (selectedScene: SceneTheme) => {
+  const visibleScenes = SCENE_THEMES.slice(0, 6);
+
+  if (visibleScenes.some((scene) => scene.id === selectedScene.id)) {
+    return visibleScenes;
+  }
+
+  return [selectedScene, ...visibleScenes].slice(0, 6);
+};
+
+export const useSpaceWorkspaceSelection = ({
+  initialSceneId,
+  initialGoal,
+  initialTimerLabel,
+  sceneQuery,
+  goalQuery,
+  soundQuery,
+  timerQuery,
+  hasQueryOverrides,
+  currentSession,
+  sceneAssetMap,
+  selectedPresetId,
+  setSelectedPresetId,
+  shouldPlaySound,
+  unlockPlayback,
+  resolveSoundPlaybackUrl,
+  pushStatusLine,
+  updateCurrentSelection,
+  mediaCatalogError,
+  usedFallbackManifest,
+  hasResolvedManifest,
+}: UseSpaceWorkspaceSelectionParams) => {
+  const [selectedSceneId, setSelectedSceneId] = useState(initialSceneId);
+  const [selectedTimerLabel, setSelectedTimerLabel] = useState(initialTimerLabel);
+  const [goalInput, setGoalInput] = useState(initialGoal);
+  const [selectedGoalId, setSelectedGoalId] = useState<string | null>(null);
+  const [resumeGoal, setResumeGoal] = useState('');
+  const [showResumePrompt, setShowResumePrompt] = useState(false);
+  const [hasHydratedSelection, setHasHydratedSelection] = useState(false);
+  const [selectionOverride, setSelectionOverride] = useState<SelectionOverride>({
+    sound: false,
+    timer: false,
+  });
+  const didHydrateServerPreferencesRef = useRef(false);
+
+  const selectedScene = useMemo(() => {
+    return getSceneById(selectedSceneId) ?? SCENE_THEMES[0];
+  }, [selectedSceneId]);
+
+  const selectedSceneAsset = sceneAssetMap[selectedScene.id];
+
+  const setupScenes = useMemo(() => {
+    return getVisibleSetupScenes(selectedScene);
+  }, [selectedScene]);
+
+  const canStart = goalInput.trim().length > 0;
+
+  const applyRecommendedSelections = useCallback((
+    sceneId: string,
+    overrideState: SelectionOverride = selectionOverride,
+  ) => {
+    const scene = getSceneById(sceneId);
+
+    if (!scene) {
+      return;
+    }
+
+    if (!overrideState.timer) {
+      const recommendedTimerLabel = resolveTimerLabelFromPresetId(scene.recommendedTimerPresetId);
+
+      if (recommendedTimerLabel) {
+        setSelectedTimerLabel(recommendedTimerLabel);
+      }
+    }
+
+    if (
+      !overrideState.sound &&
+      SOUND_PRESETS.some((preset) => preset.id === scene.recommendedSoundPresetId)
+    ) {
+      setSelectedPresetId(scene.recommendedSoundPresetId);
+    }
+  }, [selectionOverride, setSelectedPresetId]);
+
+  const persistSpaceSelection = useCallback((selection: {
+    sceneId?: string;
+    soundPresetId?: string | null;
+  }) => {
+    const preferencePayload: {
+      defaultSceneId?: string | null;
+      defaultSoundPresetId?: string | null;
+    } = {};
+    const currentSessionPayload: {
+      sceneId?: string;
+      soundPresetId?: string | null;
+    } = {};
+
+    if (selection.sceneId !== undefined) {
+      preferencePayload.defaultSceneId = selection.sceneId;
+      currentSessionPayload.sceneId = selection.sceneId;
+    }
+
+    if (selection.soundPresetId !== undefined) {
+      preferencePayload.defaultSoundPresetId = selection.soundPresetId;
+      currentSessionPayload.soundPresetId = selection.soundPresetId;
+    }
+
+    void (async () => {
+      const [preferencesResult, sessionResult] = await Promise.allSettled([
+        preferencesApi.updateFocusPreferences(preferencePayload),
+        currentSession ? updateCurrentSelection(currentSessionPayload) : Promise.resolve(null),
+      ]);
+
+      if (preferencesResult.status === 'rejected') {
+        pushStatusLine({
+          message: copy.space.workspace.selectionPreferenceSaveFailed,
+        });
+      }
+
+      if (
+        currentSession &&
+        (sessionResult.status === 'rejected' || sessionResult.value === null)
+      ) {
+        pushStatusLine({
+          message: copy.space.workspace.selectionSessionSyncFailed,
+        });
+      }
+    })();
+  }, [currentSession, pushStatusLine, updateCurrentSelection]);
+
+  const handleSelectScene = useCallback((sceneId: string) => {
+    void (async () => {
+      const normalizedSceneId = normalizeSceneId(sceneId) ?? sceneId;
+      const recommendedScene = getSceneById(normalizedSceneId);
+      const nextSoundPresetId =
+        recommendedScene &&
+        !selectionOverride.sound &&
+        SOUND_PRESETS.some((preset) => preset.id === recommendedScene.recommendedSoundPresetId)
+          ? recommendedScene.recommendedSoundPresetId
+          : selectedPresetId;
+
+      if (shouldPlaySound) {
+        await unlockPlayback(resolveSoundPlaybackUrl(nextSoundPresetId));
+      }
+
+      setSelectedSceneId(normalizedSceneId);
+      applyRecommendedSelections(normalizedSceneId);
+      persistSpaceSelection({
+        sceneId: normalizedSceneId,
+        soundPresetId: nextSoundPresetId,
+      });
+    })();
+  }, [
+    applyRecommendedSelections,
+    persistSpaceSelection,
+    resolveSoundPlaybackUrl,
+    selectedPresetId,
+    selectionOverride.sound,
+    shouldPlaySound,
+    unlockPlayback,
+  ]);
+
+  const handleSelectTimer = useCallback((timerLabel: string, markOverride = false) => {
+    setSelectedTimerLabel(timerLabel);
+
+    if (!markOverride) {
+      return;
+    }
+
+    setSelectionOverride((current) => {
+      if (current.timer) {
+        return current;
+      }
+
+      return { ...current, timer: true };
+    });
+  }, []);
+
+  const handleSelectSound = useCallback((presetId: string, markOverride = false) => {
+    void (async () => {
+      if (shouldPlaySound) {
+        await unlockPlayback(resolveSoundPlaybackUrl(presetId));
+      }
+
+      setSelectedPresetId(presetId);
+
+      if (!markOverride) {
+        return;
+      }
+
+      setSelectionOverride((current) => {
+        if (current.sound) {
+          return current;
+        }
+
+        return { ...current, sound: true };
+      });
+
+      persistSpaceSelection({
+        soundPresetId: presetId,
+      });
+    })();
+  }, [
+    persistSpaceSelection,
+    resolveSoundPlaybackUrl,
+    setSelectedPresetId,
+    shouldPlaySound,
+    unlockPlayback,
+  ]);
+
+  const handleGoalChipSelect = useCallback((chip: GoalChip) => {
+    setShowResumePrompt(false);
+    setSelectedGoalId(chip.id);
+    setGoalInput(chip.label);
+  }, []);
+
+  const handleGoalChange = useCallback((value: string) => {
+    if (showResumePrompt) {
+      setShowResumePrompt(false);
+    }
+
+    setGoalInput(value);
+
+    if (value.trim().length === 0) {
+      setSelectedGoalId(null);
+    }
+  }, [showResumePrompt]);
+
+  useEffect(() => {
+    const storedSelection = readStoredWorkspaceSelection();
+    const restoredSelectionOverride: SelectionOverride = {
+      sound: Boolean(storedSelection.override?.sound),
+      timer: Boolean(storedSelection.override?.timer),
+    };
+    const restoredSceneId =
+      !sceneQuery && storedSelection.sceneId && getSceneById(storedSelection.sceneId)
+        ? normalizeSceneId(storedSelection.sceneId)
+        : null;
+    const restoredTimerLabel = !timerQuery
+      ? resolveTimerLabelFromPresetId(storedSelection.timerPresetId)
+      : null;
+    const restoredSoundPresetId =
+      !soundQuery && storedSelection.soundPresetId && SOUND_PRESETS.some((preset) => preset.id === storedSelection.soundPresetId)
+        ? storedSelection.soundPresetId
+        : null;
+    const restoredGoal = storedSelection.goal?.trim() ?? '';
+    const rafId = window.requestAnimationFrame(() => {
+      setSelectionOverride(restoredSelectionOverride);
+
+      if (restoredSceneId) {
+        setSelectedSceneId(restoredSceneId);
+      }
+
+      if (restoredTimerLabel) {
+        setSelectedTimerLabel(restoredTimerLabel);
+      }
+
+      if (restoredSoundPresetId) {
+        setSelectedPresetId(restoredSoundPresetId);
+      }
+
+      if (!goalQuery && restoredGoal.length > 0 && !hasQueryOverrides) {
+        setResumeGoal(restoredGoal);
+        setShowResumePrompt(true);
+      }
+
+      setHasHydratedSelection(true);
+    });
+
+    return () => {
+      window.cancelAnimationFrame(rafId);
+    };
+  }, [goalQuery, hasQueryOverrides, sceneQuery, setSelectedPresetId, soundQuery, timerQuery]);
+
+  useEffect(() => {
+    if (!hasHydratedSelection || didHydrateServerPreferencesRef.current) {
+      return;
+    }
+
+    didHydrateServerPreferencesRef.current = true;
+    let cancelled = false;
+
+    void preferencesApi
+      .getFocusPreferences()
+      .then((preferences) => {
+        if (cancelled || currentSession || hasQueryOverrides) {
+          return;
+        }
+
+        const normalizedPreferredSceneId = normalizeSceneId(preferences.defaultSceneId);
+        const nextSceneId =
+          normalizedPreferredSceneId && getSceneById(normalizedPreferredSceneId)
+            ? normalizedPreferredSceneId
+            : null;
+        const nextSoundPresetId =
+          preferences.defaultSoundPresetId &&
+          SOUND_PRESETS.some((preset) => preset.id === preferences.defaultSoundPresetId)
+            ? preferences.defaultSoundPresetId
+            : null;
+
+        if (nextSceneId) {
+          setSelectedSceneId(nextSceneId);
+        }
+
+        if (nextSoundPresetId) {
+          setSelectedPresetId(nextSoundPresetId);
+          setSelectionOverride((current) => ({ ...current, sound: true }));
+        }
+      })
+      .catch(() => {
+        // Focus preference load failure should not block entering the space.
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [currentSession, hasHydratedSelection, hasQueryOverrides, setSelectedPresetId]);
+
+  useEffect(() => {
+    if (!currentSession) {
+      return;
+    }
+
+    const nextTimerLabel =
+      resolveTimerLabelFromPresetId(currentSession.timerPresetId) ?? selectedTimerLabel;
+    const nextSoundPresetId =
+      currentSession.soundPresetId &&
+      SOUND_PRESETS.some((preset) => preset.id === currentSession.soundPresetId)
+        ? currentSession.soundPresetId
+        : selectedPresetId;
+    const rafId = window.requestAnimationFrame(() => {
+      setSelectedSceneId(normalizeSceneId(currentSession.sceneId) ?? currentSession.sceneId);
+      setSelectedTimerLabel(nextTimerLabel);
+      setSelectedPresetId(nextSoundPresetId);
+      setGoalInput(currentSession.goal);
+      setSelectedGoalId(null);
+      setShowResumePrompt(false);
+    });
+
+    return () => {
+      window.cancelAnimationFrame(rafId);
+    };
+  }, [currentSession, selectedPresetId, selectedTimerLabel, setSelectedPresetId]);
+
+  useWorkspacePersistence({
+    hasHydratedSelection,
+    selectedScene,
+    selectedTimerPresetId: resolveTimerPresetIdFromLabel(selectedTimerLabel),
+    selectedPresetId,
+    goalInput,
+    showResumePrompt,
+    resumeGoal,
+    selectionOverride,
+  });
+
+  useWorkspaceMediaDiagnostics({
+    mediaCatalogError,
+    pushStatusLine,
+    selectedScene,
+    hasResolvedManifest,
+    usedFallbackManifest,
+    selectedSceneAsset,
+  });
+
+  return {
+    selectedSceneId,
+    selectedTimerLabel,
+    goalInput,
+    selectedGoalId,
+    resumeGoal,
+    showResumePrompt,
+    hasHydratedSelection,
+    selectionOverride,
+    selectedScene,
+    selectedSceneAsset,
+    setupScenes,
+    canStart,
+    setGoalInput,
+    setSelectedGoalId,
+    setShowResumePrompt,
+    setResumeGoal,
+    handleSelectScene,
+    handleSelectTimer,
+    handleSelectSound,
+    handleGoalChipSelect,
+    handleGoalChange,
+  };
+};

src/widgets/space-workspace/model/useSpaceWorkspaceSessionControls.ts

@@ -0,0 +1,316 @@
+'use client';
+
+import { useCallback, useEffect, useRef, useState } from 'react';
+import type { FocusSession } from '@/features/focus-session';
+import { copy } from '@/shared/i18n';
+import type { HudStatusLinePayload } from '@/shared/lib/useHudStatusLine';
+import { resolveTimerPresetIdFromLabel } from './workspaceSelection';
+import type { SessionEntryPoint, WorkspaceMode } from './types';
+
+interface UseSpaceWorkspaceSessionControlsParams {
+  canStart: boolean;
+  currentSession: FocusSession | null;
+  goalInput: string;
+  selectedSceneId: string;
+  selectedTimerLabel: string;
+  selectedPresetId: string;
+  soundPlaybackError: string | null;
+  pushStatusLine: (payload: HudStatusLinePayload) => void;
+  unlockPlayback: (requestedUrl?: string | null) => Promise<boolean>;
+  resolveSoundPlaybackUrl: (presetId: string) => string | null;
+  startSession: (input: {
+    sceneId: string;
+    goal: string;
+    timerPresetId: string;
+    soundPresetId: string;
+    entryPoint: SessionEntryPoint;
+  }) => Promise<FocusSession | null>;
+  pauseSession: () => Promise<FocusSession | null>;
+  resumeSession: () => Promise<FocusSession | null>;
+  restartCurrentPhase: () => Promise<FocusSession | null>;
+  completeSession: (input: {
+    completionType: 'goal-complete';
+    completedGoal: string;
+  }) => Promise<FocusSession | null>;
+  abandonSession: () => Promise<boolean>;
+  setGoalInput: (value: string) => void;
+  setSelectedGoalId: (value: string | null) => void;
+  setShowResumePrompt: (value: boolean) => void;
+}
+
+export const useSpaceWorkspaceSessionControls = ({
+  canStart,
+  currentSession,
+  goalInput,
+  selectedSceneId,
+  selectedTimerLabel,
+  selectedPresetId,
+  soundPlaybackError,
+  pushStatusLine,
+  unlockPlayback,
+  resolveSoundPlaybackUrl,
+  startSession,
+  pauseSession,
+  resumeSession,
+  restartCurrentPhase,
+  completeSession,
+  abandonSession,
+  setGoalInput,
+  setSelectedGoalId,
+  setShowResumePrompt,
+}: UseSpaceWorkspaceSessionControlsParams) => {
+  const [workspaceMode, setWorkspaceMode] = useState<WorkspaceMode>('setup');
+  const [previewPlaybackState, setPreviewPlaybackState] = useState<'running' | 'paused'>('paused');
+  const [pendingSessionEntryPoint, setPendingSessionEntryPoint] =
+    useState<SessionEntryPoint>('space-setup');
+  const queuedFocusStatusMessageRef = useRef<string | null>(null);
+  const lastSoundPlaybackErrorRef = useRef<string | null>(null);
+
+  const resolvedPlaybackState = currentSession?.state ?? previewPlaybackState;
+  const isFocusMode = workspaceMode === 'focus';
+  const canStartSession = canStart && (!currentSession || resolvedPlaybackState !== 'running');
+  const canPauseSession = Boolean(currentSession && resolvedPlaybackState === 'running');
+  const canRestartSession = Boolean(currentSession);
+
+  const openFocusMode = useCallback((
+    nextGoal: string,
+    entryPoint: SessionEntryPoint = 'space-setup',
+  ) => {
+    const trimmedGoal = nextGoal.trim();
+
+    if (!trimmedGoal) {
+      return;
+    }
+
+    setShowResumePrompt(false);
+    setPendingSessionEntryPoint(entryPoint);
+    setPreviewPlaybackState('paused');
+    setWorkspaceMode('focus');
+    queuedFocusStatusMessageRef.current = copy.space.workspace.readyToStart;
+  }, [setShowResumePrompt]);
+
+  const startFocusFlow = useCallback(async () => {
+    const trimmedGoal = goalInput.trim();
+    const timerPresetId = resolveTimerPresetIdFromLabel(selectedTimerLabel);
+
+    if (!trimmedGoal || !timerPresetId) {
+      return;
+    }
+
+    const startedSession = await startSession({
+      sceneId: selectedSceneId,
+      goal: trimmedGoal,
+      timerPresetId,
+      soundPresetId: selectedPresetId,
+      entryPoint: pendingSessionEntryPoint,
+    });
+
+    if (startedSession) {
+      setPreviewPlaybackState('running');
+      return;
+    }
+
+    setPreviewPlaybackState('paused');
+    pushStatusLine({
+      message: copy.space.workspace.startFailed,
+    });
+  }, [
+    goalInput,
+    pendingSessionEntryPoint,
+    pushStatusLine,
+    selectedPresetId,
+    selectedSceneId,
+    selectedTimerLabel,
+    startSession,
+  ]);
+
+  const handleSetupFocusOpen = useCallback(() => {
+    if (!canStart) {
+      return;
+    }
+
+    openFocusMode(goalInput, 'space-setup');
+  }, [canStart, goalInput, openFocusMode]);
+
+  const handleStartRequested = useCallback(async () => {
+    if (!canStartSession) {
+      return;
+    }
+
+    await unlockPlayback(resolveSoundPlaybackUrl(selectedPresetId));
+
+    if (!currentSession) {
+      await startFocusFlow();
+      return;
+    }
+
+    const resumedSession = await resumeSession();
+
+    if (!resumedSession) {
+      pushStatusLine({
+        message: copy.space.workspace.resumeFailed,
+      });
+    }
+  }, [
+    canStartSession,
+    currentSession,
+    pushStatusLine,
+    resolveSoundPlaybackUrl,
+    resumeSession,
+    selectedPresetId,
+    startFocusFlow,
+    unlockPlayback,
+  ]);
+
+  const handleExitRequested = useCallback(async () => {
+    const didAbandon = await abandonSession();
+
+    if (!didAbandon) {
+      pushStatusLine({
+        message: copy.space.workspace.abandonFailed,
+      });
+      return;
+    }
+
+    setPreviewPlaybackState('paused');
+    setPendingSessionEntryPoint('space-setup');
+    setWorkspaceMode('setup');
+  }, [abandonSession, pushStatusLine]);
+
+  const handlePauseRequested = useCallback(async () => {
+    if (!currentSession) {
+      setPreviewPlaybackState('paused');
+      return;
+    }
+
+    const pausedSession = await pauseSession();
+
+    if (!pausedSession) {
+      pushStatusLine({
+        message: copy.space.workspace.pauseFailed,
+      });
+    }
+  }, [currentSession, pauseSession, pushStatusLine]);
+
+  const handleRestartRequested = useCallback(async () => {
+    if (!currentSession) {
+      return;
+    }
+
+    const restartedSession = await restartCurrentPhase();
+
+    if (!restartedSession) {
+      pushStatusLine({
+        message: copy.space.workspace.restartFailed,
+      });
+      return;
+    }
+
+    pushStatusLine({
+      message: copy.space.workspace.restarted,
+    });
+  }, [currentSession, pushStatusLine, restartCurrentPhase]);
+
+  const handleGoalAdvance = useCallback(async (nextGoal: string) => {
+    const trimmedNextGoal = nextGoal.trim();
+
+    if (!trimmedNextGoal) {
+      return;
+    }
+
+    if (currentSession) {
+      const completedSession = await completeSession({
+        completionType: 'goal-complete',
+        completedGoal: goalInput.trim(),
+      });
+
+      if (!completedSession) {
+        pushStatusLine({
+          message: copy.space.workspace.goalCompleteSyncFailed,
+        });
+        return;
+      }
+    }
+
+    setGoalInput(trimmedNextGoal);
+    setSelectedGoalId(null);
+    setPendingSessionEntryPoint('goal-complete');
+    setPreviewPlaybackState('paused');
+    pushStatusLine({
+      message: copy.space.workspace.nextGoalReady,
+    });
+  }, [completeSession, currentSession, goalInput, pushStatusLine, setGoalInput, setSelectedGoalId]);
+
+  useEffect(() => {
+    const previousBodyOverflow = document.body.style.overflow;
+    const previousHtmlOverflow = document.documentElement.style.overflow;
+
+    document.body.style.overflow = 'hidden';
+    document.documentElement.style.overflow = 'hidden';
+
+    return () => {
+      document.body.style.overflow = previousBodyOverflow;
+      document.documentElement.style.overflow = previousHtmlOverflow;
+    };
+  }, []);
+
+  useEffect(() => {
+    if (!currentSession) {
+      return;
+    }
+
+    const rafId = window.requestAnimationFrame(() => {
+      setPreviewPlaybackState(currentSession.state);
+      setWorkspaceMode('focus');
+    });
+
+    return () => {
+      window.cancelAnimationFrame(rafId);
+    };
+  }, [currentSession]);
+
+  useEffect(() => {
+    if (!isFocusMode || !queuedFocusStatusMessageRef.current) {
+      return;
+    }
+
+    const message = queuedFocusStatusMessageRef.current;
+    queuedFocusStatusMessageRef.current = null;
+    pushStatusLine({
+      message,
+    });
+  }, [isFocusMode, pushStatusLine]);
+
+  useEffect(() => {
+    if (!soundPlaybackError) {
+      lastSoundPlaybackErrorRef.current = null;
+      return;
+    }
+
+    if (soundPlaybackError === lastSoundPlaybackErrorRef.current) {
+      return;
+    }
+
+    lastSoundPlaybackErrorRef.current = soundPlaybackError;
+    pushStatusLine({
+      message: soundPlaybackError,
+    });
+  }, [pushStatusLine, soundPlaybackError]);
+
+  return {
+    workspaceMode,
+    isFocusMode,
+    previewPlaybackState,
+    resolvedPlaybackState,
+    canStartSession,
+    canPauseSession,
+    canRestartSession,
+    openFocusMode,
+    handleSetupFocusOpen,
+    handleStartRequested,
+    handleExitRequested,
+    handlePauseRequested,
+    handleRestartRequested,
+    handleGoalAdvance,
+  };
+};

src/widgets/space-workspace/model/useWorkspaceMediaDiagnostics.ts

@@ -0,0 +1,70 @@
+'use client';
+
+import { useEffect, useRef } from 'react';
+import type { HudStatusLinePayload } from '@/shared/lib/useHudStatusLine';
+import type { SceneTheme } from '@/entities/scene';
+import type { SceneAssetManifestItem } from '@/entities/media';
+
+interface UseWorkspaceMediaDiagnosticsParams {
+  mediaCatalogError: string | null;
+  pushStatusLine: (payload: HudStatusLinePayload) => void;
+  selectedScene: SceneTheme;
+  hasResolvedManifest: boolean;
+  usedFallbackManifest: boolean;
+  selectedSceneAsset: SceneAssetManifestItem | undefined;
+}
+
+export const useWorkspaceMediaDiagnostics = ({
+  mediaCatalogError,
+  pushStatusLine,
+  selectedScene,
+  hasResolvedManifest,
+  usedFallbackManifest,
+  selectedSceneAsset,
+}: UseWorkspaceMediaDiagnosticsParams) => {
+  const lastMediaManifestErrorRef = useRef<string | null>(null);
+  const lastFallbackSceneDiagnosticRef = useRef<string | null>(null);
+
+  useEffect(() => {
+    if (!mediaCatalogError) {
+      lastMediaManifestErrorRef.current = null;
+      return;
+    }
+
+    if (mediaCatalogError === lastMediaManifestErrorRef.current) {
+      return;
+    }
+
+    lastMediaManifestErrorRef.current = mediaCatalogError;
+    console.error('[media] Failed to load remote media manifest.', {
+      error: mediaCatalogError,
+      sceneId: selectedScene.id,
+    });
+    pushStatusLine({
+      message: mediaCatalogError,
+    });
+  }, [mediaCatalogError, pushStatusLine, selectedScene.id]);
+
+  useEffect(() => {
+    if (!hasResolvedManifest || usedFallbackManifest) {
+      return;
+    }
+
+    const isUsingFallbackSceneAsset = !selectedSceneAsset || selectedSceneAsset.source === 'fallback';
+
+    if (!isUsingFallbackSceneAsset) {
+      lastFallbackSceneDiagnosticRef.current = null;
+      return;
+    }
+
+    if (lastFallbackSceneDiagnosticRef.current === selectedScene.id) {
+      return;
+    }
+
+    lastFallbackSceneDiagnosticRef.current = selectedScene.id;
+    console.warn('[space] Selected scene is using fallback asset data.', {
+      sceneId: selectedScene.id,
+      asset: selectedSceneAsset ?? null,
+    });
+  }, [hasResolvedManifest, selectedScene.id, selectedSceneAsset, usedFallbackManifest]);
+};

src/widgets/space-workspace/model/useWorkspacePersistence.ts

@@ -0,0 +1,60 @@
+'use client';
+
+import { useEffect } from 'react';
+import { WORKSPACE_SELECTION_STORAGE_KEY } from './workspaceSelection';
+import type { SelectionOverride } from './types';
+import type { SceneTheme } from '@/entities/scene';
+
+interface UseWorkspacePersistenceParams {
+  hasHydratedSelection: boolean;
+  selectedScene: SceneTheme;
+  selectedTimerPresetId: string | undefined;
+  selectedPresetId: string;
+  goalInput: string;
+  showResumePrompt: boolean;
+  resumeGoal: string;
+  selectionOverride: SelectionOverride;
+}
+
+export const useWorkspacePersistence = ({
+  hasHydratedSelection,
+  selectedScene,
+  selectedTimerPresetId,
+  selectedPresetId,
+  goalInput,
+  showResumePrompt,
+  resumeGoal,
+  selectionOverride,
+}: UseWorkspacePersistenceParams) => {
+  useEffect(() => {
+    if (typeof window === 'undefined' || !hasHydratedSelection) {
+      return;
+    }
+
+    const normalizedGoal = goalInput.trim().length > 0
+      ? goalInput.trim()
+      : showResumePrompt
+        ? resumeGoal
+        : '';
+
+    window.localStorage.setItem(
+      WORKSPACE_SELECTION_STORAGE_KEY,
+      JSON.stringify({
+        sceneId: selectedScene.id,
+        timerPresetId: selectedTimerPresetId,
+        soundPresetId: selectedPresetId,
+        goal: normalizedGoal,
+        override: selectionOverride,
+      }),
+    );
+  }, [
+    goalInput,
+    hasHydratedSelection,
+    resumeGoal,
+    selectedPresetId,
+    selectedScene.id,
+    selectedTimerPresetId,
+    selectionOverride,
+    showResumePrompt,
+  ]);
+};

src/widgets/space-workspace/model/workspaceSelection.ts

@@ -0,0 +1,140 @@
+import {
+  getSceneById,
+  normalizeSceneId,
+  SCENE_THEMES,
+} from '@/entities/scene';
+import {
+  SOUND_PRESETS,
+  TIMER_PRESETS,
+  type TimerPreset,
+} from '@/entities/session';
+
+export type SelectionOverride = {
+  sound: boolean;
+  timer: boolean;
+};
+
+export interface StoredWorkspaceSelection {
+  sceneId?: string;
+  timerPresetId?: string;
+  soundPresetId?: string;
+  goal?: string;
+  override?: Partial<SelectionOverride>;
+}
+
+export const WORKSPACE_SELECTION_STORAGE_KEY = 'viberoom:workspace-selection:v1';
+
+export const readStoredWorkspaceSelection = (): StoredWorkspaceSelection => {
+  if (typeof window === 'undefined') {
+    return {};
+  }
+
+  const raw = window.localStorage.getItem(WORKSPACE_SELECTION_STORAGE_KEY);
+
+  if (!raw) {
+    return {};
+  }
+
+  try {
+    const parsed = JSON.parse(raw);
+
+    if (!parsed || typeof parsed !== 'object') {
+      return {};
+    }
+
+    return parsed as StoredWorkspaceSelection;
+  } catch {
+    return {};
+  }
+};
+
+export const resolveInitialSceneId = (
+  sceneIdFromQuery: string | null,
+  storedSceneId?: string,
+) => {
+  const normalizedQuerySceneId = normalizeSceneId(sceneIdFromQuery);
+  if (normalizedQuerySceneId && getSceneById(normalizedQuerySceneId)) {
+    return normalizedQuerySceneId;
+  }
+
+  const normalizedStoredSceneId = normalizeSceneId(storedSceneId);
+  if (normalizedStoredSceneId && getSceneById(normalizedStoredSceneId)) {
+    return normalizedStoredSceneId;
+  }
+
+  return SCENE_THEMES[0].id;
+};
+
+export const resolveInitialSoundPreset = (
+  presetIdFromQuery: string | null,
+  storedPresetId: string | undefined,
+  recommendedPresetId?: string,
+) => {
+  if (presetIdFromQuery && SOUND_PRESETS.some((preset) => preset.id === presetIdFromQuery)) {
+    return presetIdFromQuery;
+  }
+
+  if (storedPresetId && SOUND_PRESETS.some((preset) => preset.id === storedPresetId)) {
+    return storedPresetId;
+  }
+
+  if (recommendedPresetId && SOUND_PRESETS.some((preset) => preset.id === recommendedPresetId)) {
+    return recommendedPresetId;
+  }
+
+  return SOUND_PRESETS[0].id;
+};
+
+export const TIMER_SELECTION_PRESETS = TIMER_PRESETS.filter(
+  (preset): preset is TimerPreset & { focusMinutes: number; breakMinutes: number } =>
+    typeof preset.focusMinutes === 'number' && typeof preset.breakMinutes === 'number',
+).slice(0, 3);
+
+export const resolveTimerLabelFromPresetId = (presetId?: string) => {
+  if (!presetId) {
+    return null;
+  }
+
+  const preset = TIMER_SELECTION_PRESETS.find((candidate) => candidate.id === presetId);
+
+  if (!preset) {
+    return null;
+  }
+
+  return preset.label;
+};
+
+export const resolveTimerPresetIdFromLabel = (timerLabel: string) => {
+  const preset = TIMER_SELECTION_PRESETS.find((candidate) => candidate.label === timerLabel);
+  return preset?.id;
+};
+
+export const resolveInitialTimerLabel = (
+  timerLabelFromQuery: string | null,
+  storedPresetId?: string,
+  recommendedPresetId?: string,
+) => {
+  if (timerLabelFromQuery && TIMER_SELECTION_PRESETS.some((preset) => preset.label === timerLabelFromQuery)) {
+    return timerLabelFromQuery;
+  }
+
+  const storedLabel = resolveTimerLabelFromPresetId(storedPresetId);
+
+  if (storedLabel) {
+    return storedLabel;
+  }
+
+  const recommendedLabel = resolveTimerLabelFromPresetId(recommendedPresetId);
+
+  if (recommendedLabel) {
+    return recommendedLabel;
+  }
+
+  return TIMER_SELECTION_PRESETS[0]?.label ?? '25/5';
+};
+
+export const resolveFocusTimeDisplayFromTimerLabel = (timerLabel: string) => {
+  const preset = TIMER_SELECTION_PRESETS.find((candidate) => candidate.label === timerLabel);
+  const focusMinutes = preset?.focusMinutes ?? 25;
+  return `${String(focusMinutes).padStart(2, '0')}:00`;
+};