릴리스: v1.4.8 주제 헤더 안정화와 검색 헤더 통일

릴리스: v1.4.7 컬렉션 레이아웃 정리와 topics 경로 1차
릴리스: v1.4.6 관리자 내부 명칭 정리 2차
2026-04-02 18:50:21 +09:00 · 2026-04-02 18:47:37 +09:00 · 2026-04-02 18:43:39 +09:00 · 2026-04-02 18:26:18 +09:00 · 2026-04-02 18:20:13 +09:00 · 2026-04-02 18:17:50 +09:00
19 changed files with 624 additions and 625 deletions
--- a/docs/history.md
+++ b/docs/history.md
@@ -1,5 +1,31 @@
 # 의사결정 이력

+## 2026-04-02 v1.4.8
+- 주제 상세 화면 제목은 내부 ID를 잠깐 보여주는 것보다, 로딩 문구를 거쳐 실제 이름으로 자연스럽게 바뀌는 편이 사용자 체감상 더 안정적이라고 판단했다.
+- 주요 목록 화면은 `pageHead` 문법을 계속 통일해 두는 편이, 이후 검색/필터 툴바를 더 붙이더라도 구조를 예측하기 쉽다고 판단했다.
+
+## 2026-04-02 v1.4.7
+- 주제 상세 컬렉션 화면도 즐겨찾기·나의 티어표와 같은 `pageHead` 문법으로 맞춰야, 네비게이션으로 이동하는 주요 화면들의 리듬이 더 자연스럽다고 판단했다.
+- 라우트 전환은 한 번에 `/games`를 없애기보다, 먼저 `/topics`를 기본 진입 경로로 세우고 기존 `/games`는 alias로 유지하는 점진 전환이 더 안전하다고 정리했다.
+
+## 2026-04-02 v1.4.6
+- 내부 리네이밍 2단계는 관리자 화면처럼 상태와 액션이 많은 영역부터 정리해 두는 편이, 이후 `/games` 라우트와 API 계층을 손볼 때 위험을 줄이는 데 더 유리하다고 판단했다.
+
+## 2026-04-02 v1.4.5
+- 내부 리네이밍은 한 번에 API와 DB까지 건드리기보다, 홈·주제 화면·에디터처럼 영향 범위가 비교적 명확한 프런트 핵심 흐름부터 `game` 의존 이름을 줄여 나가는 편이 더 안전하다고 판단했다.
+
+## 2026-04-02 v1.4.4
+- 용어 정리 마무리 단계에서는 눈에 잘 띄는 영어 헤더를 그대로 두기보다, 홈과 관리자처럼 진입 빈도가 높은 화면의 상단 라벨까지 한국어로 맞춰야 전체 제품 인상이 더 자연스럽다고 판단했다.
+
+## 2026-04-02 v1.4.3
+- 용어 전환은 메뉴 타이틀만 바꾸는 것으로 끝나지 않고, 관리자 작업 중 반복해서 보게 되는 토스트와 확인창까지 맞춰야 실제 체감 일관성이 살아난다고 판단했다.
+
+## 2026-04-02 v1.4.2
+- 용어 정리를 시작한 뒤에는 일부 화면만 바꾸는 것보다, 관리자 모달과 확인 메시지처럼 실제 운영 중 많이 보는 문구도 함께 맞춰 주는 편이 체감 일관성이 더 높다고 판단했다.
+
+## 2026-04-02 v1.4.1
+- 좌측 메뉴와 화면 타이틀의 명칭이 서로 다르면 사용자가 현재 위치를 직관적으로 매칭하기 어렵기 때문에, 메뉴 이름과 진입 타이틀을 같은 문구로 맞추는 편이 맞다고 판단했다.
+
 ## 2026-04-02 v1.4.0
 - 서비스가 게임 외 주제 전반을 다룰 수 있는 단계에 온 만큼, 내부 모델명은 유지하더라도 사용자에게 보이는 주요 용어는 `주제 / 템플릿` 기준으로 먼저 정리하는 편이 맞다고 판단했다.
 - 대규모 내부 리네이밍은 API와 DB까지 손대야 하므로, 이번 단계에서는 사용자 화면 문구만 우선 바꾸고 내부 `game` 모델은 그대로 두는 점진적 전환이 더 안전하다고 정리했다.
--- a/docs/todo.md
+++ b/docs/todo.md
@@ -1,9 +1,17 @@
 # 할 일 및 이슈

 ## 단기 확인
- 용어 정리 1차는 사용자 노출 문구만 `주제 / 템플릿`으로 바꿨으므로, 홈/주제 화면/관리자 템플릿 관리에서 어색하게 남은 `게임` 문구가 없는지 한 번 더 QA한다.
+- 주제 상세 화면 제목은 ID fallback 대신 로딩 문구를 쓰도록 바꿨으므로, 직접 진입·뒤로가기·다른 주제로 연속 이동할 때 헤더가 깜빡이거나 이전 제목을 잠깐 유지하지 않는지 한 번 더 QA한다.
+- 검색 결과 화면도 `pageHead` 구조로 맞췄으므로, 주요 목록 화면들 간 상단 여백과 타이포 리듬이 자연스러운지 한 번 더 비교 QA한다.
+- 주제 상세 컬렉션 화면은 `pageHead` 공통 레이아웃과 `/topics` 기본 경로로 옮겼으므로, 직접 진입·뒤로가기·검색 후 재진입 시 주소와 헤더 흐름이 자연스러운지 한 번 더 QA한다.
+- `/topics/:gameId`를 기본 경로로 세우고 `/games/:gameId`는 alias로 남겼으므로, 다음 단계에서는 에디터/검색/공유 흐름에서 어떤 링크를 새 경로로 더 전환할지 범위를 정한다.
+- 내부 리네이밍 2단계로 관리자 `selectedTemplate / templates / loadTemplate / refreshTemplates` 묶음까지 정리했으므로, 다음 단계에서는 `/games/:gameId` 라우트와 프런트 API 호출부를 어디까지 `topic/template` 의미로 감쌀지 범위를 먼저 정리한다.
+- 화면/문서 층의 용어 정리는 거의 마무리됐으므로, 다음 단계에서는 내부 `gameId / games` 모델을 실제로 옮길지, 아니면 라우트 alias/리다이렉트부터 둘지 점진 전환 순서를 정한다.
+- 관리자 화면까지 포함한 사용자 노출 `게임` 문구를 3차까지 정리했으므로, 실제 운영 흐름에서 뜨는 확인창/토스트/선택 모달까지 표현이 자연스러운지 한 번 더 QA한다.
+- 왼쪽 사이드 메뉴와 각 화면 타이틀을 한글 기준으로 맞췄으므로, 홈/나의 티어표/즐겨찾기/설정 진입 시 실제 체감이 자연스럽고 중복 표현이 어색하지 않은지 한 번 더 QA한다.
+- 사용자 노출 용어는 `주제 / 템플릿` 기준으로 계속 걷어내고 있으므로, 홈/주제 화면/관리자 템플릿 관리에서 어색하게 남은 `게임` 문구가 없는지 한 번 더 QA한다.
 - 내부 모델명은 아직 `game`을 유지하므로, 다음 단계에서는 문서와 보조 화면 문구를 더 정리할지, 아니면 내부 리네이밍 계획을 따로 잡을지 결정한다.
- 게임 목록과 티어표 카드 썸네일은 기본 이미지 드래그를 막았으므로, 데스크톱 브라우저에서 클릭/드래그 시 원본 이미지 프리뷰가 더 이상 뜨지 않는지 한 번 더 QA한다.
+- 주제 목록과 티어표 카드 썸네일은 기본 이미지 드래그를 막았으므로, 데스크톱 브라우저에서 클릭/드래그 시 원본 이미지 프리뷰가 더 이상 뜨지 않는지 한 번 더 QA한다.
 - 왼쪽 레일 활성 배경은 공용 인디케이터가 이동하는 방식으로 바뀌었으므로, 홈/내 티어표/즐겨찾기/설정 전환과 레일 접힘 상태 양쪽에서 위치 보정이 자연스러운지 한 번 더 QA한다.
 - 로그인 화면 상단 토글은 이동형 인디케이터로 바뀌었으므로, 데스크톱과 모바일에서 `로그인 / 회원가입` 전환 애니메이션이 어색하지 않고 포커스/클릭 상태도 자연스러운지 한 번 더 QA한다.
 - 관리자 카드 설명 줄임은 `line-clamp` 표준 속성까지 함께 선언했으므로, 실제 브라우저별 표시 차이가 없는지 한 번 더 QA한다.
@@ -19,21 +27,21 @@
 - 관리자 템플릿 요청 카드는 썸네일 클릭이 새창 열기 역할로 바뀌었으므로, 썸네일 클릭과 `확인하기` 액션이 서로 헷갈리지 않는지 한 번 더 QA한다.
 - 티어표 만들기 화면의 `공유하기`는 저장된 티어표에서만 노출되므로, 저장 직후/수정 중/복사본/읽기 전용 상태 각각에서 노출 조건과 클립보드 복사가 자연스러운지 한 번 더 QA한다.
 - 우측 카피라이트는 이제 공통 오른쪽 레일 footer이므로, 관리자 화면뿐 아니라 홈/프로필 등 오른쪽 사이드가 보이는 화면에서도 같은 최하단 위치에 유지되는지 한 번 더 QA한다.
- 왼쪽 레일 축소 상태의 하단 액션 아이콘은 홈과 게임 허브에서 서로 다른 아이콘을 쓰도록 나눴으므로, 실제로 두 문맥이 한눈에 구분되는지 한 번 더 QA한다.
- 왼쪽 레일 축소 상태 최하단의 `티어표 만들기` 아이콘 버튼은 새로 추가했으므로, 홈/게임 허브에서 실제로 같은 위치 감각으로 동작하는지 한 번 더 QA한다.
+- 왼쪽 레일 축소 상태의 하단 액션 아이콘은 홈과 주제 화면에서 서로 다른 아이콘을 쓰도록 나눴으므로, 실제로 두 문맥이 한눈에 구분되는지 한 번 더 QA한다.
+- 왼쪽 레일 축소 상태 최하단의 `티어표 만들기` 아이콘 버튼은 새로 추가했으므로, 홈/주제 화면에서 실제로 같은 위치 감각으로 동작하는지 한 번 더 QA한다.
 - 관리자 우측 카피라이트 문구는 사이드바 내부 최하단으로 다시 옮겼으므로, 실제 관리자 화면에서 스크롤/창 크기 변화에도 계속 보이는지 한 번 더 QA한다.
 - 왼쪽 레일 축소 상태는 아이콘 줄 높이를 50px 기준으로 통일했으므로, 실제 데스크톱에서 아바타/검색/메뉴 아이콘이 시각적으로 같은 리듬으로 보이는지 한 번 더 QA한다.
