릴리스: v1.3.63 이미지 최적화 작업 라벨 정리

릴리스: v1.3.62 에디터 저장 순서와 삭제 조건 정리
릴리스: v1.3.61 드롭존 아이콘과 업로드 UI 통일
2026-04-02 14:03:41 +09:00 · 2026-04-02 13:57:23 +09:00 · 2026-04-02 13:48:14 +09:00 · 2026-04-02 13:41:14 +09:00 · 2026-04-02 12:46:59 +09:00 · 2026-04-02 12:06:13 +09:00
15 changed files with 916 additions and 137 deletions
--- a/backend/src/db.js
+++ b/backend/src/db.js
@@ -73,6 +73,7 @@ function mapGameRow(row) {
    id: row.id,
    name: row.name,
    thumbnailSrc: row.thumbnail_src || '',
+    isPublic: row.is_public == null ? true : !!row.is_public,
    displayRank: row.display_rank == null ? null : Number(row.display_rank),
    createdAt: Number(row.created_at),
  }
@@ -256,11 +257,18 @@ async function ensureSchema() {
        id VARCHAR(120) PRIMARY KEY,
        name VARCHAR(120) NOT NULL,
        thumbnail_src VARCHAR(255) NOT NULL DEFAULT '',
+        is_public TINYINT(1) NOT NULL DEFAULT 1,
        display_rank INT NULL DEFAULT NULL,
        created_at BIGINT NOT NULL
      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
    `)

+    const gameIsPublicColumns = await query("SHOW COLUMNS FROM games LIKE 'is_public'")
+    if (!gameIsPublicColumns.length) {
+      await query('ALTER TABLE games ADD COLUMN is_public TINYINT(1) NOT NULL DEFAULT 1 AFTER thumbnail_src')
+      await query('UPDATE games SET is_public = 1 WHERE is_public IS NULL')
+    }
+
    const displayRankColumns = await query("SHOW COLUMNS FROM games LIKE 'display_rank'")
    if (!displayRankColumns.length) {
      await query('ALTER TABLE games ADD COLUMN display_rank INT NULL DEFAULT NULL AFTER thumbnail_src')
@@ -643,12 +651,14 @@ async function adminDeleteUser(id) {
  await query('DELETE FROM users WHERE id = ?', [id])
 }

-async function listGames(currentUserId = '') {
+async function listGames(currentUserId = '', options = {}) {
+  const includePrivate = !!options.includePrivate
  const rows = await query(
    `
-      SELECT id, name, thumbnail_src, display_rank, created_at
+      SELECT id, name, thumbnail_src, is_public, display_rank, created_at
      FROM games
      WHERE id <> ?
+      ${includePrivate ? '' : 'AND is_public = 1'}
      ORDER BY
        CASE WHEN display_rank IS NULL THEN 1 ELSE 0 END ASC,
        display_rank ASC,
@@ -669,7 +679,7 @@ async function listGames(currentUserId = '') {
 }

 async function findGameById(id) {
-  const rows = await query('SELECT id, name, thumbnail_src, display_rank, created_at FROM games WHERE id = ? LIMIT 1', [id])
+  const rows = await query('SELECT id, name, thumbnail_src, is_public, display_rank, created_at FROM games WHERE id = ? LIMIT 1', [id])
  return mapGameRow(rows[0])
 }

@@ -702,11 +712,12 @@ async function getGameDetail(gameId) {
  return { game, items }
 }

-async function createGame({ id, name }) {
-  await query('INSERT INTO games (id, name, thumbnail_src, display_rank, created_at) VALUES (?, ?, ?, ?, ?)', [
+async function createGame({ id, name, isPublic = true }) {
+  await query('INSERT INTO games (id, name, thumbnail_src, is_public, display_rank, created_at) VALUES (?, ?, ?, ?, ?, ?)', [
    id,
    name,
    '',
+    isPublic ? 1 : 0,
    null,
    now(),
  ])
@@ -718,6 +729,11 @@ async function updateGameThumbnail(gameId, thumbnailSrc) {
  return findGameById(gameId)
 }

+async function updateGameVisibility(gameId, isPublic) {
+  await query('UPDATE games SET is_public = ? WHERE id = ?', [isPublic ? 1 : 0, gameId])
+  return findGameById(gameId)
+}
+
 async function findImageAssetByHash(contentHash) {
  const rows = await query(
    'SELECT id, content_hash, src, label_override, mime_type, byte_size, original_byte_size, width, height, created_at FROM image_assets WHERE content_hash = ? LIMIT 1',
@@ -2004,6 +2020,11 @@ async function updateTemplateRequestStatus({ id, status }) {
  return findTemplateRequestById(id)
 }

+async function updateTemplateRequestTargetGame({ id, targetGameId }) {
+  await query('UPDATE template_requests SET target_game_id = ?, updated_at = ? WHERE id = ?', [targetGameId || '', now(), id])
+  return findTemplateRequestById(id)
+}
+
 async function deleteTierList(id) {
  await query('DELETE FROM tierlists WHERE id = ?', [id])
 }
@@ -2139,6 +2160,7 @@ module.exports = {
  getGameDetail,
  createGame,
  updateGameThumbnail,
+  updateGameVisibility,
  findImageAssetByHash,
  findImageAssetBySrc,
  findImageAssetById,
@@ -2184,4 +2206,5 @@ module.exports = {
  findTemplateRequestById,
  listAdminTemplateRequests,
  updateTemplateRequestStatus,
+  updateTemplateRequestTargetGame,
 }
--- a/backend/src/routes/admin.js
+++ b/backend/src/routes/admin.js
@@ -9,10 +9,12 @@ const {
  findUserById,
  findGameById,
  findGameItemById,
+  listGameItems,
  findImageAssetById,
  createGame,
  listGames,
  updateGameThumbnail,
+  updateGameVisibility,
  createGameItem,
  updateGameItemLabel,
  updateGameItemDisplayOrder,
@@ -33,6 +35,7 @@ const {
  listAdminTemplateRequests,
  findTemplateRequestById,
  updateTemplateRequestStatus,
+  updateTemplateRequestTargetGame,
  adminUpdateUser,
  adminUpdateUserPassword,
  adminDeleteUser,
@@ -65,6 +68,17 @@ function buildItemLabelFromFilename(file) {
  return normalized || 'item'
 }

+function buildItemLabelFromSrc(src) {
+  const raw = typeof src === 'string' ? src : ''
+  const base = path.basename(raw.split('?')[0] || '', path.extname(raw.split('?')[0] || ''))
+  const normalized = base
+    .replace(/[_-]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, 60)
+  return normalized || 'item'
+}
+
 const upload = createMemoryUpload(multer, { fileSize: 8 * 1024 * 1024, maxCount: 50 })
 const avatarUpload = createMemoryUpload(multer, { fileSize: 4 * 1024 * 1024 })

@@ -93,13 +107,36 @@ function canManageAdminRole(actingUser, primaryAdmin) {
 }

 router.post('/games', requireAdmin, async (req, res) => {
-  const schema = z.object({ id: z.string().min(1), name: z.string().min(1).max(60) })
+  const schema = z.object({
+    id: z.string().min(1),
+    name: z.string().min(1).max(60),
+    isPublic: z.boolean().optional().default(false),
+    thumbnailSrc: z.string().max(255).optional().default(''),
+  })
  const parsed = schema.safeParse(req.body)
  if (!parsed.success) return res.status(400).json({ error: 'bad_request' })
  const exists = await findGameById(parsed.data.id)
  if (exists) return res.status(409).json({ error: 'game_id_taken' })
-  const game = await createGame({ id: parsed.data.id, name: parsed.data.name })
-  res.json({ game })
+  const game = await createGame({ id: parsed.data.id, name: parsed.data.name, isPublic: parsed.data.isPublic })
+  if (parsed.data.thumbnailSrc) {
+    const copiedThumb = await copyUploadIntoGameAsset(parsed.data.thumbnailSrc)
+    await updateGameThumbnail(game.id, copiedThumb)
+  }
+  res.json({ game: await findGameById(game.id) })
+})
+
+router.patch('/games/:gameId', requireAdmin, async (req, res) => {
+  const schema = z.object({
+    isPublic: z.boolean(),
+  })
+  const parsed = schema.safeParse(req.body)
+  if (!parsed.success) return res.status(400).json({ error: 'bad_request' })
+
+  const game = await findGameById(req.params.gameId)
+  if (!game) return res.status(404).json({ error: 'not_found' })
+
+  const updated = await updateGameVisibility(game.id, parsed.data.isPublic)
+  res.json({ game: updated })
 })

 router.patch('/games/display-order', requireAdmin, async (req, res) => {
@@ -109,7 +146,7 @@ router.patch('/games/display-order', requireAdmin, async (req, res) => {
  const parsed = schema.safeParse(req.body)
  if (!parsed.success) return res.status(400).json({ error: 'bad_request' })

-  const games = await listGames()
+  const games = await listGames('', { includePrivate: true })
  const validGameIds = new Set(games.map((game) => game.id))
  const filteredIds = parsed.data.gameIds.filter((gameId) => validGameIds.has(gameId))
  const updatedGames = await updateGameDisplayOrder(filteredIds)
@@ -391,9 +428,25 @@ async function promoteLibraryItemToGameItem({ item, gameId }) {
 }

 async function copyUploadIntoGameAsset(src) {
-  if (typeof src !== 'string' || !src.startsWith('/uploads/')) return src || ''
-  if (src.startsWith('/uploads/assets/')) return src
-  return src
+  if (typeof src !== 'string') return ''
+  const raw = src.trim()
+  if (!raw) return ''
+
+  if (raw.startsWith('/uploads/')) {
+    if (raw.startsWith('/uploads/assets/')) return raw
+    return raw
+  }
+
+  try {
+    const url = new URL(raw)
+    if (url.pathname.startsWith('/uploads/')) {
+      return url.pathname
+    }
+  } catch (error) {
+    return raw
+  }
+
+  return raw
 }

 function uniqueTierListPoolItems(tierList) {
@@ -427,10 +480,17 @@ async function promoteTierListItemsToGame({ tierList, gameId, itemIds = [] }) {
 }

 async function promoteSnapshotItemsToGame({ items, gameId }) {
+  const existingItems = await listGameItems(gameId)
+  const existingSrcs = new Set(
+    existingItems
+      .map((item) => (typeof item?.src === 'string' ? item.src.trim() : ''))
+      .filter(Boolean)
+  )
  const createdItems = []

  for (const item of items || []) {
    const copiedSrc = await copyUploadIntoGameAsset(item.src)
+    if (!copiedSrc || existingSrcs.has(copiedSrc)) continue
    createdItems.push(
      await createGameItem({
        id: nanoid(),
@@ -439,23 +499,40 @@ async function promoteSnapshotItemsToGame({ items, gameId }) {
        label: item.label,
      })
    )
+    existingSrcs.add(copiedSrc)
  }

  return createdItems
 }

-function pickTemplateRequestItems(templateRequest, itemIds = [], itemLabels = {}) {
+function pickTemplateRequestItems(templateRequest, itemIds = [], itemLabels = {}, itemSrcs = []) {
  const requestedIds = new Set((itemIds || []).filter(Boolean))
+  const requestedSrcs = new Set((itemSrcs || []).filter((src) => typeof src === 'string' && src.trim()).map((src) => src.trim()))
  const items = Array.isArray(templateRequest?.items) ? templateRequest.items : []
-  const filtered = requestedIds.size ? items.filter((item) => item?.id && requestedIds.has(item.id)) : items
-  return filtered.map((item) => ({
-    ...item,
-    label: typeof itemLabels?.[item.id] === 'string' && itemLabels[item.id].trim() ? itemLabels[item.id].trim().slice(0, 60) : item.label,
-  }))
+  const filtered =
+    requestedIds.size || requestedSrcs.size
+      ? items.filter((item) => (item?.id && requestedIds.has(item.id)) || (typeof item?.src === 'string' && requestedSrcs.has(item.src.trim())))
+      : items
+  return filtered
+    .filter((item) => typeof item?.src === 'string' && item.src.trim())
+    .map((item) => {
+      const draftLabel =
+        typeof itemLabels?.[item.id] === 'string' && itemLabels[item.id].trim()
+          ? itemLabels[item.id].trim().slice(0, 60)
+          : typeof item?.label === 'string' && item.label.trim()
+            ? item.label.trim().slice(0, 60)
+            : buildItemLabelFromSrc(item.src)
+
+      return {
+        ...item,
+        src: item.src.trim(),
+        label: draftLabel,
+      }
+    })
 }

 async function createGameTemplateFromTierList({ tierList, gameId, gameName }) {
-  await createGame({ id: gameId, name: gameName })
+  await createGame({ id: gameId, name: gameName, isPublic: false })
  if (tierList.thumbnailSrc) {
    const copiedThumb = await copyUploadIntoGameAsset(tierList.thumbnailSrc)
    await updateGameThumbnail(gameId, copiedThumb)
@@ -478,7 +555,7 @@ async function createGameTemplateFromTierList({ tierList, gameId, gameName }) {
 }

 async function createGameTemplateFromRequest({ templateRequest, gameId, gameName }) {
-  await createGame({ id: gameId, name: gameName })
+  await createGame({ id: gameId, name: gameName, isPublic: false })

  if (templateRequest.thumbnailSrc) {
    const copiedThumb = await copyUploadIntoGameAsset(templateRequest.thumbnailSrc)
@@ -636,12 +713,19 @@ router.post('/template-requests/:requestId/approve', requireAdmin, async (req, r
 })

 router.post('/template-requests/:requestId/review', requireAdmin, async (req, res) => {
-  const templateRequest = await findTemplateRequestById(req.params.requestId)
+  let templateRequest = await findTemplateRequestById(req.params.requestId)
  if (!templateRequest) return res.status(404).json({ error: 'not_found' })
  if (templateRequest.status === 'completed' || templateRequest.status === 'rejected' || templateRequest.status === 'approved') {
    return res.status(409).json({ error: 'request_already_handled' })
  }

+  if (templateRequest.type === 'create' && templateRequest.targetGameId && !templateRequest.targetGameName) {
+    templateRequest = await updateTemplateRequestTargetGame({
+      id: templateRequest.id,
+      targetGameId: '',
+    })
+  }
+
  if (templateRequest.status === 'reviewing') {
    return res.json({ request: templateRequest })
  }
@@ -650,11 +734,36 @@ router.post('/template-requests/:requestId/review', requireAdmin, async (req, re
  res.json({ request })
 })

+router.post('/template-requests/:requestId/link-game', requireAdmin, async (req, res) => {
+  const schema = z.object({
+    gameId: z.string().trim().min(1).max(120),
+  })
+  const parsed = schema.safeParse(req.body)
+  if (!parsed.success) return res.status(400).json({ error: 'bad_request' })
+
+  const templateRequest = await findTemplateRequestById(req.params.requestId)
+  if (!templateRequest) return res.status(404).json({ error: 'not_found' })
+  if (templateRequest.type !== 'create') return res.status(409).json({ error: 'create_request_required' })
+  if (!['pending', 'reviewing'].includes(templateRequest.status)) {
+    return res.status(409).json({ error: 'request_already_handled' })
+  }
+
+  const game = await findGameById(parsed.data.gameId)
+  if (!game) return res.status(404).json({ error: 'game_not_found' })
+
+  const request = await updateTemplateRequestTargetGame({
+    id: templateRequest.id,
+    targetGameId: game.id,
+  })
+  res.json({ request })
+})
+
 router.post('/template-requests/:requestId/promote-items', requireAdmin, async (req, res) => {
  const schema = z.object({
    gameId: z.string().trim().min(1).max(120),
    itemIds: z.array(z.string().min(1)).optional().default([]),
-    itemLabels: z.record(z.string().min(1).max(60)).optional().default({}),
+    itemSrcs: z.array(z.string().min(1)).optional().default([]),
+    itemLabels: z.record(z.string(), z.string().min(1).max(60)).optional().default({}),
  })
  const parsed = schema.safeParse(req.body)
  if (!parsed.success) return res.status(400).json({ error: 'bad_request' })
@@ -668,10 +777,32 @@ router.post('/template-requests/:requestId/promote-items', requireAdmin, async (
  const game = await findGameById(parsed.data.gameId)
  if (!game) return res.status(404).json({ error: 'game_not_found' })

-  const items = await promoteSnapshotItemsToGame({
-    items: pickTemplateRequestItems(templateRequest, parsed.data.itemIds, parsed.data.itemLabels),
-    gameId: game.id,
-  })
+  const promotableItems = pickTemplateRequestItems(templateRequest, parsed.data.itemIds, parsed.data.itemLabels, parsed.data.itemSrcs)
+  if (!promotableItems.length) {
+    return res.status(400).json({ error: 'no_items_selected' })
+  }
+
+  let items = []
+  try {
+    items = await promoteSnapshotItemsToGame({
+      items: promotableItems,
+      gameId: game.id,
+    })
+  } catch (error) {
+    console.error('[admin] template request promote-items failed', {
+      requestId: templateRequest.id,
+      gameId: game.id,
+      itemCount: promotableItems.length,
+      message: error?.message || 'unknown_error',
+      code: error?.code || '',
+      stack: error?.stack || '',
+    })
+    return res.status(500).json({
+      error: 'promote_items_failed',
+      detail: error?.message || 'unknown_error',
+      code: error?.code || '',
+    })
+  }

  const request =
    templateRequest.status === 'reviewing'
--- a/backend/src/routes/games.js
+++ b/backend/src/routes/games.js
@@ -5,7 +5,7 @@ const { requireAuth } = require('../middleware/auth')
 const router = express.Router()

 router.get('/', async (req, res) => {
-  const games = await listGames(req.session?.userId || '')
+  const games = await listGames(req.session?.userId || '', { includePrivate: !!req.session?.isAdmin })
  res.json({ games })
 })

@@ -30,6 +30,7 @@ router.delete('/:gameId/favorite', requireAuth, async (req, res) => {
 router.get('/:gameId', async (req, res) => {
  const detail = await getGameDetail(req.params.gameId)
  if (!detail) return res.status(404).json({ error: 'not_found' })
+  if (!detail.game.isPublic && !req.session?.isAdmin) return res.status(404).json({ error: 'not_found' })
  res.json({ game: detail.game, items: detail.items })
 })

--- a/docs/history.md
+++ b/docs/history.md
@@ -1,5 +1,33 @@
 # 의사결정 이력

+## 2026-04-02 v1.3.63
+- 이미지 최적화 기록은 내부 라우트 카테고리를 그대로 보여주면 운영자가 실제 의미를 해석해야 하므로, 관리자 화면에는 기능 기준의 한국어 라벨과 재사용 여부를 함께 보여주는 편이 맞다고 정리했다.
+
+## 2026-04-02 v1.3.62
+- 커스텀 이미지가 많은 상태에서 저장할 때 사용자 체감 순서가 흔들리는 것은 업로드 성공보다 더 직접적인 UX 문제이므로, 내부 객체 키 순서가 아니라 현재 화면 배치 순서를 저장 기준으로 삼는 편이 맞다고 정리했다.
+- 템플릿 요청이 저장본에서만 가능하다면 삭제도 같은 기준을 따르는 편이 흐름상 자연스러우므로, 저장되지 않은 초안에는 삭제 액션을 노출하지 않는 쪽으로 판단했다.
+
+## 2026-04-02 v1.3.61
+- 업로드 드롭존은 기능만 같고 생김새가 다르면 운영자와 사용자 모두 맥락 전환 비용이 생기므로, 관리자와 에디터에서 같은 아이콘·점선 보더·버튼 문법으로 읽히게 맞추는 편이 낫다고 정리했다.
+- 썸네일 교체 영역은 일반 입력 필드처럼 보이면 클릭 가능성이 떨어지므로, 이미지 미리보기 위에서도 업로드 박스라는 인상이 유지되게 밝은 배경과 아이콘을 함께 쓰는 쪽으로 판단했다.
+
+## 2026-04-02 v1.3.60
+- 관리자 접근 차단은 유지하되, 이미 로그인된 관리자가 새로고침할 때 홈으로 튕기는 체감은 권한 제어보다 더 큰 문제이므로 인증 결과가 나올 때까지 같은 세션 확인 요청을 기다리는 편이 맞다고 정리했다.
+- 관리자 썸네일 드롭존과 에디터 보드 드롭존은 기능은 같아도 현재 상태가 문구와 형태로 바로 드러나야 하므로, 빈 상태와 교체 상태를 텍스트로 구분하고 점선 박스 형태를 더 적극적으로 드러내는 쪽으로 판단했다.
+
+## 2026-04-02 v1.3.59
+- 템플릿 요청 아이템 반영은 관리자 주의에만 맡기기보다, 서버에서 같은 게임 안의 동일 `src` 중복 생성을 막고 프런트에서도 이미 반영된 요청 아이템을 다시 드래프트에 올리지 않는 편이 운영 안정성에 더 낫다고 정리했다.
+- 신규 템플릿 요청은 “완전한 임시 게임” 구조로 바로 바꾸기보다, 우선 한 번 만든 게임을 요청과 연결해 다시 `확인하기`를 눌러도 같은 게임을 재사용하게 만드는 편이 리스크 대비 효과가 크다고 판단했다.
+- 신규 템플릿 요청 카드는 생성 여부가 관리자의 머릿속 상태가 아니라 UI 메타로 드러나야 하므로, `연결된 게임 있음/없음`과 `이미 반영 n개`를 카드와 작업 패널 양쪽에서 함께 보여주는 편이 맞다고 정리했다.
+
+## 2026-04-02 v1.3.55
+- 관리자 요청/업로드 배지는 문구만 다르면 빠르게 구분하기 어려우므로, 같은 `pill` 구조를 유지하되 색으로도 역할을 나누는 편이 운영 판단에 더 적합하다고 정리했다.
+- 신규 템플릿 요청으로 새 게임을 만들 때는 아이템만 가져오고 썸네일이 비어 있으면 식별성이 떨어지므로, 요청 썸네일도 기본값으로 함께 승계하는 편이 맞다고 판단했다.
+
+## 2026-04-02 v1.3.54
+- 관리자 요청 카드는 운영자가 이미 흐름을 알고 있다는 전제에서, 설명형 힌트보다 즉시 판단에 필요한 메타와 액션만 남기는 편이 더 적합하다고 정리했다.
+- 요청 종류 표시는 중복 텍스트보다 오른쪽 상단의 짧은 상태 배지 하나로 고정하고, 하단 액션 줄은 `보조 링크는 왼쪽 / 실제 처리 버튼은 오른쪽` 구조가 더 읽기 쉽다고 판단했다.
+
 ## 2026-04-02 v1.3.53
 - 관리자 후속 리팩터링은 남은 큰 액션 묶음인 `상단 고정 게임 정렬`과 `커스텀 아이템 검수`부터 composable로 분리하는 편이 `AdminView.vue` 체감 복잡도를 가장 빨리 낮춘다고 판단했다.
 - 이 단계에서도 레이아웃이나 문구보다 로직 책임 경계를 먼저 옮기고, 실제 스타일 파일 분리는 그 다음 단계로 이어가는 편이 안전하다고 정리했다.
--- a/docs/todo.md
+++ b/docs/todo.md
@@ -1,10 +1,21 @@
 # 할 일 및 이슈

+## 단기 확인
+- 관리자 계정으로 `/admin/...`을 직접 새로고침했을 때 홈으로 튕기지 않고 그대로 유지되는지, 실제 세션이 살아 있는 브라우저와 만료된 브라우저 각각에서 한 번 더 QA한다.
+- 티어표 만들기 화면의 보드 드롭존은 점선/높이/중앙 정렬로 존재감이 커졌으므로, 데스크톱과 모바일에서 파일 선택 버튼과 안내 문구 밀도를 한 번 더 QA한다.
+- 관리자 썸네일 드롭존과 기본 아이템 추가 드롭존은 에디터 드롭존과 시각 문법을 맞췄으므로, 라이트모드와 좁은 화면에서 아이콘 대비와 배경 밝기가 과하지 않은지 한 번 더 QA한다.
+- 커스텀 이미지가 많은 티어표를 저장할 때 커스텀 이름 정리 목록과 미배치 아이템 영역 순서가 실제로 안정적으로 유지되는지, 10장 이상 업로드한 상태로 한 번 더 QA한다.
+- 관리자 이미지 최적화 현황은 최근 작업 라벨을 읽기 쉬운 이름으로 바꿨으므로, 실제 운영 데이터에서 `커스텀 아이템 / 티어표 썸네일 / 게임·템플릿 이미지 / 프로필 아바타` 흐름이 기대와 맞게 찍히는지 한 번 더 QA한다.
+
 ## 중기 개선
+- 신규 템플릿 요청은 현재 `첫 생성 1회 후 요청과 게임을 연결해 재사용` 단계까지 정리했으므로, 다음 단계에서는 정말로 게임을 DB에 만들기 전까지 임시 작업 상태로 유지할지 여부를 운영 흐름 기준으로 결정한다.
+- 관리자 템플릿 요청은 동일 `src` 중복 생성 방지와 `연결된 게임/이미 반영 n개` 표시까지 붙였으므로, 이후에는 요청별 반영 이력(예: 어떤 아이템을 언제 반영했는지)까지 별도로 남길지 검토한다.
 - 관리자 URL 분리는 시작했으므로, 다음 단계에서는 `AdminView.vue` 단일 대형 파일을 섹션별 뷰/컴포저블로 쪼개고 직접 진입 시 선택 게임/요청 작업 상태 복원 범위도 함께 정리한다.
 - 관리자 본문 컴포넌트 분리와 `게임/템플릿 요청/회원 관리/아이템 관리/목록 관리` composable 분리는 시작했으므로, 다음 단계에서는 공통 모달 상태를 어느 계층에서 소유할지 정리하고 남은 관리자 유틸 함수를 더 줄인다.
 - 관리자 화면은 섹션 경로 분리까지 끝났으므로, 다음 단계에서는 `AdminView.vue`를 실제 레이아웃 뷰와 섹션별 라우트 컴포넌트로 더 쪼갤지 결정한다.
 - 관리자 공통 스타일은 `adminUiScope` 기준으로 다시 묶었으므로, 다음 단계에서는 각 섹션을 별도 파일로 완전히 분리할 때 스타일도 `admin.css` 또는 섹션별 스타일로 옮길지 결정한다.
+- 관리자 요청 카드 밀도는 줄였으므로, 다음 단계에서는 전체 티어표 카드와 요청 카드의 상단/하단 액션 정렬을 한 번 더 통일할지 비교 QA한다.
+- 신규 템플릿 요청 썸네일 기본 승계는 붙였으므로, 다음 단계에서는 요청 아이템 반영 후 `처리 완료`까지의 관리자 흐름을 실제 데이터로 한 번 더 QA한다.
 - 관리자 게임 아이템 순서 저장은 추가됐으므로, 다음 단계에서는 새 아이템 추가 직후 `자동 맨 앞 배치`와 `관리자 수동 고정 순서`의 우선순위를 실제 운영 흐름 기준으로 한 번 더 QA한다.
 - 관리자 템플릿 요청 미리보기는 실제 완성본 iframe 방식과의 체감 차이를 마지막으로 한 번 더 QA한다.
 - 라이트모드/다크모드 2차 보정까지 반영했으므로, 남은 작업은 전체 화면을 실제 사용 흐름으로 돌려 보며 대비·명도·아이콘 가독성을 미세하게 QA하는 최종 테마 점검 단계로 가져간다.
--- a/docs/update.md
+++ b/docs/update.md
@@ -1,5 +1,41 @@
 # 업데이트 로그

+## 2026-04-02 v1.3.63
+- 관리자 이미지 최적화 최근 작업 목록은 더 이상 내부 카테고리 문자열 `custom / tierlists / games / avatars`를 그대로 노출하지 않고, 각각 `커스텀 아이템 / 티어표 썸네일 / 게임·템플릿 이미지 / 프로필 아바타`처럼 사람이 이해할 수 있는 이름으로 표시함.
+- 같은 이미지 해시를 다시 업로드해 기존 최적화 파일을 재사용한 경우에는 최근 작업 목록에 `기존 최적화 파일 재사용` 문구를 함께 보여, 새로 압축된 건지 중복 자산이 재사용된 건지 운영자가 바로 구분할 수 있게 함.
+
+## 2026-04-02 v1.3.62
+- 티어표 저장과 템플릿 요청 전 커스텀 이미지 업로드에서는 더 이상 `itemsById` 객체 키 순서에 기대지 않고, 실제 화면에 보이는 `아이템 영역 + 보드 배치 순서` 기준으로 아이템 배열을 만들도록 바꿔 저장 중 이미지 목록이 흔들리던 현상을 줄임.
+- 따라서 커스텀 아이템 이름 정리 목록, 저장 payload, 템플릿 요청 payload 모두 같은 순서 기준을 공유하게 되어, 이미지를 여러 장 올린 뒤 저장해도 사용자가 보고 있던 흐름이 덜 흔들리도록 정리함.
+- 티어표 삭제 버튼은 이제 템플릿 요청과 같은 기준으로 `저장된 티어표`에서만 노출되며, 실제 삭제도 저장본 ID가 있을 때만 동작하도록 맞춰 저장 전 초안 상태의 어색한 삭제 액션을 제거함.
+
+## 2026-04-02 v1.3.61
+- 관리자 게임 관리의 썸네일 드롭존, 관리자 기본 아이템 추가 드롭존, 티어표 에디터의 커스텀 이미지 드롭존에 `add_photo_alternate` 아이콘을 넣어 업로드 영역임을 더 빠르게 인식할 수 있게 정리함.
+- 관리자와 에디터 드롭존은 점선 보더 굵기, 라운드, 밝은 배경 톤, 활성화 상태 색 변화, 파일 선택 버튼 크기를 같은 계열로 맞춰 서로 다른 화면에서도 같은 업로드 컴포넌트처럼 읽히도록 통일함.
+- 썸네일 드롭존 역시 배경을 일반 입력 필드보다 더 밝고 넓은 업로드 박스처럼 보이게 조정해, 일반 폼 필드와 대표 이미지 교체 영역을 시각적으로 더 분명하게 구분함.
+
+## 2026-04-02 v1.3.60
+- 관리자 게임 관리의 대표 썸네일 드롭존은 이제 썸네일이 없을 때는 `클릭 & 드래그`, 이미 등록된 썸네일이 있을 때는 `썸네일 변경`으로 문구가 바뀌어 현재 동작을 더 바로 읽을 수 있게 함.
+- 관리자 인증 상태는 라우터 가드와 앱 셸이 동시에 `/api/auth/me`를 호출할 때, 가드가 아직 끝나지 않은 요청을 기다리지 못해 새로고침 직후 홈으로 튕기던 흐름이 있었으므로 인증 스토어에서 진행 중인 `refresh` Promise를 재사용하도록 정리함.
+- 따라서 관리자 계정으로 로그인된 상태에서는 `/admin/...` 경로를 새로고침해도 세션 확인이 끝날 때까지 같은 요청을 기다린 뒤 관리자 화면에 남도록 안정성을 보강함.
+- 티어표 만들기 화면의 보드 드롭존은 점선 테두리, 더 높은 박스, 중앙 정렬된 안내 문구와 버튼을 적용해 커스텀 이미지 추가 영역임을 더 즉시 인식할 수 있게 조정함.
+
+## 2026-04-02 v1.3.59
+- 관리자 템플릿 요청의 `promote-items` 처리에서는 잘못된 `z.record` 스키마 때문에 500이 나던 서버 파싱 버그를 수정하고, 요청 아이템 `src`까지 함께 받아 실제 요청 데이터와 더 안정적으로 매칭하도록 보강함.
+- 요청 아이템을 게임에 반영할 때는 이제 같은 게임 안에 동일한 `src`가 이미 있으면 새 기본 아이템을 다시 만들지 않도록 막고, 관리자 화면에서도 이미 반영된 요청 아이템은 드래프트에 다시 올리지 않게 정리함.
+- 신규 템플릿 요청으로 새 게임을 한 번 만들면 해당 요청과 새 게임을 연결해 저장하고, 이후 같은 요청에서 다시 `확인하기`를 눌렀을 때는 새 게임을 또 만들지 않고 기존에 연결된 게임으로 바로 복귀하도록 흐름을 정리함.
+- 따라서 요청 카드와 게임 관리 작업 패널에서는 `연결된 게임`, `이미 반영 n개` 같은 상태를 함께 보여, 처리 완료 전에도 현재 진행 정도와 재작업 위험을 더 쉽게 구분할 수 있게 함.
+
+## 2026-04-02 v1.3.55
+- 관리자 요청 카드 오른쪽 상단의 `신규 템플릿 / 보유 템플릿` 배지는 서로 다른 색상으로 분리해, 카드 타입을 텍스트보다 더 빠르게 구분할 수 있게 조정함.
+- 게임 관리의 기본 아이템 추가 미리보기에서도 `요청 아이템 / 직접 추가 파일` 배지를 서로 다른 색상으로 구분해, 요청 반영분과 직접 업로드분이 한눈에 섞이지 않도록 정리함.
+- 신규 템플릿 요청에서 `새 게임 만들기`를 진행할 때는 요청 티어표 대표 썸네일도 함께 새 게임 썸네일로 복사되도록 보강해, 관리자가 이후 수정하더라도 초기 식별용 썸네일은 바로 이어받을 수 있게 함.
+
+## 2026-04-02 v1.3.54
+- 관리자 `티어표 관리` 요청 카드에서는 사용법 힌트 문구와 중복 타입 텍스트를 제거해, 카드 본문이 관리 정보만 더 빠르게 읽히도록 정리함.
+- `신규 템플릿 / 보유 템플릿` 구분은 카드 오른쪽 상단의 별도 배지로 옮기고, 기존 `추가 아이템 / 확인함 여부` 배지는 그대로 유지해 정보 계층을 더 단순하게 맞춤.
+- `요청 티어표 보기` 링크는 하단 액션 줄의 왼쪽으로 옮기고 `확인하기 / 처리 완료` 버튼은 오른쪽에 정렬해, 실제 작업 버튼과 보조 링크의 역할이 한 줄 안에서도 분명하게 보이도록 조정함.
+
 ## 2026-04-02 v1.3.53
 - 관리자 리팩터링 4차로 `목록 관리` 정렬 로직과 `아이템 관리` 모달/삭제/승격 액션을 각각 `useAdminFeaturedGames`, `useAdminCustomItems` composable로 분리해 `AdminView.vue`의 직접 액션 코드를 더 줄임.
 - 따라서 관리자 메인 뷰는 섹션 연결과 공통 상태 중심으로 더 가까워졌고, 상단 고정 게임 정렬과 커스텀 아이템 처리 흐름은 각 영역 책임에 맞는 파일로 옮겨 유지보수 범위를 좁힘.
--- a/frontend/src/assets/icons/add_photo_alternate.svg
+++ b/frontend/src/assets/icons/add_photo_alternate.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="24px" viewBox="0 -960 960 960" width="24px" fill="ffffff"><path d="M480-480ZM200-120q-33 0-56.5-23.5T120-200v-560q0-33 23.5-56.5T200-840h320v80H200v560h560v-320h80v320q0 33-23.5 56.5T760-120H200Zm40-160h480L570-480 450-320l-90-120-120 160Zm440-320v-80h-80v-80h80v-80h80v80h80v80h-80v80h-80Z"/></svg>
--- a/frontend/src/components/admin/AdminGamesSection.vue
+++ b/frontend/src/components/admin/AdminGamesSection.vue
@@ -1,10 +1,13 @@
 <script setup>
 import { toApiUrl } from '../../lib/runtime'
+import SvgIcon from '../SvgIcon.vue'
+import addPhotoAlternateIcon from '../../assets/icons/add_photo_alternate.svg'

 const props = defineProps({
  activeTemplateRequest: { type: Object, default: null },
  templateRequestSourceUrl: { type: Function, required: true },
  stagedRequestDraftCount: { type: Number, required: true },
+  appliedRequestItemCount: { type: Number, required: true },
  openGameCreateModal: { type: Function, required: true },
  isGameLoading: { type: Boolean, required: true },
  hasSelectedGame: { type: Boolean, required: true },
@@ -29,6 +32,10 @@ const props = defineProps({
  removeGameItem: { type: Function, required: true },
  selectedGameId: { type: String, default: '' },
 })
+
+function setGameItemListElement(el) {
+  props.gameItemListRef(el)
+}
 </script>

 <template>
@@ -38,12 +45,22 @@ const props = defineProps({
        <div class="panel__title">진행 중인 요청 작업</div>
        <div class="requestWorkspace__title">{{ props.activeTemplateRequest.sourceTierListTitle || '템플릿 요청' }}</div>
        <div class="hint hint--tight">
-          {{ props.activeTemplateRequest.type === 'create' ? '새 게임을 만든 뒤 필요한 아이템만 골라 저장하세요.' : '필요한 아이템만 남긴 뒤 기본 아이템 추가 버튼으로 반영하세요.' }}
+          {{
+            props.activeTemplateRequest.type === 'create'
+              ? (props.activeTemplateRequest.targetGameId
+                ? '이미 연결된 신규 템플릿이 있어요. 필요한 아이템만 골라 저장하세요.'
+                : '새 게임을 한 번 만든 뒤 필요한 아이템만 골라 저장하세요.')
+              : '필요한 아이템만 남긴 뒤 기본 아이템 추가 버튼으로 반영하세요.'
+          }}
        </div>
      </div>
      <div class="requestWorkspace__stats">
        <span class="pill pill--accent">{{ props.activeTemplateRequest.type === 'create' ? '신규 게임 요청' : '기존 게임 업데이트' }}</span>
        <span class="pill">요청 아이템 {{ props.stagedRequestDraftCount }}개</span>
+        <span v-if="props.appliedRequestItemCount" class="pill pill--soft">이미 반영 {{ props.appliedRequestItemCount }}개</span>
+        <span v-if="props.activeTemplateRequest.type === 'create' && (props.activeTemplateRequest.targetGameName || props.activeTemplateRequest.targetGameId)" class="pill pill--soft">
+          연결된 게임 · {{ props.activeTemplateRequest.targetGameName || props.activeTemplateRequest.targetGameId }}
+        </span>
      </div>
    </div>
    <div class="requestWorkspace__actions">
@@ -56,7 +73,12 @@ const props = defineProps({
      >
        요청 티어표 보기
      </a>
-      <button v-if="props.activeTemplateRequest.type === 'create'" class="btn btn--ghost btn--small" type="button" @click="props.openGameCreateModal">
+      <button
+        v-if="props.activeTemplateRequest.type === 'create' && !props.activeTemplateRequest.targetGameId"
+        class="btn btn--ghost btn--small"
+        type="button"
+        @click="props.openGameCreateModal"
+      >
        새 게임 만들기
      </button>
    </div>
@@ -86,24 +108,24 @@ const props = defineProps({
            <div
              class="dropZone"
              :class="{ 'dropZone--active': props.isItemDragOver }"
+              @click="props.openItemFilePicker"
              @dragenter="props.onItemDragEnter"
              @dragover="props.onItemDragOver"
              @dragleave="props.onItemDragLeave"
              @drop="props.onItemDrop"
            >
+              <div class="dropZone__iconWrap">
+                <SvgIcon :src="addPhotoAlternateIcon" alt="" class="dropZone__icon" />
+              </div>
              <div class="dropZone__title">이미지를 드래그해서 기본 아이템으로 추가</div>
              <div class="dropZone__desc">
                여러 파일을 한 번에 올릴 수 있고, 저장 라벨은 파일명으로 자동 생성됩니다.
                <span v-if="props.stagedRequestDraftCount"> 현재 요청에서 가져온 아이템 {{ props.stagedRequestDraftCount }}개도 함께 검토 중이에요.</span>
              </div>
              <div class="dropZone__actions">
-                <button class="btn btn--ghost btn--small" type="button" @click="props.openItemFilePicker">파일 선택</button>
-                <button class="btn btn--danger btn--small" type="button" :disabled="!props.uploadItemDrafts.length" @click="props.clearItemFiles">선택 비우기</button>
+                <button class="btn btn--ghost btn--small dropZone__button" type="button" @click.stop="props.openItemFilePicker">파일 선택</button>
              </div>
            </div>
-            <button class="btn" :disabled="!props.canAddItem" @click="props.uploadItem">
-              아이템 {{ props.uploadItemDrafts.length || 0 }}개 추가
-            </button>
          </div>
          <div class="itemPreviewCard">
            <div v-if="props.uploadItemDrafts.length" class="itemDraftList">
@@ -119,16 +141,18 @@ const props = defineProps({
                  <input v-model="draft.label" class="input input--labelEdit input--dense" maxlength="60" placeholder="아이템 이름" />
                  <div class="hint hint--tight">{{ draft.sourceName }}</div>
                  <div class="itemDraftRow__meta">
-                    <span class="pill pill--soft">{{ draft.kind === 'request' ? '요청 아이템' : '직접 추가 파일' }}</span>
+                    <span class="pill" :class="draft.kind === 'request' ? 'pill--requestItem' : 'pill--directFile'">
+                      {{ draft.kind === 'request' ? '요청 아이템' : '직접 추가 파일' }}
+                    </span>
                    <button class="btn btn--danger btn--small" type="button" @click="props.removeUploadDraft(draft)">제외</button>
                  </div>
                </div>
              </div>
            </div>
            <div v-else class="itemPreviewEmpty">등록한 기본 아이템 미리보기가 여기에 표시됩니다.</div>
-            <div class="thumbLabel thumbLabel--preview">
-              {{ props.uploadItemDrafts.length ? `추가 예정 아이템 ${props.uploadItemDrafts.length}개` : '아직 선택된 파일이 없어요.' }}
-            </div>
+            <button class="btn itemPreviewCard__submit" :disabled="!props.canAddItem" @click="props.uploadItem">
+              {{ props.uploadItemDrafts.length ? `아이템 ${props.uploadItemDrafts.length}개 추가` : '아이템 추가' }}
+            </button>
          </div>
        </div>
      </section>
@@ -143,19 +167,20 @@ const props = defineProps({
        <button class="btn btn--primary btn--small" :disabled="!props.hasGameItemOrderChanges" @click="props.saveGameItemOrder">순서 저장</button>
      </div>
      <div v-if="!props.selectedGame?.items?.length" class="hint">아직 등록된 기본 아이템이 없어요.</div>
-      <div v-else :ref="props.gameItemListRef" class="thumbGrid">
+      <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">
-          <img class="thumb thumb--game" :src="toApiUrl(item.src)" :alt="item.label" />
-          <input v-model="item.draftLabel" class="input input--labelEdit" placeholder="아이템 이름" />
+          <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">
            <button
              class="btn btn--ghost btn--small"
+              data-no-drag
              :disabled="item.isSavingLabel || !item.draftLabel?.trim() || item.draftLabel.trim() === item.label"
              @click="props.saveGameItemLabel(item)"
            >
              {{ item.isSavingLabel ? '저장중...' : '이름 저장' }}
            </button>
-            <button class="btn btn--danger btn--small" @click="props.removeGameItem(item.id)">아이템 삭제</button>
+            <button class="btn btn--danger btn--small" data-no-drag @click="props.removeGameItem(item.id)">아이템 삭제</button>
          </div>
        </div>
      </div>
--- a/frontend/src/components/admin/AdminTierlistsSection.vue
+++ b/frontend/src/components/admin/AdminTierlistsSection.vue
@@ -5,12 +5,10 @@ const props = defineProps({
  tierlistsMode: { type: String, required: true },
  templateRequests: { type: Array, required: true },
  openTemplateRequestPreview: { type: Function, required: true },
-  templateRequestTypeLabel: { type: Function, required: true },
  fmt: { type: Function, required: true },
  templateRequestTargetLabel: { type: Function, required: true },
  templateRequestStatusLabel: { type: Function, required: true },
  templateRequestSourceUrl: { type: Function, required: true },
-  templateRequestReviewHint: { type: Function, required: true },
  startTemplateRequestReview: { type: Function, required: true },
  completeTemplateRequest: { type: Function, required: true },
  adminTierLists: { type: Array, required: true },
@@ -32,7 +30,6 @@ const props = defineProps({
    <div class="sectionHeader">
      <div>
        <div class="panel__title">사용자 요청</div>
-        <div class="hint hint--tight">요청 카드는 미확인/확인함 상태로 관리하고, 실제 아이템 반영은 게임 관리 화면에서 직접 진행합니다. 처리 완료를 눌러야 카드가 목록에서 빠져요.</div>
      </div>
    </div>

@@ -67,10 +64,16 @@ const props = defineProps({
        <div class="tierAdminCard__body">
          <div class="tierAdminCard__head">
            <div>
+              <span
+                class="pill templateRequestCard__cornerBadge"
+                :class="request.type === 'create' ? 'pill--create' : 'pill--owned'"
+              >
+                {{ request.type === 'create' ? '신규 템플릿' : '보유 템플릿' }}
+              </span>
              <div class="tierAdminCard__title">{{ request.sourceTierListTitle }}</div>
              <div v-if="request.sourceDescription" class="tierAdminCard__desc">{{ request.sourceDescription }}</div>
              <div class="tierAdminCard__meta">
-                {{ props.templateRequestTypeLabel(request) }} · {{ request.requesterName }} · {{ props.fmt(request.createdAt) }}
+                {{ request.requesterName }} · {{ props.fmt(request.createdAt) }}
              </div>
              <div class="tierAdminCard__meta">{{ props.templateRequestTargetLabel(request) }}</div>
            </div>
@@ -78,7 +81,9 @@ const props = defineProps({

          <div class="tierAdminCard__stats">
            <span class="pill">추가 아이템 {{ request.items?.length || 0 }}개</span>
-            <span class="pill">{{ request.type === 'create' ? '새 템플릿' : '기존 템플릿 업데이트' }}</span>
+            <span v-if="request.type === 'create' && (request.targetGameName || request.targetGameId)" class="pill pill--soft">
+              연결됨 · {{ request.targetGameName || request.targetGameId }}
+            </span>
            <span class="pill" :class="{ 'pill--accent': request.status === 'reviewing' }">{{ props.templateRequestStatusLabel(request) }}</span>
          </div>

@@ -89,24 +94,30 @@ const props = defineProps({
            </button>
          </div>

-          <div class="templateRequestCard__links">
-            <a
-              v-if="props.templateRequestSourceUrl(request)"
-              class="btn btn--ghost btn--small"
-              :href="props.templateRequestSourceUrl(request)"
-              target="_blank"
-              rel="noreferrer"
-            >
-              요청 티어표 보기
-            </a>
-            <div class="hint hint--tight">{{ props.templateRequestReviewHint(request) }}</div>
-          </div>
-
-          <div class="templateRequestCard__actions">
-            <button class="btn btn--primary" :disabled="request.isHandling" @click="props.startTemplateRequestReview(request)">
-              {{ request.isHandling ? '이동중...' : '확인하기' }}
-            </button>
-            <button class="btn btn--ghost" :disabled="request.isHandling || request.status !== 'reviewing'" @click="props.completeTemplateRequest(request)">처리 완료</button>
+          <div class="templateRequestCard__footer">
+            <div class="templateRequestCard__footerLeft">
+              <a
+                v-if="props.templateRequestSourceUrl(request)"
+                class="btn btn--ghost btn--small"
+                :href="props.templateRequestSourceUrl(request)"
+                target="_blank"
+                rel="noreferrer"
+              >
+                요청 티어표 보기
+              </a>
+            </div>
+            <div class="templateRequestCard__actions">
+              <button class="btn btn--primary" :disabled="request.isHandling" @click="props.startTemplateRequestReview(request)">
+                {{
+                  request.isHandling
+                    ? '이동중...'
+                    : request.type === 'create' && (request.targetGameName || request.targetGameId)
+                      ? '연결된 게임 열기'
+                      : '확인하기'
+                }}
+              </button>
+              <button class="btn btn--ghost" :disabled="request.isHandling || request.status !== 'reviewing'" @click="props.completeTemplateRequest(request)">처리 완료</button>
+            </div>
          </div>
        </div>
      </article>
@@ -117,7 +128,6 @@ const props = defineProps({
    <div class="sectionHeader">
      <div>
        <div class="panel__title">전체 티어표 관리</div>
-        <div class="hint hint--tight">공개/비공개를 포함한 최근 티어표를 모두 확인하고, 추가 아이템을 기존 게임 템플릿으로 승격하거나 커스텀 티어표를 새 게임 템플릿으로 만들 수 있어요. 여기는 요청 목록과 별개로 전체 저장 티어표를 보는 영역입니다.</div>
      </div>
    </div>

--- a/frontend/src/composables/useAdminGameManager.js
+++ b/frontend/src/composables/useAdminGameManager.js
@@ -21,6 +21,7 @@ export function useAdminGameManager({
  customItemModalTargetGameId,
  newGameId,
  newGameName,
+  newGameIsPublic,
  clearPreviewUrl,
  resetFileInput,
  resetUploadState,
@@ -30,6 +31,19 @@ export function useAdminGameManager({
  success,
  error,
 }) {
+  function normalizeDraftSrc(src) {
+    if (typeof src !== 'string') return ''
+    const raw = src.trim()
+    if (!raw) return ''
+    if (raw.startsWith('/uploads/')) return raw
+    try {
+      const url = new URL(raw)
+      return url.pathname || raw
+    } catch (e) {
+      return raw
+    }
+  }
+
  function requestItemFilename(item = {}) {
    const src = typeof item.src === 'string' ? item.src : ''
    return src.split('/').pop() || item.file?.name || 'item'
@@ -50,6 +64,11 @@ export function useAdminGameManager({
    gameItemSortable.value = Sortable.create(gameItemListEl.value, {
      animation: 160,
      draggable: '[data-game-item-id]',
+      forceFallback: true,
+      fallbackOnBody: false,
+      filter: '[data-no-drag]',
+      preventOnFilter: false,
+      fallbackClass: 'thumbCard--dragging',
      ghostClass: 'ghost',
      chosenClass: 'chosen',
      onEnd: (evt) => {
@@ -68,6 +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 existingKeys = new Set(uploadItemDrafts.value.map((draft) => `${draft.kind}:${draft.requestId || ''}:${draft.itemId || draft.file?.name || ''}`))
    const nextRequestDrafts = (request.items || [])
      .filter((item) => item?.src)
@@ -80,6 +100,7 @@ export function useAdminGameManager({
        sourceName: requestItemFilename(item),
        src: item.src,
      }))
+      .filter((draft) => !existingGameSrcs.has(normalizeDraftSrc(draft.src)))
      .filter((draft) => !existingKeys.has(`${draft.kind}:${draft.requestId}:${draft.itemId}`))

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

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

    if (!selectedGameId.value) {
      selectedGame.value = null
@@ -120,7 +142,6 @@ export function useAdminGameManager({
      savedGameItemOrderIds.value = (data.items || []).map((item) => item.id)
      await syncGameItemSortable()
    } catch (e) {
-      console.error('[AdminView] loadGame failed', selectedGameId.value, e)
      selectedGame.value = null
      error.value = '게임 정보를 불러오지 못했어요.'
    } finally {
@@ -128,24 +149,50 @@ export function useAdminGameManager({
    }
  }

-  async function createGame() {
+  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()
+    const preserveUploadState = !!options.preserveUploadState
    resetMessages()
    try {
      const res = await fetch(toApiUrl('/api/admin/games'), {
        method: 'POST',
        credentials: 'include',
        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ id: newGameId.value.trim(), name: newGameName.value.trim() }),
+        body: JSON.stringify({
+          id: nextGameId,
+          name: nextGameName,
+          isPublic: !!newGameIsPublic.value,
+          thumbnailSrc: activeTemplateRequest.value?.type === 'create' ? (activeTemplateRequest.value?.thumbnailSrc || '') : '',
+        }),
      })
      if (!res.ok) throw new Error('failed')

      const data = await res.json()
+      if (activeTemplateRequest.value?.type === 'create' && activeTemplateRequest.value?.id) {
+        const linkData = await api.linkAdminTemplateRequestGame(activeTemplateRequest.value.id, {
+          gameId: data.game.id,
+        })
+        activeTemplateRequest.value = {
+          ...activeTemplateRequest.value,
+          targetGameId: linkData.request?.targetGameId || data.game.id,
+          targetGameName: linkData.request?.targetGameName || data.game.name || nextGameName,
+        }
+        const requestIndex = templateRequests.value.findIndex((entry) => entry.id === activeTemplateRequest.value.id)
+        if (requestIndex >= 0) {
+          templateRequests.value.splice(requestIndex, 1, {
+            ...templateRequests.value[requestIndex],
+            targetGameId: linkData.request?.targetGameId || data.game.id,
+            targetGameName: linkData.request?.targetGameName || data.game.name || nextGameName,
+          })
+        }
+      }
      await refreshGames()
      selectedGameId.value = data.game.id
      if (customItemModalOpen.value) customItemModalTargetGameId.value = data.game.id
      closeGameCreateModal()
-      await loadGame()
-      if (activeTemplateRequest.value?.id) {
+      await loadGame({ preserveUploadState })
+      if (!preserveUploadState && activeTemplateRequest.value?.id) {
        const sourceRequest = templateRequests.value.find((entry) => entry.id === activeTemplateRequest.value.id) || activeTemplateRequest.value
        mergeRequestItemsIntoDrafts(sourceRequest)
      }
@@ -201,12 +248,31 @@ export function useAdminGameManager({

  async function uploadItem() {
    resetMessages()
-    if (!uploadItemDrafts.value.length || !selectedGameId.value) {
+    if (!uploadItemDrafts.value.length) {
      error.value = '아이템 파일을 선택해주세요.'
      return
    }

    try {
+      if (!selectedGameId.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를 저장해주세요.'
+          return
+        }
+        await createGame({
+          gameId: draftGameId,
+          gameName: draftGameName,
+          preserveUploadState: true,
+        })
+      }
+
+      if (!selectedGameId.value) {
+        error.value = '게임을 먼저 선택해주세요.'
+        return
+      }
+
      const fileDrafts = uploadItemDrafts.value.filter((entry) => entry.kind === 'file')
      const requestDrafts = uploadItemDrafts.value.filter((entry) => entry.kind === 'request')
      let uploadCount = 0
@@ -230,15 +296,16 @@ export function useAdminGameManager({
        const requestIds = [...new Set(requestDrafts.map((entry) => entry.requestId).filter(Boolean))]
        for (const requestId of requestIds) {
          const draftsForRequest = requestDrafts.filter((entry) => entry.requestId === requestId)
-          await api.promoteAdminTemplateRequestItems(requestId, {
+          const result = await api.promoteAdminTemplateRequestItems(requestId, {
            gameId: selectedGameId.value,
            itemIds: draftsForRequest.map((entry) => entry.itemId).filter(Boolean),
+            itemSrcs: draftsForRequest.map((entry) => entry.src).filter(Boolean),
            itemLabels: draftsForRequest.reduce((acc, entry) => {
              if (entry.itemId) acc[entry.itemId] = entry.label.trim()
              return acc
            }, {}),
          })
-          uploadCount += draftsForRequest.length
+          uploadCount += Array.isArray(result?.items) ? result.items.length : 0
        }
      }

@@ -246,7 +313,21 @@ export function useAdminGameManager({
      await loadGame()
      success.value = `게임 기본 아이템 ${uploadCount}개 추가를 완료했어요.`
    } catch (e) {
-      error.value = '아이템 추가 실패(관리자 권한/파일 크기 확인)'
+      const apiError = e?.data?.error || ''
+      if (apiError === 'no_items_selected') {
+        error.value = '추가할 요청 아이템이 없어요.'
+        return
+      }
+      if (apiError === 'promote_items_failed') {
+        const detail = e?.data?.detail ? ` (${e.data.detail})` : ''
+        error.value = `요청 아이템을 게임 기본 아이템으로 옮기지 못했어요.${detail}`
+        return
+      }
+      if (apiError === 'game_not_found') {
+        error.value = '선택한 게임을 찾지 못했어요.'
+        return
+      }
+      error.value = '아이템 추가에 실패했어요.'
    }
  }

--- a/frontend/src/composables/useAdminTemplateRequests.js
+++ b/frontend/src/composables/useAdminTemplateRequests.js
@@ -18,12 +18,15 @@ export function useAdminTemplateRequests({
      id: request.id,
      type: request.type,
      status: request.status,
+      thumbnailSrc: request.thumbnailSrc || '',
      draftGameId: request.draftGameId || '',
      draftGameName: request.draftGameName || '',
+      draftGameIsPublic: !!request.draftGameIsPublic,
      sourceTierListId: request.sourceTierListId || '',
      sourceGameId: request.sourceGameId || '',
      sourceTierListTitle: request.sourceTierListTitle || '',
      targetGameId: request.targetGameId || '',
+      targetGameName: request.targetGameName || '',
      requesterName: request.requesterName || '',
    }
  }
@@ -47,19 +50,32 @@ export function useAdminTemplateRequests({
    try {
      request.isHandling = true
      const data = await api.startAdminTemplateRequestReview(request.id)
-      request.status = data.request?.status || 'reviewing'
-      updateActiveTemplateRequest(request)
+      const syncedRequest = {
+        ...request,
+        ...(data.request || {}),
+        draftGameId: request.draftGameId || '',
+        draftGameName: request.draftGameName || '',
+        draftGameIsPublic: !!request.draftGameIsPublic,
+      }
+      Object.assign(request, syncedRequest)
+      request.status = syncedRequest.status || 'reviewing'
+      updateActiveTemplateRequest(syncedRequest)
      setTab('game-admin')

      if (request.type === 'create') {
-        openGameCreateModal()
-        newGameId.value = (request.draftGameId || '').trim()
-        newGameName.value = (request.draftGameName || '').trim()
-        mergeRequestItemsIntoDrafts(request)
+        const linkedGameId = syncedRequest.targetGameId || ''
+        if (linkedGameId) {
+          await selectAdminGame(linkedGameId)
+        } else {
+          openGameCreateModal()
+          newGameId.value = (syncedRequest.draftGameId || '').trim()
+          newGameName.value = (syncedRequest.draftGameName || '').trim()
+        }
+        mergeRequestItemsIntoDrafts(syncedRequest)
      } else {
-        const nextGameId = request.targetGameId || request.sourceGameId || ''
+        const nextGameId = syncedRequest.targetGameId || syncedRequest.sourceGameId || ''
        if (nextGameId) await selectAdminGame(nextGameId)
-        mergeRequestItemsIntoDrafts(request)
+        mergeRequestItemsIntoDrafts(syncedRequest)
      }
      success.value = '요청 아이템을 게임 관리 화면으로 가져왔어요. 필요한 항목만 골라서 추가해 주세요.'
    } catch (e) {
--- a/frontend/src/lib/api.js
+++ b/frontend/src/lib/api.js
@@ -37,6 +37,8 @@ export const api = {
  updateAdminGameDisplayOrder: (payload) => request('/api/admin/games/display-order', { method: 'PATCH', body: payload }),
  updateAdminGameItemDisplayOrder: (gameId, payload) =>
    request(`/api/admin/games/${encodeURIComponent(gameId)}/items/display-order`, { method: 'PATCH', body: payload }),
+  updateAdminGame: (gameId, payload) =>
+    request(`/api/admin/games/${encodeURIComponent(gameId)}`, { method: 'PATCH', body: payload }),
  updateAdminGameItem: (gameId, itemId, payload) =>
    request(`/api/admin/games/${encodeURIComponent(gameId)}/items/${encodeURIComponent(itemId)}`, { method: 'PATCH', body: payload }),
  listAdminCustomItems: ({ q = '', page = 1, limit = 50, orphanOnly = false } = {}) =>
@@ -65,6 +67,8 @@ export const api = {
    request(`/api/admin/tierlists/${encodeURIComponent(tierListId)}/create-game-template`, { method: 'POST', body: payload }),
  startAdminTemplateRequestReview: (requestId) =>
    request(`/api/admin/template-requests/${encodeURIComponent(requestId)}/review`, { method: 'POST', body: {} }),
+  linkAdminTemplateRequestGame: (requestId, payload) =>
+    request(`/api/admin/template-requests/${encodeURIComponent(requestId)}/link-game`, { method: 'POST', body: payload }),
  promoteAdminTemplateRequestItems: (requestId, payload) =>
    request(`/api/admin/template-requests/${encodeURIComponent(requestId)}/promote-items`, { method: 'POST', body: payload }),
  completeAdminTemplateRequest: (requestId) =>
--- a/frontend/src/stores/auth.js
+++ b/frontend/src/stores/auth.js
@@ -1,6 +1,8 @@
 import { defineStore } from 'pinia'
 import { api } from '../lib/api'

+let refreshPromise = null
+
 export const useAuthStore = defineStore('auth', {
  state: () => ({
    user: null,
@@ -9,19 +11,23 @@ export const useAuthStore = defineStore('auth', {
  }),
  actions: {
    async refresh() {
-      if (this.status === 'loading') return this.user
+      if (refreshPromise) return refreshPromise
      this.status = 'loading'
-      try {
-        const data = await api.me()
-        this.user = data.user
-        return this.user
-      } catch (error) {
-        this.user = null
-        return null
-      } finally {
-        this.status = 'idle'
-        this.hydrated = true
-      }
+      refreshPromise = (async () => {
+        try {
+          const data = await api.me()
+          this.user = data.user
+          return this.user
+        } catch (error) {
+          this.user = null
+          return null
+        } finally {
+          this.status = 'idle'
+          this.hydrated = true
+          refreshPromise = null
+        }
+      })()
+      return refreshPromise
    },
    async signup(email, password) {
      const user = await api.signup({ email, password })
@@ -42,4 +48,3 @@ export const useAuthStore = defineStore('auth', {
    },
  },
 })
-
--- a/frontend/src/views/AdminView.vue
+++ b/frontend/src/views/AdminView.vue
@@ -5,6 +5,7 @@ import { api } from '../lib/api'
 import { toApiUrl } from '../lib/runtime'
 import lockResetIcon from '../assets/icons/lock_reset.svg'
 import deleteIcon from '../assets/icons/delete.svg'
+import addPhotoAlternateIcon from '../assets/icons/add_photo_alternate.svg'
 import SvgIcon from '../components/SvgIcon.vue'
 import AdminFeaturedSection from '../components/admin/AdminFeaturedSection.vue'
 import AdminGamesSection from '../components/admin/AdminGamesSection.vue'
@@ -96,6 +97,8 @@ const success = ref('')

 const newGameId = ref('')
 const newGameName = ref('')
+const newGameIsPublic = ref(false)
+const gameVisibilitySaving = ref(false)

 const uploadFiles = ref([])
 const uploadItemDrafts = ref([])
@@ -110,6 +113,7 @@ const featuredListEl = ref(null)
 const featuredSortable = ref(null)
 const gameItemListEl = ref(null)
 const gameItemSortable = ref(null)
+let gameItemSortableSyncTimer = null
 const savedGameItemOrderIds = ref([])
 const userAvatarInputs = ref({})
 const isGameLoading = ref(false)
@@ -124,14 +128,49 @@ function setItemFileInputRef(el) {
  itemFileInput.value = el
 }

+function scheduleGameItemSortableSync() {
+  if (gameItemSortableSyncTimer) {
+    clearTimeout(gameItemSortableSyncTimer)
+    gameItemSortableSyncTimer = null
+  }
+  if (!gameItemListEl.value || !selectedGame.value?.items?.length) return
+
+  gameItemSortableSyncTimer = setTimeout(() => {
+    gameItemSortableSyncTimer = null
+    syncGameItemSortable()
+  }, 0)
+}
+
 function setGameItemListRef(el) {
  gameItemListEl.value = el
+  if (!el) return
+  scheduleGameItemSortableSync()
+}
+
+function normalizeAdminSrc(src) {
+  if (typeof src !== 'string') return ''
+  const raw = src.trim()
+  if (!raw) return ''
+  if (raw.startsWith('/uploads/')) return raw
+  try {
+    const url = new URL(raw)
+    return url.pathname || raw
+  } catch (e) {
+    return raw
+  }
 }

 const hasSelectedGame = computed(() => !!selectedGame.value?.game?.id)
 const canApplyThumbnail = computed(() => !!thumbFile.value && !!selectedGameId.value)
 const canAddItem = computed(() => uploadItemDrafts.value.length > 0 && uploadItemDrafts.value.every((item) => !!item.label.trim()) && !!selectedGameId.value)
 const stagedRequestDraftCount = computed(() => uploadItemDrafts.value.filter((item) => item.kind === 'request').length)
+const appliedRequestItemCount = computed(() => {
+  if (!activeTemplateRequest.value?.id || !selectedGame.value?.items?.length) return 0
+  const sourceRequest = templateRequests.value.find((request) => request.id === activeTemplateRequest.value.id)
+  if (!sourceRequest?.items?.length) return 0
+  const gameSrcs = new Set((selectedGame.value.items || []).map((item) => normalizeAdminSrc(item?.src)).filter(Boolean))
+  return sourceRequest.items.filter((item) => gameSrcs.has(normalizeAdminSrc(item?.src))).length
+})
 const hasGameItemOrderChanges = computed(() => {
  const currentIds = (selectedGame.value?.items || []).map((item) => item.id)
  return currentIds.join('|') !== savedGameItemOrderIds.value.join('|')
@@ -316,6 +355,10 @@ onUnmounted(() => {
  if (typeof document !== 'undefined') document.body.style.overflow = previousBodyOverflow.value || ''
  clearPreviewUrl('item')
  clearPreviewUrl('thumb')
+  if (gameItemSortableSyncTimer) {
+    clearTimeout(gameItemSortableSyncTimer)
+    gameItemSortableSyncTimer = null
+  }
  destroyFeaturedSortable()
  destroyGameItemSortable()
 })
@@ -438,6 +481,14 @@ watch(
  }
 )

+watch(
+  () => [selectedGame.value?.game?.id || '', selectedGame.value?.items?.length || 0, !!gameItemListEl.value],
+  ([gameId, itemCount, hasListEl]) => {
+    if (!gameId || !itemCount || !hasListEl) return
+    scheduleGameItemSortableSync()
+  }
+)
+

 watch(
  () => isAnyModalOpen.value,
@@ -472,6 +523,36 @@ function formatBytes(value) {
  return `${current >= 10 || unitIndex === 0 ? current.toFixed(0) : current.toFixed(1)} ${units[unitIndex]}`
 }

+function formatImageJobSourceCategory(category) {
+  switch (String(category || '').trim()) {
+    case 'custom':
+      return '커스텀 아이템'
+    case 'tierlists':
+      return '티어표 썸네일'
+    case 'games':
+      return '게임/템플릿 이미지'
+    case 'avatars':
+      return '프로필 아바타'
+    default:
+      return '기타 이미지'
+  }
+}
+
+function formatImageJobStatus(status) {
+  switch (String(status || '').trim()) {
+    case 'queued':
+      return '대기'
+    case 'processing':
+      return '처리중'
+    case 'completed':
+      return '완료'
+    case 'failed':
+      return '실패'
+    default:
+      return status || '알 수 없음'
+  }
+}
+
 const imageDiagnosticsCards = computed(() => {
  const stats = imageStats.value
  if (!stats) return []
@@ -614,8 +695,15 @@ function setTierlistsMode(mode) {

 function openGameCreateModal() {
  resetMessages()
-  newGameId.value = ''
-  newGameName.value = ''
+  if (activeTemplateRequest.value?.type === 'create' && !activeTemplateRequest.value?.targetGameId) {
+    newGameId.value = activeTemplateRequest.value?.draftGameId || ''
+    newGameName.value = activeTemplateRequest.value?.draftGameName || ''
+    newGameIsPublic.value = !!activeTemplateRequest.value?.draftGameIsPublic
+  } else {
+    newGameId.value = ''
+    newGameName.value = ''
+    newGameIsPublic.value = false
+  }
  gameCreateModalOpen.value = true
 }

@@ -697,6 +785,7 @@ async function refreshTemplateRequests() {
        request.type === 'create'
          ? `${request.sourceTierListTitle || request.sourceGameName || '새 템플릿'}`
          : request.targetGameName || request.sourceGameName || '',
+      draftGameIsPublic: false,
    }))
  } catch (e) {
    error.value = '템플릿 요청 목록을 불러오지 못했어요.'
@@ -746,6 +835,7 @@ const {

 const {
  destroyGameItemSortable,
+  syncGameItemSortable,
  mergeRequestItemsIntoDrafts,
  removeUploadDraft,
  loadGame,
@@ -776,6 +866,7 @@ const {
  customItemModalTargetGameId,
  newGameId,
  newGameName,
+  newGameIsPublic,
  clearPreviewUrl,
  resetFileInput,
  resetUploadState,
@@ -980,6 +1071,53 @@ async function uploadThumbnail() {
  }
 }

+async function saveGameVisibility() {
+  if (!selectedGame.value?.game?.id) return
+  try {
+    gameVisibilitySaving.value = true
+    const data = await api.updateAdminGame(selectedGame.value.game.id, {
+      isPublic: !!selectedGame.value.game.isPublic,
+    })
+    selectedGame.value = {
+      ...selectedGame.value,
+      game: {
+        ...selectedGame.value.game,
+        ...data.game,
+      },
+    }
+    await refreshGames()
+    success.value = data.game?.isPublic ? '게임을 공개 상태로 전환했어요.' : '게임을 비공개 상태로 전환했어요.'
+    return true
+  } catch (e) {
+    error.value = '게임 공개 상태를 저장하지 못했어요.'
+    return false
+  } finally {
+    gameVisibilitySaving.value = false
+  }
+}
+
+async function toggleSelectedGameVisibility(nextValue) {
+  if (!selectedGame.value?.game?.id || gameVisibilitySaving.value) return
+  const previous = !!selectedGame.value.game.isPublic
+  selectedGame.value = {
+    ...selectedGame.value,
+    game: {
+      ...selectedGame.value.game,
+      isPublic: !!nextValue,
+    },
+  }
+  const saved = await saveGameVisibility()
+  if (!saved) {
+    selectedGame.value = {
+      ...selectedGame.value,
+      game: {
+        ...selectedGame.value.game,
+        isPublic: previous,
+      },
+    }
+  }
+}
+
 async function removeGameItem(itemId) {
  resetMessages()
  try {
@@ -1265,7 +1403,13 @@ function templateRequestTypeLabel(request) {
 }

 function templateRequestTargetLabel(request) {
-  return request.type === 'create' ? '새 게임 템플릿 생성' : request.targetGameName || request.targetGameId || request.sourceGameName
+  if (request.type === 'create') {
+    if (request.targetGameName || request.targetGameId) {
+      return `연결된 게임 · ${request.targetGameName || request.targetGameId}`
+    }
+    return '연결된 게임 없음'
+  }
+  return request.targetGameName || request.targetGameId || request.sourceGameName
 }

 const displayThumbnailUrl = computed(() => {
@@ -1334,6 +1478,7 @@ function userAvatarFallback(user) {
              :active-template-request="activeTemplateRequest"
              :template-request-source-url="templateRequestSourceUrl"
              :staged-request-draft-count="stagedRequestDraftCount"
+              :applied-request-item-count="appliedRequestItemCount"
              :open-game-create-modal="openGameCreateModal"
              :is-game-loading="isGameLoading"
              :has-selected-game="hasSelectedGame"
@@ -1374,12 +1519,10 @@ function userAvatarFallback(user) {
              :tierlists-mode="tierlistsMode"
              :template-requests="templateRequests"
              :open-template-request-preview="openTemplateRequestPreview"
-              :template-request-type-label="templateRequestTypeLabel"
              :fmt="fmt"
              :template-request-target-label="templateRequestTargetLabel"
              :template-request-status-label="templateRequestStatusLabel"
              :template-request-source-url="templateRequestSourceUrl"
-              :template-request-review-hint="templateRequestReviewHint"
              :start-template-request-review="startTemplateRequestReview"
              :complete-template-request="completeTemplateRequest"
              :admin-tier-lists="adminTierLists"
@@ -1442,6 +1585,11 @@ function userAvatarFallback(user) {
                    />
                    <span class="field__hint">영문, 숫자, 하이픈 조합 권장 · {{ newGameId.length }}/120자</span>
                  </label>
+                  <label class="toggleSwitch">
+                    <input v-model="newGameIsPublic" type="checkbox" />
+                    <span class="toggleSwitch__label">{{ newGameIsPublic ? '템플릿 공개중' : '비공개 상태' }}</span>
+                    <span class="toggleSwitch__track"><span class="toggleSwitch__thumb"></span></span>
+                  </label>
                </div>
                <div class="modalCard__actions">
                  <button class="btn btn--ghost" @click="closeGameCreateModal">취소</button>
@@ -1799,6 +1947,11 @@ function userAvatarFallback(user) {
        <div v-if="hasSelectedGame" class="adminSidebar__group">
          <div class="selectedGameSidebar__name">{{ selectedGame.game.name }}</div>
          <div class="selectedGameSidebar__id">{{ selectedGame.game.id }}</div>
+          <label class="toggleSwitch" :class="{ 'toggleSwitch--disabled': gameVisibilitySaving }">
+            <input :checked="!!selectedGame.game.isPublic" type="checkbox" @change="toggleSelectedGameVisibility($event.target.checked)" />
+            <span class="toggleSwitch__label">{{ selectedGame.game.isPublic ? '템플릿 공개중' : '비공개 상태' }}</span>
+            <span class="toggleSwitch__track"><span class="toggleSwitch__thumb"></span></span>
+          </label>
          <input ref="thumbFileInput" type="file" accept="image/*" class="srOnlyInput" @change="onThumb" />
          <button
            class="thumbDropZone"
@@ -1813,7 +1966,10 @@ function userAvatarFallback(user) {
            <img v-if="displayThumbnailUrl" class="selectedThumb selectedThumb--sidebar" :src="displayThumbnailUrl" :alt="selectedGame.game.name" />
            <div v-else class="selectedThumb selectedThumb--empty selectedThumb--sidebar">대표 썸네일</div>
            <div class="thumbDropZone__copy">
-              <div class="thumbDropZone__title">클릭 or 드래그</div>
+              <div class="thumbDropZone__iconWrap">
+                <SvgIcon :src="addPhotoAlternateIcon" alt="" class="thumbDropZone__icon" />
+              </div>
+              <div class="thumbDropZone__title">{{ displayThumbnailUrl ? '썸네일 변경' : '클릭 & 드래그' }}</div>
            </div>
          </button>
          <div class="adminSidebar__actions adminSidebar__actions--stack">
@@ -1953,10 +2109,11 @@ function userAvatarFallback(user) {
          <div v-else class="imageJobList">
            <article v-for="job in imageRecentJobs" :key="job.id" class="imageJobRow">
              <div class="imageJobRow__head">
-                <strong>{{ job.sourceCategory || 'asset' }}</strong>
-                <span class="imageJobRow__status">{{ job.status }}</span>
+                <strong>{{ formatImageJobSourceCategory(job.sourceCategory) }}</strong>
+                <span class="imageJobRow__status">{{ formatImageJobStatus(job.status) }}</span>
              </div>
              <div class="hint hint--tight">{{ formatBytes(job.originalByteSize) }} → {{ formatBytes(job.optimizedByteSize) }}</div>
+              <div v-if="job.reusedAsset" class="hint hint--tight">기존 최적화 파일 재사용</div>
              <div class="hint hint--tight">{{ fmt(job.queuedAt) }}</div>
            </article>
          </div>
@@ -2523,6 +2680,10 @@ function userAvatarFallback(user) {
 .adminUiScope .chosen {
  outline: 2px solid rgba(96, 165, 250, 0.45);
 }
+.adminUiScope .thumbCard--dragging {
+  box-shadow: 0 18px 38px rgba(15, 23, 42, 0.34);
+  opacity: 0.96;
+}
 .adminUiScope .btn:disabled {
  cursor: not-allowed;
  opacity: 0.45;
@@ -2588,17 +2749,23 @@ function userAvatarFallback(user) {
 .adminUiScope .thumbDropZone {
  position: relative;
  width: 100%;
-  display: block;
+  display: grid;
+  gap: 0;
  padding: 0;
  overflow: hidden;
-  border-radius: 18px;
-  border: 1px solid rgba(255, 255, 255, 0.12);
-  background: var(--theme-pill-bg);
+  border-radius: 22px;
+  border: 2px dashed color-mix(in srgb, var(--theme-border-strong) 82%, rgba(255, 255, 255, 0.12));
+  background:
+    linear-gradient(180deg, color-mix(in srgb, var(--theme-card-bg) 88%, white 4%), color-mix(in srgb, var(--theme-card-bg-hover) 82%, white 6%)),
+    radial-gradient(circle at top, color-mix(in srgb, var(--theme-accent) 12%, transparent), transparent 60%);
  text-align: left;
-  transition: border-color 0.16s ease, box-shadow 0.16s ease, transform 0.16s ease;
+  transition: border-color 0.16s ease, background 0.16s ease, box-shadow 0.16s ease, transform 0.16s ease;
 }
 .adminUiScope .thumbDropZone--active {
  border-color: rgba(96, 165, 250, 0.56);
+  background:
+    linear-gradient(180deg, color-mix(in srgb, var(--theme-card-bg-hover) 90%, white 6%), color-mix(in srgb, var(--theme-card-bg) 84%, white 4%)),
+    radial-gradient(circle at top, color-mix(in srgb, var(--theme-accent) 18%, transparent), transparent 60%);
  box-shadow: 0 0 0 1px rgba(96, 165, 250, 0.18);
  transform: translateY(-1px);
 }
@@ -2607,13 +2774,27 @@ function userAvatarFallback(user) {
  inset: auto 0 0 0;
  display: grid;
  place-items: center;
-  min-height: 52px;
-  padding: 12px 16px;
+  gap: 8px;
+  min-height: 80px;
+  padding: 16px 18px;
  background: linear-gradient(180deg, transparent 0%, color-mix(in srgb, var(--theme-main-bg) 82%, transparent) 46%, color-mix(in srgb, var(--theme-main-bg) 94%, transparent) 100%);
 }
+.adminUiScope .thumbDropZone__iconWrap {
+  width: 46px;
+  height: 46px;
+  display: grid;
+  place-items: center;
+  border-radius: 14px;
+  background: color-mix(in srgb, var(--theme-text) 10%, transparent);
+}
+.adminUiScope .thumbDropZone__icon {
+  width: 24px;
+  height: 24px;
+  opacity: 0.86;
+}
 .adminUiScope .thumbDropZone__title {
  font-weight: 900;
-  font-size: 13px;
+  font-size: 14px;
  letter-spacing: 0.01em;
  color: var(--theme-text);
 }
@@ -2630,10 +2811,18 @@ function userAvatarFallback(user) {
  align-items: start;
 }
 .adminUiScope .dropZone {
-  padding: 18px;
-  border-radius: 16px;
-  border: 1px dashed var(--theme-border-strong);
-  background: var(--theme-pill-bg);
+  min-height: 180px;
+  padding: 28px 22px;
+  border-radius: 22px;
+  border: 2px dashed color-mix(in srgb, var(--theme-border-strong) 82%, rgba(255, 255, 255, 0.12));
+  background:
+    linear-gradient(180deg, color-mix(in srgb, var(--theme-card-bg) 88%, white 4%), color-mix(in srgb, var(--theme-card-bg-hover) 82%, white 6%)),
+    radial-gradient(circle at top, color-mix(in srgb, var(--theme-accent) 12%, transparent), transparent 60%);
+  display: grid;
+  place-items: center;
+  align-content: center;
+  text-align: center;
+  cursor: pointer;
  transition:
    border-color 0.16s ease,
    background 0.16s ease,
@@ -2641,23 +2830,46 @@ function userAvatarFallback(user) {
 }
 .adminUiScope .dropZone--active {
  border-color: rgba(96, 165, 250, 0.56);
-  background: rgba(96, 165, 250, 0.08);
+  background:
+    linear-gradient(180deg, color-mix(in srgb, var(--theme-card-bg-hover) 90%, white 6%), color-mix(in srgb, var(--theme-card-bg) 84%, white 4%)),
+    radial-gradient(circle at top, color-mix(in srgb, var(--theme-accent) 18%, transparent), transparent 60%);
  transform: translateY(-1px);
 }
+.adminUiScope .dropZone__iconWrap {
+  width: 52px;
+  height: 52px;
+  margin: 0 auto 12px;
+  display: grid;
+  place-items: center;
+  border-radius: 16px;
+  background: color-mix(in srgb, var(--theme-text) 10%, transparent);
+}
+.adminUiScope .dropZone__icon {
+  width: 28px;
+  height: 28px;
+  opacity: 0.86;
+}
 .adminUiScope .dropZone__title {
  font-weight: 900;
+  font-size: 16px;
 }
 .adminUiScope .dropZone__desc {
  margin-top: 8px;
  font-size: 13px;
  opacity: 0.74;
  line-height: 1.5;
+  max-width: 480px;
 }
 .adminUiScope .dropZone__actions {
  margin-top: 12px;
  display: flex;
  gap: 10px;
  flex-wrap: wrap;
+  justify-content: center;
+}
+.adminUiScope .dropZone__button {
+  min-width: 124px;
+  min-height: 34px;
 }
 .adminUiScope .itemPreviewCard {
  margin-top: 12px;
@@ -2666,6 +2878,10 @@ function userAvatarFallback(user) {
  border: 1px solid rgba(255, 255, 255, 0.12);
  background: var(--theme-surface-soft);
 }
+.adminUiScope .itemPreviewCard__submit {
+  margin-top: 12px;
+  width: 100%;
+}
 .adminUiScope .itemPreviewGrid {
  display: grid;
  grid-template-columns: repeat(2, minmax(0, 1fr));
@@ -2735,6 +2951,13 @@ function userAvatarFallback(user) {
  background: var(--theme-surface-soft);
  padding: 12px;
  min-width: 0;
+  cursor: grab;
+  user-select: none;
+  -webkit-user-drag: none;
+  touch-action: none;
+}
+.adminUiScope .thumbCard:active {
+  cursor: grabbing;
 }
 .adminUiScope .thumb {
  width: 100%;
@@ -2766,6 +2989,26 @@ function userAvatarFallback(user) {
 .adminUiScope .pill--soft {
  background: rgba(255, 255, 255, 0.08);
 }
+.adminUiScope .pill--create {
+  border-color: rgba(56, 189, 248, 0.36);
+  background: rgba(56, 189, 248, 0.16);
+  color: rgba(224, 242, 254, 0.98);
+}
+.adminUiScope .pill--owned {
+  border-color: rgba(167, 139, 250, 0.34);
+  background: rgba(167, 139, 250, 0.14);
+  color: rgba(243, 232, 255, 0.98);
+}
+.adminUiScope .pill--requestItem {
+  border-color: rgba(250, 204, 21, 0.34);
+  background: rgba(250, 204, 21, 0.14);
+  color: rgba(254, 249, 195, 0.98);
+}
+.adminUiScope .pill--directFile {
+  border-color: rgba(52, 211, 153, 0.34);
+  background: rgba(52, 211, 153, 0.14);
+  color: rgba(209, 250, 229, 0.98);
+}
 .adminUiScope .requestWorkspace {
  display: grid;
  gap: 14px;
@@ -3368,9 +3611,17 @@ function userAvatarFallback(user) {
 .adminUiScope .templateRequestCard__items {
  grid-template-columns: repeat(auto-fill, minmax(100px, 1fr));
 }
-.adminUiScope .templateRequestCard__links {
-  display: grid;
+.adminUiScope .templateRequestCard__footer {
+  display: flex;
+  gap: 12px;
+  justify-content: space-between;
+  align-items: center;
+  flex-wrap: wrap;
+}
+.adminUiScope .templateRequestCard__footerLeft {
+  display: flex;
  gap: 10px;
+  align-items: center;
 }
 .adminUiScope .templateRequestCard__actions {
  display: flex;
@@ -3557,6 +3808,7 @@ function userAvatarFallback(user) {
  min-width: 0;
  display: grid;
  gap: 14px;
+  position: relative;
 }
 .adminUiScope .tierAdminCard__head {
  display: flex;
@@ -3564,9 +3816,15 @@ function userAvatarFallback(user) {
  justify-content: space-between;
  align-items: flex-start;
 }
+.adminUiScope .templateRequestCard__cornerBadge {
+  position: absolute;
+  top: 0;
+  right: 0;
+}
 .adminUiScope .tierAdminCard__title {
  font-size: 18px;
  font-weight: 900;
+  padding-right: 132px;
 }
 .adminUiScope .tierAdminCard__desc {
  margin-top: 6px;
@@ -3599,6 +3857,26 @@ function userAvatarFallback(user) {
  font-size: 12px;
  font-weight: 800;
 }
+.adminUiScope .pill--create {
+  border-color: rgba(56, 189, 248, 0.36);
+  background: rgba(56, 189, 248, 0.16);
+  color: rgba(224, 242, 254, 0.98);
+}
+.adminUiScope .pill--owned {
+  border-color: rgba(167, 139, 250, 0.34);
+  background: rgba(167, 139, 250, 0.14);
+  color: rgba(243, 232, 255, 0.98);
+}
+.adminUiScope .pill--requestItem {
+  border-color: rgba(250, 204, 21, 0.34);
+  background: rgba(250, 204, 21, 0.14);
+  color: rgba(254, 249, 195, 0.98);
+}
+.adminUiScope .pill--directFile {
+  border-color: rgba(52, 211, 153, 0.34);
+  background: rgba(52, 211, 153, 0.14);
+  color: rgba(209, 250, 229, 0.98);
+}
 .adminUiScope .pill--accent {
  border-color: rgba(251, 191, 36, 0.32);
  background: rgba(251, 191, 36, 0.12);
@@ -3739,6 +4017,59 @@ function userAvatarFallback(user) {
  align-items: center;
  opacity: 0.88;
 }
+.adminUiScope .toggleSwitch {
+  display: inline-flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  padding: 10px 12px;
+  border-radius: 14px;
+  border: 1px solid var(--theme-border);
+  background: var(--theme-pill-bg);
+  cursor: pointer;
+  user-select: none;
+}
+.adminUiScope .toggleSwitch input {
+  position: absolute;
+  opacity: 0;
+  pointer-events: none;
+}
+.adminUiScope .toggleSwitch__track {
+  position: relative;
+  width: 42px;
+  height: 24px;
+  border-radius: 999px;
+  background: var(--theme-surface-soft-3);
+  border: 1px solid var(--theme-border-strong);
+  transition: background 180ms ease, border-color 180ms ease;
+  flex: 0 0 auto;
+}
+.adminUiScope .toggleSwitch__thumb {
+  position: absolute;
+  top: 2px;
+  left: 2px;
+  width: 18px;
+  height: 18px;
+  border-radius: 999px;
+  background: var(--theme-text-strong);
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.24);
+  transition: transform 180ms ease;
+}
+.adminUiScope .toggleSwitch__label {
+  font-weight: 800;
+  color: var(--theme-text);
+}
+.adminUiScope .toggleSwitch input:checked ~ .toggleSwitch__track {
+  background: rgba(96, 165, 250, 0.34);
+  border-color: rgba(96, 165, 250, 0.42);
+}
+.adminUiScope .toggleSwitch input:checked ~ .toggleSwitch__track .toggleSwitch__thumb {
+  transform: translateX(18px);
+}
+.adminUiScope .toggleSwitch--disabled {
+  opacity: 0.55;
+  pointer-events: none;
+}
 .adminUiScope .checkRow--compact {
  margin-top: 0;
 }
@@ -3801,6 +4132,9 @@ function userAvatarFallback(user) {
  .adminUiScope .itemPreviewCard {
    max-width: none;
  }
+  .adminUiScope .itemDraftList {
+    grid-template-columns: 1fr;
+  }
  .adminUiScope .userCard__identity {
    width: 100%;
  }
--- a/frontend/src/views/TierEditorView.vue
+++ b/frontend/src/views/TierEditorView.vue
@@ -6,6 +6,7 @@ import * as htmlToImage from 'html-to-image'
 import SvgIcon from '../components/SvgIcon.vue'
 import addColumnRightIcon from '../assets/icons/add_column_right.svg'
 import addRowBelowIcon from '../assets/icons/add_row_below.svg'
+import addPhotoAlternateIcon from '../assets/icons/add_photo_alternate.svg'
 import { api } from '../lib/api'
 import { toApiUrl } from '../lib/runtime'
 import { useAuthStore } from '../stores/auth'
@@ -118,10 +119,7 @@ const copiedFromLabel = computed(() => {
  if (sourceSnapshotAuthor.value) parts.push(sourceSnapshotAuthor.value)
  return parts.join(' · ') || '복사해 온 티어표'
 })
-const customItems = computed(() =>
-  Object.values(itemsById.value)
-    .filter((item) => item?.origin === 'custom')
-)
+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
@@ -165,6 +163,29 @@ function formatExportDate(ts) {
  })
 }

+function getOrderedItemIds() {
+  const orderedIds = []
+  const seen = new Set()
+  const pushId = (itemId) => {
+    if (!itemId || seen.has(itemId) || !itemsById.value[itemId]) return
+    seen.add(itemId)
+    orderedIds.push(itemId)
+  }
+
+  pool.value.forEach(pushId)
+  groups.value.forEach((group) => {
+    ;(group.cells || []).forEach((cell) => {
+      ;(cell || []).forEach(pushId)
+    })
+  })
+  Object.keys(itemsById.value).forEach(pushId)
+  return orderedIds
+}
+
+function getOrderedItems() {
+  return getOrderedItemIds().map((itemId) => itemsById.value[itemId]).filter(Boolean)
+}
+
 function setIconSize(nextSize) {
  iconSize.value = nextSize
 }
@@ -654,7 +675,7 @@ function buildPayload(existingId) {
    sourceSnapshotTitle: sourceSnapshotTitle.value || '',
    sourceSnapshotAuthor: sourceSnapshotAuthor.value || '',
    groups: buildGroupPayload(),
-    pool: Object.values(itemsById.value),
+    pool: getOrderedItems(),
  }
 }

@@ -721,6 +742,7 @@ function closeTemplateUpdateModal() {
 }

 function openDeleteModal() {
+  if (!hasSavedTierList.value) return
  isDeleteModalOpen.value = true
 }

@@ -729,11 +751,12 @@ function closeDeleteModal() {
 }

 async function confirmDeleteTierList() {
-  if (!canEdit.value || isNewTierList.value || isDeleting.value) return
+  const currentTierListId = persistedTierListId.value || (tierListId.value && tierListId.value !== 'new' ? tierListId.value : '')
+  if (!canEdit.value || !currentTierListId || isDeleting.value) return
  error.value = ''
  try {
    isDeleting.value = true
-    await api.deleteTierList(tierListId.value)
+    await api.deleteTierList(currentTierListId)
    closeDeleteModal()
    toast.success('티어표를 삭제했어요.')
    router.push(gameId.value === 'freeform' ? '/me' : `/games/${gameId.value}`)
@@ -791,7 +814,7 @@ async function requestTemplate(type) {
      isPublic: !!isPublic.value,
      showCharacterNames: !!showCharacterNames.value,
      groups: buildGroupPayload(),
-      boardItems: Object.values(itemsById.value),
+      boardItems: getOrderedItems(),
    })

    if (type === 'create') closeTemplateRequestModal()
@@ -1184,13 +1207,16 @@ onUnmounted(() => {
            @dragleave="onDragLeave"
            @drop.prevent="onDropFiles"
          >
-            <div>
+          <div>
+            <div class="dropzone__iconWrap">
+              <SvgIcon :src="addPhotoAlternateIcon" alt="" class="dropzone__icon" />
+            </div>
              <div class="dropzone__title">커스텀 이미지 추가</div>
              <div class="dropzone__desc">이곳으로 이미지를 드래그하거나 파일 선택으로 한 번에 추가할 수 있어요.</div>
            </div>
            <div class="dropzone__actions">
              <input ref="fileEl" type="file" accept="image/*" multiple class="hidden" @change="onFileChange" />
-              <button class="btn btn--ghost dropzone__button" @click="openFile">파일 선택</button>
+              <button class="btn btn--ghost btn--small dropzone__button" @click="openFile">파일 선택</button>
            </div>
          </div>
        </div>
@@ -1298,7 +1324,7 @@ onUnmounted(() => {
          <button v-if="canEdit" class="btn btn--save editorSidebar__button" :disabled="isSaving" @click="save">{{ isSaving ? '저장중...' : '저장' }}</button>
        </div>
        <div class="editorSidebar__utilityLinks">
-          <button v-if="canEdit && !isNewTierList" class="editorSidebar__utilityLink editorSidebar__utilityLink--danger" @click="openDeleteModal">삭제하기</button>
+          <button v-if="canEdit && hasSavedTierList" class="editorSidebar__utilityLink editorSidebar__utilityLink--danger" @click="openDeleteModal">삭제하기</button>
          <button v-if="canDuplicate" class="editorSidebar__utilityLink" @click="duplicateCurrentTierList">복사해서 내 티어표로 가져오기</button>
          <button
            v-if="canRequestTemplateCreate"
@@ -2073,9 +2099,26 @@ onUnmounted(() => {
 .dropzone--board {
  margin-top: 18px;
  display: flex;
+  flex-direction: column;
  align-items: center;
-  justify-content: space-between;
+  justify-content: center;
  gap: 18px;
+  min-height: 180px;
+  padding: 28px 22px;
+  border-radius: 22px;
+  border: 2px dashed color-mix(in srgb, var(--theme-border-strong) 82%, rgba(255, 255, 255, 0.12));
+  background:
+    linear-gradient(180deg, color-mix(in srgb, var(--theme-card-bg) 88%, white 4%), color-mix(in srgb, var(--theme-card-bg-hover) 82%, white 6%)),
+    radial-gradient(circle at top, color-mix(in srgb, var(--theme-accent) 12%, transparent), transparent 60%);
+  text-align: center;
+}
+
+.dropzone--board.dropzone--active {
+  border-color: rgba(96, 165, 250, 0.56);
+  background:
+    linear-gradient(180deg, color-mix(in srgb, var(--theme-card-bg-hover) 90%, white 6%), color-mix(in srgb, var(--theme-card-bg) 84%, white 4%)),
+    radial-gradient(circle at top, color-mix(in srgb, var(--theme-accent) 18%, transparent), transparent 60%);
+  transform: translateY(-1px);
 }

 .dropzone__actions {
@@ -2083,10 +2126,39 @@ onUnmounted(() => {
  align-items: center;
  gap: 12px;
  flex: 0 0 auto;
+  justify-content: center;
 }

 .dropzone__button {
-  min-width: 148px;
+  min-width: 124px;
+  min-height: 34px;
+  font-size: 11px;
+}
+
+/* .dropzone__iconWrap {
+  width: 52px;
+  height: 52px;
+  display: grid;
+  place-items: center;
+  border-radius: 16px;
+  background: color-mix(in srgb, var(--theme-text) 10%, transparent);
+} */
+
+.dropzone__icon {
+  width: 48px;
+  height: 48px;
+  opacity: 0.86;
+}
+
+.dropzone--board .dropzone__title {
+  font-size: 18px;
+  font-weight: 800;
+}
+
+.dropzone--board .dropzone__desc {
+  max-width: 520px;
+  color: var(--theme-text-soft);
+  line-height: 1.6;
 }
 .editorSidebar__section {
  display: grid;
@@ -2285,10 +2357,11 @@ onUnmounted(() => {
 }
 .dropzone {
  margin-top: 12px;
-  padding: 14px;
+  padding: 28px 22px;
  border-radius: 16px;
-  border: 1px dashed rgba(255, 255, 255, 0.18);
-  background: var(--theme-surface-soft);
+  border: 2px dashed color-mix(in srgb, var(--theme-border-strong) 82%, rgba(255, 255, 255, 0.12));
+  background: linear-gradient(180deg, color-mix(in srgb, var(--theme-card-bg) 88%, white 4%), color-mix(in srgb, var(--theme-card-bg-hover) 82%, white 6%)),
+    radial-gradient(circle at top, color-mix(in srgb, var(--theme-accent) 12%, transparent), transparent 60%);
 }
 .dropzone--active {
  border-color: rgba(110, 231, 183, 0.6);
Author	SHA1	Message	Date
zenn	b542b963d2	릴리스: v1.3.63 이미지 최적화 작업 라벨 정리	2026-04-02 14:03:41 +09:00
zenn	b98a3d5a6d	릴리스: v1.3.62 에디터 저장 순서와 삭제 조건 정리	2026-04-02 13:57:23 +09:00
zenn	d3c5eeae6a	릴리스: v1.3.61 드롭존 아이콘과 업로드 UI 통일	2026-04-02 13:48:14 +09:00
zenn	e3559f4a84	릴리스: v1.3.60 관리자 공개 토글과 인증 새로고침 안정화	2026-04-02 13:41:14 +09:00
zenn	aa114a170e	릴리스: v1.3.59 관리자 템플릿 요청 중복 방지 및 신규 템플릿 연결 흐름 정리	2026-04-02 12:46:59 +09:00
zenn	4f300e7dbc	릴리스: v1.3.58 관리자 드래그 fallback 및 드롭존 재정비	2026-04-02 12:06:13 +09:00
zenn	717e3b97f0	릴리스: v1.3.57 관리자 기본 아이템 카드 전체 드래그 복원	2026-04-02 12:02:00 +09:00
zenn	4fc7bcb29a	릴리스: v1.3.56 관리자 배지 색상 적용 및 아이템 드래그 핸들 추가	2026-04-02 11:59:15 +09:00
zenn	0a3fce2130	릴리스: v1.3.55 관리자 요청 썸네일 승계 및 배지 색상 구분	2026-04-02 11:54:53 +09:00
zenn	1d8e8581b8	릴리스: v1.3.54 관리자 요청 카드 정보 밀도 조정	2026-04-02 11:49:13 +09:00
				`@@ -0,0 +1 @@`
				`<svg xmlns="http://www.w3.org/2000/svg" height="24px" viewBox="0 -960 960 960" width="24px" fill="ffffff"><path d="M480-480ZM200-120q-33 0-56.5-23.5T120-200v-560q0-33 23.5-56.5T200-840h320v80H200v560h560v-320h80v320q0 33-23.5 56.5T760-120H200Zm40-160h480L570-480 450-320l-90-120-120 160Zm440-320v-80h-80v-80h80v-80h80v80h80v80h-80v80h-80Z"/></svg>`