- 왼쪽 레일 검색은 이제 항상 게임 검색으로 홈으로 이동하므로, 홈이 아닌 화면에서 사이드 검색 후 게임 목록 결과로 자연스럽게 이동하는지 한 번 더 QA한다.
+- 왼쪽 레일 검색은 이제 항상 주제 템플릿 검색으로 홈으로 이동하므로, 홈이 아닌 화면에서 사이드 검색 후 주제 목록 결과로 자연스럽게 이동하는지 한 번 더 QA한다.
 - 앱 왼쪽 사이드 레일은 접힘 상태 레이아웃을 다시 손봤으므로, 데스크톱에서 접기/펼치기 반복 시 아바타 영역 높이, 아이콘 중앙 정렬, 검색 버튼 간격, 네비게이션 히트 영역이 모두 자연스러운지 한 번 더 QA한다.
 - 관리자 우측 사이드바 하단 카피라이트 링크는 새 창 외부 링크로 바꿨으므로, 실제 클릭 시 `zenn.town` 연결과 hover 대비가 자연스러운지 한 번 더 QA한다.
- 관리자 아이템 상세 모달은 공통 패딩 예외 처리를 다시 넣었으므로, 대형 상세 모달과 일반 게임 선택 모달이 각각 기대한 크기로 보이는지 한 번 더 QA한다.
- 아이템 관리 모달의 공용 게임 선택기에서는 이미 연결된 게임이 비활성화되므로, 실제 운영 데이터에서 중복 연결 방지와 `이미 추가됨` 표시가 기대대로 읽히는지 한 번 더 QA한다.
- 공용 게임 선택 모달을 아이템 관리 모달에도 붙였으므로, 관리자 `게임 관리 / 전체 티어표 관리 / 아이템 관리` 세 흐름에서 같은 검색/선택 UX가 자연스럽게 느껴지는지 한 번 더 QA한다.
- 관리자 `/admin/games?gameId=...` 직접 진입과 새로고침에서 선택 게임이 정상 복원되고 콘솔 오류가 없는지 한 번 더 QA한다.
- 공용 `게임 선택` 검색 모달은 새로 붙였으므로, 게임 관리 선택/전체 티어표 관리 필터 양쪽에서 검색어 입력, 선택, 해제, 뒤로가기 흐름을 한 번 더 QA한다.
- 관리자 `전체 티어표 관리`의 게임 필터와 관리 모달은 새로 붙였으므로, 실제 운영 데이터에서 필터 전환 후 공개/비공개 집계, 제목 수정, 비공개 전환, 삭제 흐름이 자연스럽게 이어지는지 한 번 더 QA한다.
- 관리자 게임 관리 상단의 `전체 / 공개 / 비공개` 티어표 수치와 전체 티어표 관리 상단 집계가 실제 운영 데이터와 맞는지, 공개 전환 직후 숫자가 자연스럽게 갱신되는지 한 번 더 QA한다.
- 관리자 아이템 상세 모달은 왼쪽 선택 카드와 오른쪽 상세 본문으로 다시 정리했으므로, 데스크톱/모바일에서 긴 게임 목록과 긴 참조 목록이 각각 자연스럽게 스크롤되는지 한 번 더 QA한다.
+- 관리자 아이템 상세 모달은 공통 패딩 예외 처리를 다시 넣었으므로, 대형 상세 모달과 일반 템플릿 선택 모달이 각각 기대한 크기로 보이는지 한 번 더 QA한다.
+- 아이템 관리 모달의 공용 템플릿 선택기에서는 이미 연결된 템플릿이 비활성화되므로, 실제 운영 데이터에서 중복 연결 방지와 `이미 추가됨` 표시가 기대대로 읽히는지 한 번 더 QA한다.
+- 공용 템플릿 선택 모달을 아이템 관리 모달에도 붙였으므로, 관리자 `템플릿 관리 / 전체 티어표 관리 / 아이템 관리` 세 흐름에서 같은 검색/선택 UX가 자연스럽게 느껴지는지 한 번 더 QA한다.
+- 관리자 `/admin/games?gameId=...` 직접 진입과 새로고침에서 선택 템플릿이 정상 복원되고 콘솔 오류가 없는지 한 번 더 QA한다.
+- 공용 `템플릿 선택` 검색 모달은 새로 붙였으므로, 템플릿 관리 선택/전체 티어표 관리 필터 양쪽에서 검색어 입력, 선택, 해제, 뒤로가기 흐름을 한 번 더 QA한다.
+- 관리자 `전체 티어표 관리`의 템플릿 필터와 관리 모달은 새로 붙였으므로, 실제 운영 데이터에서 필터 전환 후 공개/비공개 집계, 제목 수정, 비공개 전환, 삭제 흐름이 자연스럽게 이어지는지 한 번 더 QA한다.
+- 관리자 템플릿 관리 상단의 `전체 / 공개 / 비공개` 티어표 수치와 전체 티어표 관리 상단 집계가 실제 운영 데이터와 맞는지, 공개 전환 직후 숫자가 자연스럽게 갱신되는지 한 번 더 QA한다.
+- 관리자 아이템 상세 모달은 왼쪽 선택 카드와 오른쪽 상세 본문으로 다시 정리했으므로, 데스크톱/모바일에서 긴 템플릿 목록과 긴 참조 목록이 각각 자연스럽게 스크롤되는지 한 번 더 QA한다.
 - 관리자 계정으로 `/admin/...`을 직접 새로고침했을 때 홈으로 튕기지 않고 그대로 유지되는지, 실제 세션이 살아 있는 브라우저와 만료된 브라우저 각각에서 한 번 더 QA한다.
 - 티어표 만들기 화면의 보드 드롭존은 점선/높이/중앙 정렬로 존재감이 커졌으므로, 데스크톱과 모바일에서 파일 선택 버튼과 안내 문구 밀도를 한 번 더 QA한다.
 - 관리자 썸네일 드롭존과 기본 아이템 추가 드롭존은 에디터 드롭존과 시각 문법을 맞췄으므로, 라이트모드와 좁은 화면에서 아이콘 대비와 배경 밝기가 과하지 않은지 한 번 더 QA한다.
--- a/docs/update.md
+++ b/docs/update.md
@@ -1,5 +1,33 @@
 # 업데이트 로그

+## 2026-04-02 v1.4.8
+- 주제 상세 컬렉션 화면은 제목을 `topicId` fallback으로 먼저 노출하지 않도록 바꾸고, 주제 전환 시에는 로딩 문구를 거쳐 실제 이름으로 자연스럽게 바뀌게 정리했다.
+- 검색 결과 화면도 공통 `pageHead` 문법으로 맞춰 주요 목록 화면들의 상단 리듬을 한 번 더 통일했다.
+
+## 2026-04-02 v1.4.7
+- 주제 선택 뒤에 들어가는 `Collection` 화면을 공통 `pageHead` 레이아웃으로 다시 맞추고, 검색 입력을 즐겨찾기 화면처럼 상단 우측 툴바로 정리했다.
+- `공개 티어표` 보조 설명 줄은 제거해 헤더 밀도를 줄였고, 사용자 진입 경로는 `/topics/:gameId`를 기본으로 전환하면서 기존 `/games/:gameId`는 alias로 유지했다.
+
+## 2026-04-02 v1.4.6
+- 관리자 내부 리네이밍 2단계로 `AdminView`와 관련 composable/component의 핵심 상태명을 `selectedTemplate / templates / loadTemplate / refreshTemplates / createTemplate` 기준으로 정리했다.
+- 요청 검토, 템플릿 생성 모달, 아이템 추가/정렬, 템플릿 선택 모달 흐름도 같은 기준으로 맞춰, 관리자 화면을 읽을 때 내부 이름과 사용자 노출 용어가 덜 어긋나게 정리했다.
+
+## 2026-04-02 v1.4.5
+- 내부 리네이밍 1단계를 시작해 홈, 주제 화면, 티어표 편집기, 앱 셸에서 `games / gameId / gameName` 중심의 로컬 상태명을 `templates / topicId / templateId / templateName` 계열로 먼저 정리했다.
+- 경로와 API는 그대로 둔 채 프런트 내부에서 자주 읽는 상태명부터 바꿔, 이후 `/games` 라우트와 관리자 상태를 손볼 때 의미 충돌이 덜 나도록 기반을 만들었다.
+
+## 2026-04-02 v1.4.4
+- 홈 화면 `Topic Library`와 일부 영어 헤더를 `주제 선택 / 티어표 / 관리자 작업실 / 티어표 만들기 / 작업 공간`으로 정리해, 화면 타이틀과 상단 레이블까지 한국어 기준으로 거의 통일했다.
+
+## 2026-04-02 v1.4.3
+- 관리자 토스트, 확인창, 요청 처리 안내처럼 실제로 자주 보이는 운영 문구까지 `주제 / 템플릿` 기준으로 한 번 더 정리해, 화면 제목뿐 아니라 작업 피드백도 더 일관되게 맞췄다.
+
+## 2026-04-02 v1.4.2
+- 관리자 화면과 보조 모달에 남아 있던 사용자 노출 `게임` 문구를 추가로 걷어내고, `템플릿 / 주제` 기준 표현으로 더 통일했다.
+
+## 2026-04-02 v1.4.1
+- 왼쪽 사이드 메뉴를 `주제 선택 / 나의 티어표 / 즐겨찾기 / 설정` 한글 문구로 통일하고, 해당 화면 진입 시 헤더 타이틀도 같은 이름 기준으로 맞췄다.
+
 ## 2026-04-02 v1.4.0
 - 사용자 노출 용어 1차 정리를 시작해 홈/좌측 레일/가이드/주제 화면에서는 `게임` 대신 `주제`, 관리자 핵심 화면에서는 `게임 관리` 대신 `템플릿 관리` 중심 표현으로 바꿨다.
 - 내부 데이터 모델과 API의 `gameId`, `/games` 구조는 아직 유지하고, 이번 단계는 화면 문구와 안내 텍스트를 먼저 정리하는 안전한 1차 리네이밍 범위로 제한했다.
--- a/frontend/src/App.vue
+++ b/frontend/src/App.vue
@@ -60,10 +60,10 @@ const shellStyle = computed(() => ({
 }))
 const leftNavItems = computed(() => {
  const items = [
-    { key: 'home', label: 'Topics', path: '/', iconSrc: iconGridView },
-    { key: 'me', label: 'My Lists', path: '/me', iconSrc: iconLists, requiresAuth: true },
-    { key: 'favorites', label: 'Favorites', path: '/favorites', iconSrc: iconFavorite, requiresAuth: true },
-    { key: 'profile', label: 'Settings', path: '/profile', iconSrc: iconSettings, requiresAuth: true },
+    { key: 'home', label: '주제 선택', path: '/', iconSrc: iconGridView },
+    { key: 'me', label: '나의 티어표', path: '/me', iconSrc: iconLists, requiresAuth: true },
+    { key: 'favorites', label: '즐겨찾기', path: '/favorites', iconSrc: iconFavorite, requiresAuth: true },
+    { key: 'profile', label: '설정', path: '/profile', iconSrc: iconSettings, requiresAuth: true },
  ]
  return items.filter((item) => !item.requiresAuth || (authReady.value && auth.user))
 })
@@ -134,8 +134,8 @@ const isGuideNextDisabled = computed(() => guideStepIndex.value >= guideSteps.le
 const isLightTheme = computed(() => themeMode.value === 'light')
 const themeToggleLabel = computed(() => (isLightTheme.value ? '다크 모드' : '라이트 모드'))
 const showSettingsThemePanel = computed(() => false && route.name === 'profile')
-const showGameHubViewToggle = computed(() => route.name === 'gameHub')
-const gameHubViewMode = computed(() => (route.query.view === 'list' ? 'list' : 'grid'))
+const showTopicViewToggle = computed(() => route.name === 'gameHub')
+const topicViewMode = computed(() => (route.query.view === 'list' ? 'list' : 'grid'))
 const leftBottomPrimaryAction = computed(() => {
  if (!authReady.value) return null
  if (route.name === 'home' && auth.user) {
@@ -151,7 +151,7 @@ const leftBottomPrimaryAction = computed(() => {
 const routeMeta = computed(() => {
  if (route.name === 'home') {
    return {
-      title: 'Tier Maker',
+      title: '주제 선택',
      subtitle: '주제 템플릿 선택과 커스텀 보드 시작',
      contextTitle: '빠른 시작',
      contextText: auth.user ? '커스텀 티어표를 만들거나 원하는 주제를 바로 선택할 수 있어요.' : '로그인하면 커스텀 티어표 생성과 개인 목록 관리가 열립니다.',
@@ -163,7 +163,7 @@ const routeMeta = computed(() => {
  }
  if (route.name === 'gameHub') {
    return {
-      title: 'Topic Boards',
+      title: '주제 티어표',
      subtitle: '주제별 공개 티어표 탐색',
      contextTitle: '작성 작업',
      contextText: auth.user ? '이 주제의 새 티어표를 만들거나 기존 공개 티어표를 확인할 수 있어요.' : '로그인 후 새 티어표를 만들 수 있어요.',
@@ -176,7 +176,7 @@ const routeMeta = computed(() => {
  }
  if (route.name === 'editEditor' || route.name === 'newEditor') {
    return {
-      title: 'Deck Builder',
+      title: '티어표 만들기',
      subtitle: '티어표 편집 및 공유',
      contextTitle: '편집 패널',
      contextText: '현재 편집 옵션은 중앙 화면 안에 유지되어 있습니다. 다음 단계에서 우측 패널로 정리해갈게요.',
@@ -186,7 +186,7 @@ const routeMeta = computed(() => {
  }
  if (isAdminRoute.value) {
    return {
-      title: 'Admin Workspace',
+      title: '관리자 작업실',
      subtitle: '템플릿·아이템·회원 관리',
      contextTitle: '운영 노트',
      contextText: '관리자 화면은 기능이 많아 우선 공통 셸 톤을 맞췄고, 세부 패널은 다음 단계에서 시안 방식으로 더 세밀하게 나눌 예정입니다.',
@@ -196,8 +196,8 @@ const routeMeta = computed(() => {
  }
  if (route.name === 'me') {
    return {
-      title: 'My Lists',
-      subtitle: '내가 저장한 티어표',
+      title: '나의 티어표',
+      subtitle: '저장한 티어표 모아보기',
      contextTitle: '작성 이력',
      contextText: '최근 저장한 티어표를 열람하고 정리할 수 있어요.',
      actionLabel: '즐겨찾기 보기',
@@ -206,27 +206,27 @@ const routeMeta = computed(() => {
  }
  if (route.name === 'favorites') {
    return {
-      title: 'Favorites',
+      title: '즐겨찾기',
      subtitle: '마음에 드는 티어표 모음',
      contextTitle: '정리 도구',
      contextText: '정렬과 검색으로 원하는 티어표를 빠르게 다시 찾을 수 있어요.',
-      actionLabel: '내 티어표 보기',
+      actionLabel: '나의 티어표 보기',
      action: () => router.push('/me'),
    }
  }
  if (route.name === 'profile') {
    return {
-      title: 'Profile',
+      title: '설정',
      subtitle: '프로필 및 계정 설정',
      contextTitle: '계정 관리',
      contextText: '아바타와 닉네임을 관리하고 표시 정보를 확인할 수 있어요.',
-      actionLabel: '내 티어표 보기',
+      actionLabel: '나의 티어표 보기',
      action: () => router.push('/me'),
    }
  }
  if (route.name === 'search') {
    return {
-      title: 'Search',
+      title: '검색',
      subtitle: '전체 공개 티어표 검색 결과',
      contextTitle: '검색',
      contextText: '제목, 작성자 기준으로 공개 티어표를 전체 검색할 수 있어요.',
@@ -237,7 +237,7 @@ const routeMeta = computed(() => {
  return {
    title: 'Tier Maker',
    subtitle: '주제 템플릿으로 만드는 티어표',
-    contextTitle: 'Workspace',
+    contextTitle: '작업 공간',
    contextText: '현재 화면에 맞는 도구와 안내를 여기에 배치할 수 있습니다.',
    actionLabel: '홈으로',
    action: () => router.push('/'),
@@ -344,7 +344,7 @@ function toggleRightRail() {
  }
 }

-function setGameHubViewMode(mode) {
+function setTopicViewMode(mode) {
  if (route.name !== 'gameHub') return
  const nextQuery = { ...route.query }
  if (mode === 'list') nextQuery.view = 'list'
@@ -499,11 +499,11 @@ function submitGlobalSearch() {
              <span class="workspaceHead__brandTitle">Tier Maker</span>
            </div>
            <div class="workspaceHead__actions">
-              <div v-if="showGameHubViewToggle" class="viewToggle" role="group" aria-label="티어표 보기 방식">
-                <button class="ghostIcon ghostIcon--iconOnly" :class="{ 'ghostIcon--active': gameHubViewMode === 'grid' }" type="button" aria-label="그리드 보기" @click="setGameHubViewMode('grid')">
+              <div v-if="showTopicViewToggle" class="viewToggle" role="group" aria-label="티어표 보기 방식">
+                <button class="ghostIcon ghostIcon--iconOnly" :class="{ 'ghostIcon--active': topicViewMode === 'grid' }" type="button" aria-label="그리드 보기" @click="setTopicViewMode('grid')">
                  <SvgIcon :src="iconGridView" :size="24" />
                </button>
-                <button class="ghostIcon ghostIcon--iconOnly" :class="{ 'ghostIcon--active': gameHubViewMode === 'list' }" type="button" aria-label="리스트 보기" @click="setGameHubViewMode('list')">
+                <button class="ghostIcon ghostIcon--iconOnly" :class="{ 'ghostIcon--active': topicViewMode === 'list' }" type="button" aria-label="리스트 보기" @click="setTopicViewMode('list')">
                  <SvgIcon :src="iconLists" :size="24" />
                </button>
              </div>
--- a/frontend/src/components/admin/AdminFeaturedSection.vue
+++ b/frontend/src/components/admin/AdminFeaturedSection.vue
@@ -1,13 +1,13 @@
 <script setup>
 const props = defineProps({
-  featuredGames: { type: Array, required: true },
-  availableGamesForFeatured: { type: Array, required: true },
-  featuredGameIds: { type: Array, required: true },
+  featuredTemplates: { type: Array, required: true },
+  availableTemplatesForFeatured: { type: Array, required: true },
+  featuredTemplateIds: { type: Array, required: true },
  featuredListRef: { type: Function, required: true },
  saveFeaturedOrder: { type: Function, required: true },
-  moveFeaturedGame: { type: Function, required: true },
-  removeFeaturedGame: { type: Function, required: true },
-  addFeaturedGame: { type: Function, required: true },
+  moveFeaturedTemplate: { type: Function, required: true },
+  removeFeaturedTemplate: { type: Function, required: true },
+  addFeaturedTemplate: { type: Function, required: true },
 })
 </script>

@@ -24,21 +24,21 @@ const props = defineProps({
    <div class="featuredOrderPanel">
      <div class="featuredOrderPanel__list">
        <div class="section__title">상단 고정 목록</div>
-        <div v-if="!props.featuredGames.length" class="hint">아직 상단 고정 템플릿이 없어요.</div>
+        <div v-if="!props.featuredTemplates.length" class="hint">아직 상단 고정 템플릿이 없어요.</div>
        <div v-else :ref="props.featuredListRef" class="featuredList">
-          <article v-for="(game, index) in props.featuredGames" :key="game.id" class="featuredCard" :data-featured-id="game.id">
+          <article v-for="(template, index) in props.featuredTemplates" :key="template.id" class="featuredCard" :data-featured-id="template.id">
            <div class="featuredCard__meta">
              <span class="featuredCard__rank">{{ index + 1 }}</span>
              <div>
-                <div class="featuredCard__title">{{ game.name }}</div>
-                <div class="featuredCard__id">{{ game.id }}</div>
+                <div class="featuredCard__title">{{ template.name }}</div>
+                <div class="featuredCard__id">{{ template.id }}</div>
              </div>
            </div>
            <div class="featuredCard__actions">
              <button class="btn btn--ghost btn--small" data-featured-handle>드래그</button>
-              <button class="btn btn--ghost btn--small" :disabled="index === 0" @click="props.moveFeaturedGame(game.id, -1)">위로</button>
-              <button class="btn btn--ghost btn--small" :disabled="index === props.featuredGames.length - 1" @click="props.moveFeaturedGame(game.id, 1)">아래로</button>
-              <button class="btn btn--danger btn--small" @click="props.removeFeaturedGame(game.id)">제외</button>
+              <button class="btn btn--ghost btn--small" :disabled="index === 0" @click="props.moveFeaturedTemplate(template.id, -1)">위로</button>
+              <button class="btn btn--ghost btn--small" :disabled="index === props.featuredTemplates.length - 1" @click="props.moveFeaturedTemplate(template.id, 1)">아래로</button>
+              <button class="btn btn--danger btn--small" @click="props.removeFeaturedTemplate(template.id)">제외</button>
            </div>
          </article>
        </div>
@@ -48,14 +48,14 @@ const props = defineProps({
        <div class="section__title">템플릿 추가</div>
        <div class="featuredPickerList">
          <button
-            v-for="game in props.availableGamesForFeatured"
-            :key="game.id"
+            v-for="template in props.availableTemplatesForFeatured"
+            :key="template.id"
            class="featuredPickerItem"
-            :disabled="props.featuredGameIds.length >= 50"
-            @click="props.addFeaturedGame(game.id)"
+            :disabled="props.featuredTemplateIds.length >= 50"
+            @click="props.addFeaturedTemplate(template.id)"
          >
-            <span>{{ game.name }}</span>
-            <span class="featuredPickerItem__id">{{ game.id }}</span>
+            <span>{{ template.name }}</span>
+            <span class="featuredPickerItem__id">{{ template.id }}</span>
          </button>
        </div>
      </div>
--- a/frontend/src/components/admin/AdminGamesSection.vue
+++ b/frontend/src/components/admin/AdminGamesSection.vue
@@ -8,10 +8,10 @@ const props = defineProps({
  templateRequestSourceUrl: { type: Function, required: true },
  stagedRequestDraftCount: { type: Number, required: true },
  appliedRequestItemCount: { type: Number, required: true },
-  openGameCreateModal: { type: Function, required: true },
+  openTemplateCreateModal: { type: Function, required: true },
  isGameLoading: { type: Boolean, required: true },
-  hasSelectedGame: { type: Boolean, required: true },
-  selectedGame: { type: Object, default: null },
+  hasSelectedTemplate: { type: Boolean, required: true },
+  selectedTemplate: { type: Object, default: null },
  displayThumbnailUrl: { type: String, default: '' },
  canApplyThumbnail: { type: Boolean, required: true },
  gameVisibilitySaving: { type: Boolean, required: true },
@@ -24,8 +24,8 @@ const props = defineProps({
  onThumbDrop: { type: Function, required: true },
  isThumbDragOver: { type: Boolean, required: true },
  uploadThumbnail: { type: Function, required: true },
-  removeGame: { type: Function, required: true },
-  toggleSelectedGameVisibility: { type: Function, required: true },
+  removeTemplate: { type: Function, required: true },
+  toggleSelectedTemplateVisibility: { type: Function, required: true },
  itemFileInputRef: { type: Function, required: true },
  onFile: { type: Function, required: true },
  isItemDragOver: { type: Boolean, required: true },
@@ -39,12 +39,12 @@ const props = defineProps({
  canAddItem: { type: Boolean, required: true },
  uploadItem: { type: Function, required: true },
  removeUploadDraft: { type: Function, required: true },
-  hasGameItemOrderChanges: { type: Boolean, required: true },
-  saveGameItemOrder: { type: Function, required: true },
+  hasTemplateItemOrderChanges: { type: Boolean, required: true },
+  saveTemplateItemOrder: { type: Function, required: true },
  gameItemListRef: { type: Function, required: true },
-  saveGameItemLabel: { type: Function, required: true },
-  removeGameItem: { type: Function, required: true },
-  selectedGameId: { type: String, default: '' },
+  saveTemplateItemLabel: { type: Function, required: true },
+  removeTemplateItem: { type: Function, required: true },
+  selectedTemplateId: { type: String, default: '' },
 })

 function setGameItemListElement(el) {
@@ -95,7 +95,7 @@ function setThumbFileElement(el) {
        v-if="props.activeTemplateRequest.type === 'create' && !props.activeTemplateRequest.targetGameId"
        class="btn btn--ghost btn--small"
        type="button"
-        @click="props.openGameCreateModal"
+        @click="props.openTemplateCreateModal"
      >
        새 템플릿 만들기
      </button>
@@ -108,7 +108,7 @@ function setThumbFileElement(el) {
      <div class="emptyState__desc">선택한 템플릿의 썸네일과 기본 아이템을 곧 표시합니다.</div>
    </div>
  </div>
-  <div v-else-if="props.hasSelectedGame" class="panel">
+  <div v-else-if="props.hasSelectedTemplate" class="panel">
    <section class="adminCard gameSettingsCard">
      <div class="gameSettingsCard__media">
        <input :ref="setThumbFileElement" type="file" accept="image/*" class="srOnlyInput" @change="props.onThumb" />
@@ -122,7 +122,7 @@ function setThumbFileElement(el) {
          @dragleave="props.onThumbDragLeave"
          @drop="props.onThumbDrop"
        >
-          <img v-if="props.displayThumbnailUrl" class="selectedThumb selectedThumb--sidebar" :src="props.displayThumbnailUrl" :alt="props.selectedGame.game.name" />
+          <img v-if="props.displayThumbnailUrl" class="selectedThumb selectedThumb--sidebar" :src="props.displayThumbnailUrl" :alt="props.selectedTemplate.game.name" />
          <div v-else class="selectedThumb selectedThumb--empty selectedThumb--sidebar">대표 썸네일</div>
          <div class="thumbDropZone__copy">
            <div class="thumbDropZone__iconWrap">
@@ -134,15 +134,15 @@ function setThumbFileElement(el) {
      </div>
      <div class="gameSettingsCard__body">
        <div class="panel__title">템플릿 설정</div>
-        <div class="gameSettingsCard__meta">{{ props.selectedGame.game.name }} · {{ props.selectedGame.game.id }}</div>
+        <div class="gameSettingsCard__meta">{{ props.selectedTemplate.game.name }} · {{ props.selectedTemplate.game.id }}</div>
        <label class="toggleSwitch" :class="{ 'toggleSwitch--disabled': props.gameVisibilitySaving }">
-          <input :checked="!!props.selectedGame.game.isPublic" type="checkbox" @change="props.toggleSelectedGameVisibility($event.target.checked)" />
-          <span class="toggleSwitch__label">{{ props.selectedGame.game.isPublic ? '템플릿 공개중' : '비공개 상태' }}</span>
+          <input :checked="!!props.selectedTemplate.game.isPublic" type="checkbox" @change="props.toggleSelectedTemplateVisibility($event.target.checked)" />
+          <span class="toggleSwitch__label">{{ props.selectedTemplate.game.isPublic ? '템플릿 공개중' : '비공개 상태' }}</span>
          <span class="toggleSwitch__track"><span class="toggleSwitch__thumb"></span></span>
        </label>
        <div class="gameSettingsCard__actions">
          <button class="btn" :disabled="!props.canApplyThumbnail" @click="props.uploadThumbnail">썸네일 적용</button>
-          <button class="btn btn--danger" @click="props.removeGame">템플릿 삭제</button>
+          <button class="btn btn--danger" @click="props.removeTemplate">템플릿 삭제</button>
        </div>
      </div>
    </section>
@@ -212,11 +212,11 @@ function setThumbFileElement(el) {
          <div class="section__title">현재 기본 아이템 목록</div>
          <div class="hint hint--tight">드래그해서 기본 노출 순서를 바꿀 수 있어요. 저장 전까지는 화면에서만 순서가 바뀝니다.</div>
        </div>
-        <button class="btn btn--primary btn--small" :disabled="!props.hasGameItemOrderChanges" @click="props.saveGameItemOrder">순서 저장</button>
+        <button class="btn btn--primary btn--small" :disabled="!props.hasTemplateItemOrderChanges" @click="props.saveTemplateItemOrder">순서 저장</button>
      </div>
-      <div v-if="!props.selectedGame?.items?.length" class="hint">아직 등록된 기본 아이템이 없어요.</div>
+      <div v-if="!props.selectedTemplate?.items?.length" class="hint">아직 등록된 기본 아이템이 없어요.</div>
      <div v-else :ref="setGameItemListElement" class="thumbGrid">
-        <div v-for="item in props.selectedGame.items" :key="item.id" class="thumbCard" :data-game-item-id="item.id">
+        <div v-for="item in props.selectedTemplate.items" :key="item.id" class="thumbCard" :data-game-item-id="item.id">
          <img class="thumb thumb--game" :src="toApiUrl(item.src)" :alt="item.label" draggable="false" />
          <input v-model="item.draftLabel" class="input input--labelEdit" placeholder="아이템 이름" data-no-drag />
          <div class="thumbCard__actions">
@@ -224,11 +224,11 @@ function setThumbFileElement(el) {
              class="btn btn--ghost btn--small"
              data-no-drag
              :disabled="item.isSavingLabel || !item.draftLabel?.trim() || item.draftLabel.trim() === item.label"
-              @click="props.saveGameItemLabel(item)"
+              @click="props.saveTemplateItemLabel(item)"
            >
              {{ item.isSavingLabel ? '저장중...' : '이름 저장' }}
            </button>
-            <button class="btn btn--danger btn--small" data-no-drag @click="props.removeGameItem(item.id)">아이템 삭제</button>
+            <button class="btn btn--danger btn--small" data-no-drag @click="props.removeTemplateItem(item.id)">아이템 삭제</button>
          </div>
        </div>
      </div>
@@ -238,7 +238,7 @@ function setThumbFileElement(el) {
    <div class="emptyState">
      <div class="emptyState__title">템플릿을 선택해 주세요.</div>
      <div v-if="props.activeTemplateRequest?.type === 'create'" class="hint hint--tight">진행 중인 신규 템플릿 요청이 있어요. 위의 `새 템플릿 만들기`로 템플릿을 만든 뒤 아이템을 추가할 수 있습니다.</div>
-      <div v-if="props.selectedGameId" class="hint hint--tight">선택한 템플릿을 찾지 못했거나 로딩 중 오류가 발생했어요. 다시 선택해보세요.</div>
+      <div v-if="props.selectedTemplateId" class="hint hint--tight">선택한 템플릿을 찾지 못했거나 로딩 중 오류가 발생했어요. 다시 선택해보세요.</div>
    </div>
  </div>
 </template>
--- a/frontend/src/composables/useAdminCustomItems.js
+++ b/frontend/src/composables/useAdminCustomItems.js
@@ -15,13 +15,13 @@ export function useAdminCustomItems({
  modalTargetCustomItem,
  customItemModalDraftLabel,
  customItemModalLabelSaving,
-  customItemModalTargetGameId,
-  games,
-  selectedGameId,
+  customItemModalTargetTemplateId,
+  templates,
+  selectedTemplateId,
  refreshCustomItems,
-  loadGame,
+  loadTemplate,
  setTab,
-  selectAdminGame,
+  selectAdminTemplate,
  resetMessages,
  success,
  error,
@@ -59,7 +59,7 @@ export function useAdminCustomItems({
  function openCustomItemModal(item) {
    modalTargetCustomItem.value = item || null
    customItemModalDraftLabel.value = item?.label || ''
-    customItemModalTargetGameId.value = ''
+    customItemModalTargetTemplateId.value = ''
    customItemModalOpen.value = true
    pushCustomItemModalHistoryState()
  }
@@ -70,7 +70,7 @@ export function useAdminCustomItems({
    modalTargetCustomItem.value = null
    customItemModalDraftLabel.value = ''
    customItemModalLabelSaving.value = false
-    customItemModalTargetGameId.value = ''
+    customItemModalTargetTemplateId.value = ''

    if (fromPopState) {
      customItemModalHistoryActive.value = false
@@ -97,12 +97,12 @@ export function useAdminCustomItems({
    customItemDeleteModalOpen.value = false
  }

-  function jumpToGameAdmin(gameId) {
-    if (!gameId) return
+  function jumpToTemplateAdmin(templateId) {
+    if (!templateId) return
    closeCustomItemModal()
    setTab('game-admin')
    nextTick(() => {
-      selectAdminGame(gameId)
+      selectAdminTemplate(templateId)
    })
  }

@@ -160,18 +160,19 @@ export function useAdminCustomItems({

  async function promoteCustomItem(item) {
    resetMessages()
-    if (!customItemModalTargetGameId.value) {
-      error.value = '추가할 게임을 먼저 선택해주세요.'
+    if (!customItemModalTargetTemplateId.value) {
+      error.value = '추가할 템플릿을 먼저 선택해주세요.'
      return
    }

    try {
      item.isPromoting = true
-      await api.promoteAdminCustomItem(item.id, { gameId: customItemModalTargetGameId.value })
-      const targetGameName = games.value.find((game) => game.id === customItemModalTargetGameId.value)?.name || customItemModalTargetGameId.value
-      if (selectedGameId.value === customItemModalTargetGameId.value) await loadGame()
+      await api.promoteAdminCustomItem(item.id, { gameId: customItemModalTargetTemplateId.value })
+      const targetTemplateName =
+        templates.value.find((template) => template.id === customItemModalTargetTemplateId.value)?.name || customItemModalTargetTemplateId.value
+      if (selectedTemplateId.value === customItemModalTargetTemplateId.value) await loadTemplate()
      closeCustomItemModal()
-      success.value = `"${item.label}" 이미지를 ${targetGameName} 템플릿으로 추가했어요.`
+      success.value = `"${item.label}" 이미지를 ${targetTemplateName} 템플릿으로 추가했어요.`
    } catch (e) {
      error.value = '선택한 이미지를 템플릿으로 추가하지 못했어요.'
    } finally {
@@ -189,7 +190,7 @@ export function useAdminCustomItems({
    closeCustomItemModal,
    openCustomItemDeleteModal,
    closeCustomItemDeleteModal,
-    jumpToGameAdmin,
+    jumpToTemplateAdmin,
    removeCustomItem,
    removeUnusedCustomItems,
    saveCustomItemModalLabel,
--- a/frontend/src/composables/useAdminFeaturedGames.js
+++ b/frontend/src/composables/useAdminFeaturedGames.js
@@ -5,8 +5,8 @@ export function useAdminFeaturedGames({
  api,
  featuredListEl,
  featuredSortable,
-  featuredGameIds,
-  games,
+  featuredTemplateIds,
+  templates,
  resetMessages,
  success,
  error,
@@ -31,63 +31,63 @@ export function useAdminFeaturedGames({
      chosenClass: 'chosen',
      onEnd: (evt) => {
        if (evt.oldIndex == null || evt.newIndex == null || evt.oldIndex === evt.newIndex) return
-        const nextIds = [...featuredGameIds.value]
+        const nextIds = [...featuredTemplateIds.value]
        const [moved] = nextIds.splice(evt.oldIndex, 1)
        nextIds.splice(evt.newIndex, 0, moved)
-        featuredGameIds.value = nextIds
+        featuredTemplateIds.value = nextIds
      },
    })
  }

-  function addFeaturedGame(gameId) {
+  function addFeaturedTemplate(templateId) {
    resetMessages()
-    if (!gameId || featuredGameIds.value.includes(gameId)) return
-    if (featuredGameIds.value.length >= 50) {
-      error.value = '상단 고정 게임은 최대 50개까지만 설정할 수 있어요.'
+    if (!templateId || featuredTemplateIds.value.includes(templateId)) return
+    if (featuredTemplateIds.value.length >= 50) {
+      error.value = '상단 고정 템플릿은 최대 50개까지만 설정할 수 있어요.'
      return
    }
-    featuredGameIds.value = [...featuredGameIds.value, gameId]
+    featuredTemplateIds.value = [...featuredTemplateIds.value, templateId]
    syncFeaturedSortable()
  }

-  function removeFeaturedGame(gameId) {
+  function removeFeaturedTemplate(templateId) {
    resetMessages()
-    featuredGameIds.value = featuredGameIds.value.filter((id) => id !== gameId)
+    featuredTemplateIds.value = featuredTemplateIds.value.filter((id) => id !== templateId)
    syncFeaturedSortable()
  }

-  function moveFeaturedGame(gameId, direction) {
-    const currentIndex = featuredGameIds.value.indexOf(gameId)
+  function moveFeaturedTemplate(templateId, direction) {
+    const currentIndex = featuredTemplateIds.value.indexOf(templateId)
    const nextIndex = currentIndex + direction
-    if (currentIndex < 0 || nextIndex < 0 || nextIndex >= featuredGameIds.value.length) return
-    const nextIds = [...featuredGameIds.value]
+    if (currentIndex < 0 || nextIndex < 0 || nextIndex >= featuredTemplateIds.value.length) return
+    const nextIds = [...featuredTemplateIds.value]
    const [moved] = nextIds.splice(currentIndex, 1)
    nextIds.splice(nextIndex, 0, moved)
-    featuredGameIds.value = nextIds
+    featuredTemplateIds.value = nextIds
    syncFeaturedSortable()
  }

  async function saveFeaturedOrder() {
    resetMessages()
    try {
-      const data = await api.updateAdminGameDisplayOrder({ gameIds: featuredGameIds.value })
-      games.value = data.games || []
-      featuredGameIds.value = games.value
-        .filter((game) => game.displayRank != null)
+      const data = await api.updateAdminGameDisplayOrder({ gameIds: featuredTemplateIds.value })
+      templates.value = data.games || []
+      featuredTemplateIds.value = templates.value
+        .filter((template) => template.displayRank != null)
        .sort((a, b) => a.displayRank - b.displayRank)
-        .map((game) => game.id)
-      success.value = '홈 화면 게임 순서를 저장했어요.'
+        .map((template) => template.id)
+      success.value = '홈 화면 템플릿 순서를 저장했어요.'
    } catch (e) {
-      error.value = '게임 순서 저장에 실패했어요.'
+      error.value = '템플릿 순서 저장에 실패했어요.'
    }
  }

  return {
    destroyFeaturedSortable,
    syncFeaturedSortable,
-    addFeaturedGame,
-    removeFeaturedGame,
-    moveFeaturedGame,
+    addFeaturedTemplate,
+    removeFeaturedTemplate,
+    moveFeaturedTemplate,
    saveFeaturedOrder,
  }
 }
--- a/frontend/src/composables/useAdminGameManager.js
+++ b/frontend/src/composables/useAdminGameManager.js
@@ -4,8 +4,8 @@ import Sortable from 'sortablejs'
 export function useAdminGameManager({
  api,
  toApiUrl,
-  selectedGameId,
-  selectedGame,
+  selectedTemplateId,
+  selectedTemplate,
  uploadFiles,
  uploadItemDrafts,
  thumbFile,
@@ -18,15 +18,15 @@ export function useAdminGameManager({
  activeTemplateRequest,
  templateRequests,
  customItemModalOpen,
-  customItemModalTargetGameId,
-  newGameId,
-  newGameName,
-  newGameIsPublic,
+  customItemModalTargetTemplateId,
+  newTemplateId,
+  newTemplateName,
+  newTemplateIsPublic,
  clearPreviewUrl,
  resetFileInput,
  resetUploadState,
-  refreshGames,
-  closeGameCreateModal,
+  refreshTemplates,
+  closeTemplateCreateModal,
  resetMessages,
  success,
  error,
@@ -59,7 +59,7 @@ export function useAdminGameManager({
  async function syncGameItemSortable() {
    await nextTick()
    destroyGameItemSortable()
-    if (!gameItemListEl.value || !selectedGame.value?.items?.length) return
+    if (!gameItemListEl.value || !selectedTemplate.value?.items?.length) return

    gameItemSortable.value = Sortable.create(gameItemListEl.value, {
      animation: 160,
@@ -73,11 +73,11 @@ export function useAdminGameManager({
      chosenClass: 'chosen',
      onEnd: (evt) => {
        if (evt.oldIndex == null || evt.newIndex == null || evt.oldIndex === evt.newIndex) return
-        const nextItems = [...(selectedGame.value?.items || [])]
+        const nextItems = [...(selectedTemplate.value?.items || [])]
        const [moved] = nextItems.splice(evt.oldIndex, 1)
        nextItems.splice(evt.newIndex, 0, moved)
-        selectedGame.value = {
-          ...selectedGame.value,
+        selectedTemplate.value = {
+          ...selectedTemplate.value,
          items: nextItems,
        }
      },
@@ -87,7 +87,7 @@ export function useAdminGameManager({
  function mergeRequestItemsIntoDrafts(request) {
    const requestId = request?.id
    if (!requestId) return
-    const existingGameSrcs = new Set((selectedGame.value?.items || []).map((item) => normalizeDraftSrc(item?.src)).filter(Boolean))
+    const existingTemplateSrcs = new Set((selectedTemplate.value?.items || []).map((item) => normalizeDraftSrc(item?.src)).filter(Boolean))
    const existingKeys = new Set(uploadItemDrafts.value.map((draft) => `${draft.kind}:${draft.requestId || ''}:${draft.itemId || draft.file?.name || ''}`))
    const nextRequestDrafts = (request.items || [])
      .filter((item) => item?.src)
@@ -100,7 +100,7 @@ export function useAdminGameManager({
        sourceName: requestItemFilename(item),
        src: item.src,
      }))
-      .filter((draft) => !existingGameSrcs.has(normalizeDraftSrc(draft.src)))
+      .filter((draft) => !existingTemplateSrcs.has(normalizeDraftSrc(draft.src)))
      .filter((draft) => !existingKeys.has(`${draft.kind}:${draft.requestId}:${draft.itemId}`))

    if (nextRequestDrafts.length) {
@@ -117,13 +117,13 @@ export function useAdminGameManager({
    uploadFiles.value = uploadItemDrafts.value.filter((draft) => draft.kind === 'file').map((draft) => draft.file).filter(Boolean)
  }

-  async function loadGame(options = {}) {
+  async function loadTemplate(options = {}) {
    const preserveUploadState = !!options.preserveUploadState
    resetMessages()
    if (!preserveUploadState) resetUploadState()

-    if (!selectedGameId.value) {
-      selectedGame.value = null
+    if (!selectedTemplateId.value) {
+      selectedTemplate.value = null
      savedGameItemOrderIds.value = []
      destroyGameItemSortable()
      return
@@ -131,8 +131,8 @@ export function useAdminGameManager({

    try {
      isGameLoading.value = true
-      const data = await api.getGame(selectedGameId.value)
-      selectedGame.value = {
+      const data = await api.getGame(selectedTemplateId.value)
+      selectedTemplate.value = {
        ...data,
        items: (data.items || []).map((item) => ({
          ...item,
@@ -142,16 +142,16 @@ export function useAdminGameManager({
      savedGameItemOrderIds.value = (data.items || []).map((item) => item.id)
      await syncGameItemSortable()
    } catch (e) {
-      selectedGame.value = null
-      error.value = '게임 정보를 불러오지 못했어요.'
+      selectedTemplate.value = null
+      error.value = '템플릿 정보를 불러오지 못했어요.'
    } finally {
      isGameLoading.value = false
    }
  }

-  async function createGame(options = {}) {
-    const nextGameId = typeof options.gameId === 'string' ? options.gameId.trim() : newGameId.value.trim()
-    const nextGameName = typeof options.gameName === 'string' ? options.gameName.trim() : newGameName.value.trim()
+  async function createTemplate(options = {}) {
+    const nextGameId = typeof options.gameId === 'string' ? options.gameId.trim() : newTemplateId.value.trim()
+    const nextGameName = typeof options.gameName === 'string' ? options.gameName.trim() : newTemplateName.value.trim()
    const preserveUploadState = !!options.preserveUploadState
    resetMessages()
    try {
@@ -162,7 +162,7 @@ export function useAdminGameManager({
        body: JSON.stringify({
          id: nextGameId,
          name: nextGameName,
-          isPublic: !!newGameIsPublic.value,
+          isPublic: !!newTemplateIsPublic.value,
          thumbnailSrc: activeTemplateRequest.value?.type === 'create' ? (activeTemplateRequest.value?.thumbnailSrc || '') : '',
        }),
      })
@@ -187,18 +187,18 @@ export function useAdminGameManager({
          })
        }
      }
-      await refreshGames()
-      selectedGameId.value = data.game.id
-      if (customItemModalOpen.value) customItemModalTargetGameId.value = data.game.id
-      closeGameCreateModal()
-      await loadGame({ preserveUploadState })
+      await refreshTemplates()
+      selectedTemplateId.value = data.game.id
+      if (customItemModalOpen.value) customItemModalTargetTemplateId.value = data.game.id
+      closeTemplateCreateModal()
+      await loadTemplate({ preserveUploadState })
      if (!preserveUploadState && activeTemplateRequest.value?.id) {
        const sourceRequest = templateRequests.value.find((entry) => entry.id === activeTemplateRequest.value.id) || activeTemplateRequest.value
        mergeRequestItemsIntoDrafts(sourceRequest)
      }
-      success.value = '게임이 생성됐어요. 이어서 썸네일과 기본 아이템을 관리할 수 있어요.'
+      success.value = '템플릿이 생성됐어요. 이어서 썸네일과 기본 아이템을 관리할 수 있어요.'
    } catch (e) {
-      error.value = '게임 생성 실패(관리자 권한/중복 ID 확인)'
+      error.value = '템플릿 생성 실패(관리자 권한/중복 ID 확인)'
    }
  }

@@ -254,22 +254,22 @@ export function useAdminGameManager({
    }

    try {
-      if (!selectedGameId.value && activeTemplateRequest.value?.type === 'create' && !activeTemplateRequest.value?.targetGameId) {
+      if (!selectedTemplateId.value && activeTemplateRequest.value?.type === 'create' && !activeTemplateRequest.value?.targetGameId) {
        const draftGameId = (activeTemplateRequest.value?.draftGameId || '').trim()
        const draftGameName = (activeTemplateRequest.value?.draftGameName || '').trim()
        if (!draftGameId || !draftGameName) {
-          error.value = '먼저 신규 템플릿의 게임 이름과 게임 ID를 저장해주세요.'
+          error.value = '먼저 신규 템플릿의 이름과 템플릿 ID를 저장해주세요.'
          return
        }
-        await createGame({
+        await createTemplate({
          gameId: draftGameId,
          gameName: draftGameName,
          preserveUploadState: true,
        })
      }

-      if (!selectedGameId.value) {
-        error.value = '게임을 먼저 선택해주세요.'
+      if (!selectedTemplateId.value) {
+        error.value = '템플릿을 먼저 선택해주세요.'
        return
      }

@@ -283,7 +283,7 @@ export function useAdminGameManager({
          fd.append('images', entry.file)
          fd.append('labels', entry.label.trim())
        })
-        const res = await fetch(toApiUrl(`/api/admin/games/${encodeURIComponent(selectedGameId.value)}/images`), {
+        const res = await fetch(toApiUrl(`/api/admin/games/${encodeURIComponent(selectedTemplateId.value)}/images`), {
          method: 'POST',
          credentials: 'include',
          body: fd,
@@ -297,7 +297,7 @@ export function useAdminGameManager({
        for (const requestId of requestIds) {
          const draftsForRequest = requestDrafts.filter((entry) => entry.requestId === requestId)
          const result = await api.promoteAdminTemplateRequestItems(requestId, {
-            gameId: selectedGameId.value,
+            gameId: selectedTemplateId.value,
            itemIds: draftsForRequest.map((entry) => entry.itemId).filter(Boolean),
            itemSrcs: draftsForRequest.map((entry) => entry.src).filter(Boolean),
            itemLabels: draftsForRequest.reduce((acc, entry) => {
@@ -310,8 +310,8 @@ export function useAdminGameManager({
      }

      resetUploadState()
-      await loadGame()
-      success.value = `게임 기본 아이템 ${uploadCount}개 추가를 완료했어요.`
+      await loadTemplate()
+      success.value = `템플릿 기본 아이템 ${uploadCount}개 추가를 완료했어요.`
    } catch (e) {
      const apiError = e?.data?.error || ''
      if (apiError === 'no_items_selected') {
@@ -320,27 +320,27 @@ export function useAdminGameManager({
      }
      if (apiError === 'promote_items_failed') {
        const detail = e?.data?.detail ? ` (${e.data.detail})` : ''
-        error.value = `요청 아이템을 게임 기본 아이템으로 옮기지 못했어요.${detail}`
+        error.value = `요청 아이템을 템플릿 기본 아이템으로 옮기지 못했어요.${detail}`
        return
      }
      if (apiError === 'game_not_found') {
-        error.value = '선택한 게임을 찾지 못했어요.'
+        error.value = '선택한 템플릿을 찾지 못했어요.'
        return
      }
      error.value = '아이템 추가에 실패했어요.'
    }
  }

-  async function saveGameItemOrder() {
+  async function saveTemplateItemOrder() {
    resetMessages()
-    if (!selectedGameId.value || !selectedGame.value?.items?.length) return
+    if (!selectedTemplateId.value || !selectedTemplate.value?.items?.length) return

    try {
-      const data = await api.updateAdminGameItemDisplayOrder(selectedGameId.value, {
-        itemIds: selectedGame.value.items.map((item) => item.id),
+      const data = await api.updateAdminGameItemDisplayOrder(selectedTemplateId.value, {
+        itemIds: selectedTemplate.value.items.map((item) => item.id),
      })
-      selectedGame.value = {
-        ...selectedGame.value,
+      selectedTemplate.value = {
+        ...selectedTemplate.value,
        items: (data.items || []).map((item) => ({
          ...item,
          draftLabel: item.label,
@@ -360,13 +360,13 @@ export function useAdminGameManager({
    syncGameItemSortable,
    mergeRequestItemsIntoDrafts,
    removeUploadDraft,
-    loadGame,
-    createGame,
+    loadTemplate,
+    createTemplate,
    handleItemFiles,
    onFile,
    openItemFilePicker,
    clearItemFiles,
    uploadItem,
-    saveGameItemOrder,
+    saveTemplateItemOrder,
  }
 }
--- a/frontend/src/composables/useAdminTemplateRequests.js
+++ b/frontend/src/composables/useAdminTemplateRequests.js
@@ -3,10 +3,10 @@ export function useAdminTemplateRequests({
  activeTemplateRequest,
  refreshTemplateRequests,
  setTab,
-  openGameCreateModal,
-  newGameId,
-  newGameName,
-  selectAdminGame,
+  openTemplateCreateModal,
+  newTemplateId,
+  newTemplateName,
+  selectAdminTemplate,
  mergeRequestItemsIntoDrafts,
  resetMessages,
  success,
@@ -41,8 +41,8 @@ export function useAdminTemplateRequests({
  }

  function templateRequestReviewHint(request) {
-    if (request.type === 'create') return '게임 생성 후 필요한 아이템만 골라 추가하고, 끝나면 여기서 처리 완료하세요.'
-    return '확인하기를 누르면 게임 관리 화면에 요청 아이템이 임시 추가되어 필요한 것만 선별 저장할 수 있어요.'
+    if (request.type === 'create') return '템플릿 생성 후 필요한 아이템만 골라 추가하고, 끝나면 여기서 처리 완료하세요.'
+    return '확인하기를 누르면 템플릿 관리 화면에 요청 아이템이 임시 추가되어 필요한 것만 선별 저장할 수 있어요.'
  }

  async function startTemplateRequestReview(request) {
@@ -65,19 +65,19 @@ export function useAdminTemplateRequests({
      if (request.type === 'create') {
        const linkedGameId = syncedRequest.targetGameId || ''
        if (linkedGameId) {
-          await selectAdminGame(linkedGameId)
+          await selectAdminTemplate(linkedGameId)
        } else {
-          openGameCreateModal()
-          newGameId.value = (syncedRequest.draftGameId || '').trim()
-          newGameName.value = (syncedRequest.draftGameName || '').trim()
+          openTemplateCreateModal()
+          newTemplateId.value = (syncedRequest.draftGameId || '').trim()
+          newTemplateName.value = (syncedRequest.draftGameName || '').trim()
        }
        mergeRequestItemsIntoDrafts(syncedRequest)
      } else {
        const nextGameId = syncedRequest.targetGameId || syncedRequest.sourceGameId || ''
-        if (nextGameId) await selectAdminGame(nextGameId)
+        if (nextGameId) await selectAdminTemplate(nextGameId)
        mergeRequestItemsIntoDrafts(syncedRequest)
      }
-      success.value = '요청 아이템을 게임 관리 화면으로 가져왔어요. 필요한 항목만 골라서 추가해 주세요.'
+      success.value = '요청 아이템을 템플릿 관리 화면으로 가져왔어요. 필요한 항목만 골라서 추가해 주세요.'
    } catch (e) {
      error.value = '요청 확인 단계로 이동하지 못했어요.'
    } finally {
--- a/frontend/src/router/index.js
+++ b/frontend/src/router/index.js
@@ -16,7 +16,7 @@ export function createRouter() {
    history: createWebHistory(),
    routes: [
      { path: '/', name: 'home', component: HomeView },
-      { path: '/games/:gameId', name: 'gameHub', component: GameHubView },
+      { path: '/topics/:gameId', alias: ['/games/:gameId'], name: 'gameHub', component: GameHubView },
      { path: '/editor/:gameId/new', name: 'newEditor', component: TierEditorView },
      { path: '/editor/:gameId/:tierListId', name: 'editEditor', component: TierEditorView },
      { path: '/login', name: 'login', component: LoginView },
--- a/frontend/src/views/AdminView.vue
+++ b/frontend/src/views/AdminView.vue
--- a/frontend/src/views/FavoriteTierListsView.vue
+++ b/frontend/src/views/FavoriteTierListsView.vue
@@ -58,7 +58,7 @@ onMounted(loadFavorites)
    <div class="pageHead">
      <div class="pageHead__main">
        <div class="pageHead__eyebrow">Collection</div>
-        <h2 class="pageHead__title">내 즐겨찾기</h2>
+        <h2 class="pageHead__title">즐겨찾기</h2>
        <div class="pageHead__desc">마음에 드는 티어표를 모아보고, 원하는 기준으로 정렬할 수 있어요.</div>
      </div>
      <div class="pageHead__aside toolbar">
--- a/frontend/src/views/GameHubView.vue
+++ b/frontend/src/views/GameHubView.vue
@@ -1,5 +1,5 @@
 <script setup>
-import { computed, onMounted, ref } from 'vue'
+import { computed, ref, watch } from 'vue'
 import { useRoute, useRouter } from 'vue-router'
 import { api } from '../lib/api'
 import { toApiUrl } from '../lib/runtime'
@@ -9,14 +9,15 @@ const route = useRoute()
 const router = useRouter()
 const auth = useAuthStore()

-const gameId = computed(() => route.params.gameId)
-
-const gameName = ref('')
+const topicId = computed(() => route.params.gameId)
+const topicName = ref('')
 const tierLists = ref([])
 const error = ref('')
 const query = ref('')
 const brokenThumbnailIds = ref({})
+const isTopicLoading = ref(false)
 const isListView = computed(() => route.query.view === 'list')
+const topicTitle = computed(() => topicName.value || (isTopicLoading.value ? '주제 불러오는 중...' : ''))

 function fmt(ts) {
  return new Date(ts).toLocaleDateString(undefined, {
@@ -48,62 +49,65 @@ function handleThumbnailError(tierListId) {
  brokenThumbnailIds.value = { ...brokenThumbnailIds.value, [tierListId]: true }
 }

-onMounted(async () => {
-  await loadTierLists()
-})
-
 async function loadTierLists() {
+  isTopicLoading.value = true
  try {
    const [gameRes, listRes] = await Promise.all([
-      api.getGame(gameId.value),
-      api.searchPublicTierLists(gameId.value, query.value),
+      api.getGame(topicId.value),
+      api.searchPublicTierLists(topicId.value, query.value),
    ])
-    gameName.value = gameRes.game?.name || gameId.value
+    topicName.value = gameRes.game?.name || ''
    brokenThumbnailIds.value = {}
    tierLists.value = listRes.tierLists || []
  } catch (e) {
    error.value = '주제 정보를 불러오지 못했어요.'
+  } finally {
+    isTopicLoading.value = false
  }
 }

 function createNew() {
  if (!auth.user) {
-    router.push(`/login?redirect=/editor/${gameId.value}/new`)
+    router.push(`/login?redirect=/editor/${topicId.value}/new`)
    return
  }
-  router.push(`/editor/${gameId.value}/new`)
+  router.push(`/editor/${topicId.value}/new`)
 }

 function openTierList(id) {
-  router.push(`/editor/${gameId.value}/${id}`)
+  router.push(`/editor/${topicId.value}/${id}`)
 }

 function submitSearch() {
  loadTierLists()
 }
+
+watch(
+  topicId,
+  () => {
+    topicName.value = ''
+    error.value = ''
+    loadTierLists()
+  },
+  { immediate: true }
+)
 </script>

 <template>
-  <section class="dashboardHero">
-    <div class="dashboardHero__left">
-      <div class="dashboardHero__eyebrow">Collection</div>
-      <h2 class="dashboardHero__title">{{ gameName || gameId }}</h2>
-      <p class="dashboardHero__desc">이 주제의 공개 티어표를 탐색하고, 바로 새 보드를 만들어 같은 흐름으로 이어갈 수 있어요.</p>
+  <section class="pageHead">
+    <div class="pageHead__main">
+      <div class="pageHead__eyebrow">Collection</div>
+      <h2 class="pageHead__title">{{ topicTitle }}</h2>
+      <div class="pageHead__desc">이 주제의 공개 티어표를 같은 카드 레이아웃으로 살펴보고 이어서 새 티어표를 만들 수 있어요.</div>
+    </div>
+    <div class="pageHead__aside toolbar">
+      <input v-model="query" class="input" placeholder="제목 또는 작성자 검색" @keydown.enter.prevent="submitSearch" />
+      <button class="btn" @click="submitSearch">검색</button>
    </div>
  </section>

  <div v-if="error" class="error">{{ error }}</div>
  <section class="panel">
-    <div class="panel__head">
-      <div>
-        <div class="panel__title">공개 티어표</div>
-        <div class="panel__sub">제목이나 작성자로 빠르게 좁혀볼 수 있어요.</div>
-      </div>
-      <div class="searchBar">
-        <input v-model="query" class="searchBar__input" placeholder="제목 또는 작성자 검색" @keydown.enter.prevent="submitSearch" />
-        <button class="searchBar__button" @click="submitSearch">검색</button>
-      </div>
-    </div>
    <div v-if="tierLists.length === 0" class="empty">아직 공개 티어표가 없어요.</div>
    <div v-else class="list" :class="{ 'list--table': isListView }">
      <article v-for="t in tierLists" :key="t.id" class="boardCard" :class="{ 'boardCard--list': isListView }">
@@ -135,72 +139,17 @@ function submitSearch() {
 </template>

 <style scoped>
-.dashboardHero {
-  display: flex;
-  gap: 18px;
-  align-items: flex-start;
-  justify-content: space-between;
-  flex-wrap: wrap;
-  padding: 6px 2px 18px;
-}
-.dashboardHero__left {
-  display: grid;
-  gap: 8px;
-}
-.dashboardHero__eyebrow {
-  font-size: 12px;
-  color: var(--theme-text-soft);
-  text-transform: uppercase;
-  letter-spacing: 0.08em;
-}
-.dashboardHero__title {
-  margin: 4px 0 6px;
-  font-size: 32px;
-  letter-spacing: -0.04em;
-  color: var(--theme-text-strong);
-}
-.dashboardHero__desc {
-  margin: 0;
-  color: var(--theme-text-muted);
-  max-width: 720px;
-}
 .panel {
-  /* border: 1px solid var(--theme-border); */
  background: transparent;
  border-radius: 0;
  padding: 0;
 }
-.error {
-  margin: 10px 0 14px;
-  padding: 10px 12px;
-  border-radius: 12px;
-  border: 1px solid var(--theme-danger-border);
-  background: var(--theme-danger-bg);
-}
-.panel__title {
-  font-weight: 800;
-  font-size: 18px;
-}
-.panel__sub {
-  margin-top: 6px;
-  color: var(--theme-text-muted);
-  font-size: 13px;
-}
-.panel__head {
-  display: flex;
-  gap: 12px;
-  align-items: center;
-  justify-content: space-between;
-  flex-wrap: wrap;
-  margin-bottom: 18px;
-}
-.searchBar {
+.toolbar {
  display: flex;
  gap: 10px;
-  align-items: center;
  flex-wrap: wrap;
 }
-.searchBar__input {
+.input {
  min-width: 240px;
  padding: 11px 13px;
  border-radius: 14px;
@@ -208,8 +157,8 @@ function submitSearch() {
  background: var(--theme-surface-soft);
  color: var(--theme-text);
 }
-.searchBar__button {
-  padding: 11px 14px;
+.btn {
+  padding: 11px 13px;
  border-radius: 14px;
  border: 1px solid var(--theme-border);
  background: var(--theme-surface-soft-2);
@@ -217,6 +166,13 @@ function submitSearch() {
  font-weight: 800;
  cursor: pointer;
 }
+.error {
+  margin: 10px 0 14px;
+  padding: 10px 12px;
+  border-radius: 12px;
+  border: 1px solid var(--theme-danger-border);
+  background: var(--theme-danger-bg);
+}
 .empty {
  opacity: 0.75;
 }
@@ -405,7 +361,11 @@ function submitSearch() {
    grid-template-columns: 1fr;
  }

-  .searchBar__input {
+  .toolbar {
+    width: 100%;
+  }
+
+  .input {
    min-width: 0;
    width: 100%;
  }
--- a/frontend/src/views/HomeView.vue
+++ b/frontend/src/views/HomeView.vue
@@ -11,12 +11,12 @@ const route = useRoute()
 const router = useRouter()
 const auth = useAuthStore()

-const items = ref([])
+const templateRecords = ref([])
 const error = ref('')
 const loadingFavoriteId = ref('')
 const query = computed(() => (typeof route.query.q === 'string' ? route.query.q.trim().toLowerCase() : ''))
-const games = computed(() => {
-  const filtered = items.value
+const templates = computed(() => {
+  const filtered = templateRecords.value
    .filter((item) => item.id !== 'freeform')
    .filter((item) => {
      if (!query.value) return true
@@ -33,34 +33,34 @@ const games = computed(() => {
  })
 })

-async function loadGames() {
+async function loadTemplates() {
  try {
    const data = await api.listGames()
-    items.value = data.games || []
+    templateRecords.value = data.games || []
  } catch (e) {
    error.value = '백엔드에 연결할 수 없어요. backend 서버가 실행 중인지 확인해주세요.'
  }
 }

-onMounted(loadGames)
-watch(() => auth.user?.id, loadGames)
+onMounted(loadTemplates)
+watch(() => auth.user?.id, loadTemplates)

-function goGame(gameId) {
-  router.push(`/games/${gameId}`)
+function openTopic(templateId) {
+  router.push(`/topics/${templateId}`)
 }

-async function toggleFavorite(game, event) {
+async function toggleFavorite(template, event) {
  event?.stopPropagation()
  if (!auth.user) {
    router.push(`/login?redirect=${encodeURIComponent(route.fullPath || '/')}`)
    return
  }
-  if (!game?.id || loadingFavoriteId.value === game.id) return
+  if (!template?.id || loadingFavoriteId.value === template.id) return

  try {
-    loadingFavoriteId.value = game.id
-    const res = game.isFavorited ? await api.unfavoriteGame(game.id) : await api.favoriteGame(game.id)
-    items.value = items.value.map((entry) => (entry.id === game.id ? { ...entry, ...res.game } : entry))
+    loadingFavoriteId.value = template.id
+    const res = template.isFavorited ? await api.unfavoriteGame(template.id) : await api.favoriteGame(template.id)
+    templateRecords.value = templateRecords.value.map((entry) => (entry.id === template.id ? { ...entry, ...res.game } : entry))
  } catch (e) {
    error.value = '즐겨찾기 변경에 실패했어요.'
  } finally {
@@ -68,41 +68,41 @@ async function toggleFavorite(game, event) {
  }
 }

-function thumbUrl(g) {
-  return g.thumbnailSrc ? toApiUrl(g.thumbnailSrc) : ''
+function templateThumbUrl(template) {
+  return template.thumbnailSrc ? toApiUrl(template.thumbnailSrc) : ''
 }
 </script>

 <template>
  <section class="pageHead">
    <div class="pageHead__main">
-      <div class="pageHead__eyebrow">Workspace</div>
-      <h1 class="pageHead__title">Topic Library</h1>
+      <div class="pageHead__eyebrow">Topic</div>
+      <h1 class="pageHead__title">주제 선택</h1>
      <p class="pageHead__desc">자주 쓰는 주제 템플릿을 빠르게 고르고, 필요하면 바로 커스텀 티어표를 시작할 수 있어요.</p>
      <p v-if="query" class="pageHead__searchState">"{{ query }}"에 맞는 주제 템플릿만 보고 있어요.</p>
    </div>
  </section>

  <div v-if="error" class="error">{{ error }}</div>
-  <TransitionGroup v-if="games.length" name="libraryCard" tag="section" class="libraryGrid">
-    <article v-for="g in games" :key="g.id" class="libraryCard">
+  <TransitionGroup v-if="templates.length" name="libraryCard" tag="section" class="libraryGrid">
+    <article v-for="template in templates" :key="template.id" class="libraryCard">
      <button
        class="libraryCard__favorite"
        type="button"
-        :class="{ 'libraryCard__favorite--active': g.isFavorited }"
-        :disabled="loadingFavoriteId === g.id"
-        @click.stop="toggleFavorite(g, $event)"
+        :class="{ 'libraryCard__favorite--active': template.isFavorited }"
+        :disabled="loadingFavoriteId === template.id"
+        @click.stop="toggleFavorite(template, $event)"
      >
        <SvgIcon class="libraryCard__favoriteIcon" :src="kidStarIcon" :size="18" />
      </button>
-      <button class="libraryCard__main" type="button" @click="goGame(g.id)">
+      <button class="libraryCard__main" type="button" @click="openTopic(template.id)">
        <div class="libraryCard__thumbWrap">
-        <img v-if="thumbUrl(g)" class="libraryCard__thumb" :src="thumbUrl(g)" :alt="g.name" draggable="false" />
+        <img v-if="templateThumbUrl(template)" class="libraryCard__thumb" :src="templateThumbUrl(template)" :alt="template.name" draggable="false" />
        <div v-else class="libraryCard__thumbFallback">대표 썸네일</div>
      </div>
        <div class="libraryCard__body">
-          <div class="libraryCard__title">{{ g.name }}</div>
-          <div class="libraryCard__meta">{{ g.id }}</div>
+          <div class="libraryCard__title">{{ template.name }}</div>
+          <div class="libraryCard__meta">{{ template.id }}</div>
        </div>
      </button>
    </article>
--- a/frontend/src/views/MyTierListsView.vue
+++ b/frontend/src/views/MyTierListsView.vue
@@ -68,8 +68,8 @@ function openList(t) {
 <template>
  <section class="pageHead">
    <div class="pageHead__main">
-      <div class="pageHead__eyebrow">Library</div>
-      <h2 class="pageHead__title">내 티어표</h2>
+      <div class="pageHead__eyebrow">Tier Lists</div>
+      <h2 class="pageHead__title">나의 티어표</h2>
      <div class="pageHead__desc">직접 저장한 티어표를 같은 카드 레이아웃으로 다시 열고 정리할 수 있어요.</div>
    </div>
  </section>
--- a/frontend/src/views/ProfileView.vue
+++ b/frontend/src/views/ProfileView.vue
@@ -121,7 +121,7 @@ async function logout() {
    <header class="pageHead">
      <div class="pageHead__main">
        <div class="pageHead__eyebrow">Account</div>
-        <h2 class="pageHead__title">Settings</h2>
+        <h2 class="pageHead__title">설정</h2>
        <div class="pageHead__desc">계정 정보를 간결하게 정리하고, 프로필 이미지를 클릭해서 바로 변경할 수 있어요.</div>
      </div>
    </header>
--- a/frontend/src/views/SearchResultsView.vue
+++ b/frontend/src/views/SearchResultsView.vue
@@ -65,13 +65,13 @@ watch(

 <template>
  <section class="wrap">
-    <div class="head">
-      <div>
-        <div class="head__eyebrow">Search</div>
-        <h2 class="title">전체 티어표 검색</h2>
-        <div class="desc">공개된 모든 티어표를 제목과 작성자 기준으로 찾아볼 수 있어요.</div>
+    <section class="pageHead">
+      <div class="pageHead__main">
+        <div class="pageHead__eyebrow">Search</div>
+        <h2 class="pageHead__title">전체 티어표 검색</h2>
+        <div class="pageHead__desc">공개된 티어표를 제목과 작성자 기준으로 다시 찾아볼 수 있어요.</div>
      </div>
-    </div>
+    </section>

    <div v-if="error" class="error">{{ error }}</div>
    <div v-else-if="loading" class="empty">검색 중이에요.</div>
@@ -110,30 +110,6 @@ watch(
  display: grid;
  gap: 18px;
 }
-.head {
-  display: flex;
-  gap: 14px;
-  justify-content: space-between;
-  align-items: flex-end;
-  flex-wrap: wrap;
-  padding: 6px 2px 8px;
-}
-.head__eyebrow {
-  font-size: 11px;
-  letter-spacing: 0.12em;
-  text-transform: uppercase;
-  color: var(--theme-text-soft);
-}
-.title {
-  margin: 4px 0 0;
-  font-size: 32px;
-  color: var(--theme-text-strong);
-  letter-spacing: -0.04em;
-}
-.desc {
-  margin-top: 6px;
-  color: var(--theme-text-muted);
-}
 .error {
  margin: 0 0 8px;
  padding: 10px 12px;
--- a/frontend/src/views/TierEditorView.vue
+++ b/frontend/src/views/TierEditorView.vue
@@ -19,10 +19,10 @@ const auth = useAuthStore()
 const toast = useToast()
 const globalRightRailOpen = inject('rightRailOpen', ref(true))
 const localRightRailTarget = inject('localRightRailTarget', '#local-right-rail-root')
-const gameId = computed(() => route.params.gameId)
+const templateId = computed(() => route.params.gameId)
 const tierListId = computed(() => route.params.tierListId)
 const previewMode = computed(() => route.query.preview === '1')
-const gameName = ref('')
+const templateName = ref('')

 const columns = ref([{ id: 'col-1', name: '' }])
 const groups = ref([
@@ -123,19 +123,19 @@ const copiedFromLabel = computed(() => {
 const customItems = computed(() => getOrderedItems().filter((item) => item?.origin === 'custom'))
 const hasSavedTierList = computed(() => !!(persistedTierListId.value || (tierListId.value && tierListId.value !== 'new')))
 const canRequestTemplateCreate = computed(
-  () => canEdit.value && hasSavedTierList.value && gameId.value === 'freeform' && customItems.value.length > 0
+  () => canEdit.value && hasSavedTierList.value && templateId.value === 'freeform' && customItems.value.length > 0
 )
 const canRequestTemplateUpdate = computed(
-  () => canEdit.value && hasSavedTierList.value && gameId.value !== 'freeform' && customItems.value.length > 0
+  () => canEdit.value && hasSavedTierList.value && templateId.value !== 'freeform' && customItems.value.length > 0
 )
 const canSubmitTemplateCreateRequest = computed(() => !!templateRequestDraftTitle.value.trim() && !!templateRequestDraftDescription.value.trim())
 const canSubmitTemplateUpdateRequest = computed(() => !!templateRequestDraftTitle.value.trim() && !!templateRequestDraftDescription.value.trim())
-const templateRequestTargetLabel = computed(() => (gameId.value === 'freeform' ? '새로운 템플릿' : (gameName.value || gameId.value || '선택한 주제')))
+const templateRequestTargetLabel = computed(() => (templateId.value === 'freeform' ? '새로운 템플릿' : (templateName.value || templateId.value || '선택한 주제')))
 const shareTierListUrl = computed(() => {
  const savedTierListId = persistedTierListId.value || (tierListId.value && tierListId.value !== 'new' ? tierListId.value : '')
  if (!savedTierListId) return ''
-  if (typeof window === 'undefined') return `/editor/${gameId.value}/${savedTierListId}?preview=1`
-  return new URL(`/editor/${gameId.value}/${savedTierListId}?preview=1`, window.location.origin).toString()
+  if (typeof window === 'undefined') return `/editor/${templateId.value}/${savedTierListId}?preview=1`
+  return new URL(`/editor/${templateId.value}/${savedTierListId}?preview=1`, window.location.origin).toString()
 })

 watch(error, (message) => {
@@ -672,7 +672,7 @@ function buildPayload(existingId) {
  const finalTitle = effectiveTitle.value
  return {
    id: existingId || undefined,
-    gameId: gameId.value,
+    gameId: templateId.value,
    title: finalTitle,
    thumbnailSrc: thumbnailSrc.value || '',
    description: (description.value || '').trim(),
@@ -697,7 +697,7 @@ async function persistTierList({ showModal = false } = {}) {
  persistedTierListId.value = savedTierListId || ''
  title.value = res.tierList?.title || payload.title
  if (tierListId.value === 'new' && res.tierList?.id) {
-    await router.replace(`/editor/${gameId.value}/${res.tierList.id}`)
+    await router.replace(`/editor/${templateId.value}/${res.tierList.id}`)
  }
  updatedAt.value = Number(res.tierList?.updatedAt || Date.now())
  authorName.value = res.tierList?.authorName || effectiveAuthorName.value
@@ -793,7 +793,7 @@ async function confirmDeleteTierList() {
    await api.deleteTierList(currentTierListId)
    closeDeleteModal()
    toast.success('티어표를 삭제했어요.')
-    router.push(gameId.value === 'freeform' ? '/me' : `/games/${gameId.value}`)
+    router.push(templateId.value === 'freeform' ? '/me' : `/topics/${templateId.value}`)
  } catch (e) {
    error.value = '티어표 삭제에 실패했어요.'
  } finally {
@@ -808,7 +808,7 @@ async function duplicateCurrentTierList() {
    const duplicatedId = data.tierList?.id
    if (!duplicatedId) throw new Error('duplicate_failed')
    toast.success('티어표를 복사해 내 작업으로 가져왔어요.')
-    router.push(`/editor/${gameId.value}/${duplicatedId}`)
+    router.push(`/editor/${templateId.value}/${duplicatedId}`)
  } catch (e) {
    error.value = '티어표 복사에 실패했어요.'
  }
@@ -841,7 +841,7 @@ async function requestTemplate(type) {
    await api.requestTierListTemplate({
      type,
      sourceTierListId: sourceId,
-      gameId: gameId.value,
+      gameId: templateId.value,
      requestTitle: templateRequestDraftTitle.value.trim(),
      requestDescription: templateRequestDraftDescription.value.trim(),
      thumbnailSrc: saved.tierList?.thumbnailSrc || thumbnailSrc.value || '',
@@ -892,13 +892,13 @@ onMounted(() => {
    authorAccountName.value = ((auth.user?.email || '').trim().split('@')[0] || '').trim()

    if (isNewTierList.value && !auth.user) {
-      router.replace(`/login?redirect=/editor/${gameId.value}/new`)
+      router.replace(`/login?redirect=/editor/${templateId.value}/new`)
      return
    }

    try {
-      const gameRes = await api.getGame(gameId.value)
-      gameName.value = gameRes.game?.name || gameId.value
+      const gameRes = await api.getGame(templateId.value)
+      templateName.value = gameRes.game?.name || templateId.value
      const base = (gameRes.items || []).map((img) => ({
        id: img.id,
        src: img.src,
@@ -1079,7 +1079,7 @@ onUnmounted(() => {
    <div class="modalCard" role="dialog" aria-modal="true" aria-labelledby="deleteTierListTitle">
      <div id="deleteTierListTitle" class="modalCard__title">티어표 삭제</div>
      <div class="modalCard__desc">
-        "{{ title || gameName || '이 티어표' }}"를 삭제할까요? 삭제 후에는 복구할 수 없어요.
+        "{{ title || templateName || '이 티어표' }}"를 삭제할까요? 삭제 후에는 복구할 수 없어요.
      </div>
      <div class="modalCard__actions">
        <button class="btn btn--ghost" @click="closeDeleteModal">취소</button>
@@ -1120,7 +1120,7 @@ onUnmounted(() => {
    <div class="editorMain">
      <section class="head">
        <div class="editorMain__headCopy">
-          <div class="editorMain__title">{{ gameName || gameId }}</div>
+          <div class="editorMain__title">{{ templateName || templateId }}</div>
          <div class="editorMain__subtitle">
            <template v-if="canEdit">
              행/열 이름과 순서를 바꾸고 아이템을 드래그해서 배치할 수 있어요.
@@ -1131,7 +1131,7 @@ onUnmounted(() => {
          </div>
          <div v-if="sourceTierListId" class="editorMain__sourceNote">
            <span>복사본</span>
-            <button class="editorMain__sourceLink" type="button" @click="router.push(`/editor/${gameId}/${sourceTierListId}`)">{{ copiedFromLabel }}</button>
+            <button class="editorMain__sourceLink" type="button" @click="router.push(`/editor/${templateId}/${sourceTierListId}`)">{{ copiedFromLabel }}</button>
          </div>
        </div>
      </section>
Author	SHA1	Message	Date
zenn	6b6676ceec	릴리스: v1.4.8 주제 헤더 안정화와 검색 헤더 통일	2026-04-02 18:50:21 +09:00
zenn	de640de4a1	릴리스: v1.4.7 컬렉션 레이아웃 정리와 topics 경로 1차	2026-04-02 18:47:37 +09:00
zenn	20955e277c	릴리스: v1.4.6 관리자 내부 명칭 정리 2차	2026-04-02 18:43:39 +09:00
zenn	1ed08d1e34	릴리스: v1.4.5 프런트 내부 명칭 정리 1차	2026-04-02 18:26:18 +09:00
zenn	a733c97991	릴리스: v1.4.4 화면 용어 정리 마무리	2026-04-02 18:20:13 +09:00
zenn	31613e4613	릴리스: v1.4.3 사용자 노출 용어 정리 3차	2026-04-02 18:17:50 +09:00
zenn	d5621362f1	릴리스: v1.4.2 사용자 노출 용어 정리 2차	2026-04-02 18:14:13 +09:00
zenn	caaddb8448	릴리스: v1.4.1 메뉴와 화면 타이틀 한글 통일	2026-04-02 18:11:17 +09:00