feat: 템플릿 태그와 병합 가져오기 및 에디터 제거 추가

feat: 미사용 이미지 기준과 관리자 자산 정리 통합
fix: 대체 아이템 삭제와 미사용 정리 기준 보정
2026-04-06 11:48:22 +09:00 · 2026-04-06 11:29:06 +09:00 · 2026-04-06 11:17:19 +09:00 · 2026-04-06 11:09:48 +09:00 · 2026-04-06 11:03:32 +09:00
10 changed files with 769 additions and 106 deletions
--- a/backend/src/db.js
+++ b/backend/src/db.js
@@ -32,6 +32,21 @@ function serializeJson(value) {
  return JSON.stringify(value || [])
 }

+function normalizeTags(tags) {
+  const values = Array.isArray(tags)
+    ? tags
+    : typeof tags === 'string'
+      ? tags.split(',')
+      : []
+  return Array.from(
+    new Set(
+      values
+        .map((tag) => String(tag || '').trim().replace(/^#/, '').slice(0, 40))
+        .filter(Boolean)
+    )
+  ).slice(0, 30)
+}
+
 function normalizeTopicSlug(value) {
  return String(value || '').trim().toLowerCase()
 }
@@ -100,6 +115,7 @@ function mapTopicRow(row) {
    isPublic: row.is_public == null ? true : !!row.is_public,
    displayRank: row.display_rank == null ? null : Number(row.display_rank),
    createdAt: Number(row.created_at),
+    tags: normalizeTags(parseJson(row.tags_json, [])),
  }
 }

@@ -112,6 +128,7 @@ function mapTopicItemRow(row) {
    label: row.label,
    displayOrder: row.display_order == null ? null : Number(row.display_order),
    createdAt: Number(row.created_at),
+    tags: normalizeTags(parseJson(row.tags_json, [])),
  }
 }

@@ -127,6 +144,7 @@ function mapCustomItemRow(row) {
    replacedBySrc: row.replaced_by_src || '',
    replacedByLabel: row.replaced_by_label || '',
    replacedAt: Number(row.replaced_at || 0),
+    tags: normalizeTags(parseJson(row.tags_json, [])),
  }
 }

@@ -349,6 +367,7 @@ async function ensureSchema() {
        slug VARCHAR(120) NOT NULL,
        name VARCHAR(120) NOT NULL,
        thumbnail_src VARCHAR(255) NOT NULL DEFAULT '',
+        tags_json LONGTEXT NULL,
        is_public TINYINT(1) NOT NULL DEFAULT 1,
        display_rank INT NULL DEFAULT NULL,
        created_at BIGINT NOT NULL,
@@ -362,6 +381,7 @@ async function ensureSchema() {
        topic_id VARCHAR(120) NOT NULL,
        src VARCHAR(255) NOT NULL,
        label VARCHAR(120) NOT NULL,
+        tags_json LONGTEXT NULL,
        display_order INT NULL DEFAULT NULL,
        created_at BIGINT NOT NULL,
        INDEX idx_topic_items_topic_id (topic_id),
@@ -375,6 +395,7 @@ async function ensureSchema() {
        owner_id VARCHAR(64) NOT NULL,
        src VARCHAR(255) NOT NULL,
        label VARCHAR(120) NOT NULL,
+        tags_json LONGTEXT NULL,
        replaced_by_item_id VARCHAR(64) NOT NULL DEFAULT '',
        replaced_by_src VARCHAR(255) NOT NULL DEFAULT '',
        replaced_by_label VARCHAR(120) NOT NULL DEFAULT '',
@@ -385,6 +406,9 @@ async function ensureSchema() {
      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
    `)

+    await query(`ALTER TABLE topics ADD COLUMN IF NOT EXISTS tags_json LONGTEXT NULL AFTER thumbnail_src`)
+    await query(`ALTER TABLE topic_items ADD COLUMN IF NOT EXISTS tags_json LONGTEXT NULL AFTER label`)
+    await query(`ALTER TABLE custom_items ADD COLUMN IF NOT EXISTS tags_json LONGTEXT NULL AFTER label`)
    await query(`ALTER TABLE custom_items ADD COLUMN IF NOT EXISTS replaced_by_item_id VARCHAR(64) NOT NULL DEFAULT '' AFTER label`)
    await query(`ALTER TABLE custom_items ADD COLUMN IF NOT EXISTS replaced_by_src VARCHAR(255) NOT NULL DEFAULT '' AFTER replaced_by_item_id`)
    await query(`ALTER TABLE custom_items ADD COLUMN IF NOT EXISTS replaced_by_label VARCHAR(120) NOT NULL DEFAULT '' AFTER replaced_by_src`)
@@ -517,11 +541,11 @@ async function ensureSchema() {

    await query(
      `
-        INSERT INTO topics (id, slug, name, thumbnail_src, is_public, created_at)
-        VALUES (?, ?, ?, ?, ?, ?)
-        ON DUPLICATE KEY UPDATE slug = VALUES(slug), name = VALUES(name), is_public = VALUES(is_public)
+        INSERT INTO topics (id, slug, name, thumbnail_src, tags_json, is_public, created_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+        ON DUPLICATE KEY UPDATE slug = VALUES(slug), name = VALUES(name), tags_json = VALUES(tags_json), is_public = VALUES(is_public)
      `,
-      [FREEFORM_TOPIC_ID, FREEFORM_TOPIC_ID, '직접 티어표 만들기', '', 1, now()]
+      [FREEFORM_TOPIC_ID, FREEFORM_TOPIC_ID, '직접 티어표 만들기', '', '[]', 1, now()]
    )
  })()

@@ -834,7 +858,7 @@ async function listTopics(currentUserId = '', options = {}) {
  const includePrivate = !!options.includePrivate
  const rows = await query(
    `
-      SELECT id, slug, name, thumbnail_src, is_public, display_rank, created_at
+      SELECT id, slug, name, thumbnail_src, tags_json, is_public, display_rank, created_at
      FROM topics
      WHERE id <> ?
      ${includePrivate ? '' : 'AND is_public = 1'}
@@ -859,7 +883,7 @@ async function listTopics(currentUserId = '', options = {}) {

 async function findTopicById(id) {
  const rows = await query(
-    'SELECT id, slug, name, thumbnail_src, is_public, display_rank, created_at FROM topics WHERE id = ? LIMIT 1',
+    'SELECT id, slug, name, thumbnail_src, tags_json, is_public, display_rank, created_at FROM topics WHERE id = ? LIMIT 1',
    [id]
  )
  return mapTopicRow(rows[0])
@@ -869,7 +893,7 @@ async function findTopicBySlug(slug) {
  const normalizedSlug = normalizeTopicSlug(slug)
  if (!normalizedSlug) return null
  const rows = await query(
-    'SELECT id, slug, name, thumbnail_src, is_public, display_rank, created_at FROM topics WHERE slug = ? LIMIT 1',
+    'SELECT id, slug, name, thumbnail_src, tags_json, is_public, display_rank, created_at FROM topics WHERE slug = ? LIMIT 1',
    [normalizedSlug]
  )
  return mapTopicRow(rows[0])
@@ -882,7 +906,7 @@ async function findTopicByIdentifier(topicRef) {

  const rows = await query(
    `
-      SELECT id, slug, name, thumbnail_src, is_public, display_rank, created_at
+      SELECT id, slug, name, thumbnail_src, tags_json, is_public, display_rank, created_at
      FROM topics
      WHERE id = ? OR slug = ?
      ORDER BY
@@ -897,7 +921,7 @@ async function findTopicByIdentifier(topicRef) {
 async function listTopicItems(topicId) {
  const rows = await query(
    `
-      SELECT id, topic_id, src, label, display_order, created_at
+      SELECT id, topic_id, src, label, tags_json, display_order, created_at
      FROM topic_items
      WHERE topic_id = ?
      ORDER BY
@@ -912,7 +936,7 @@ async function listTopicItems(topicId) {
 }

 async function findTopicItemById(itemId) {
-  const rows = await query('SELECT id, topic_id, src, label, display_order, created_at FROM topic_items WHERE id = ? LIMIT 1', [itemId])
+  const rows = await query('SELECT id, topic_id, src, label, tags_json, display_order, created_at FROM topic_items WHERE id = ? LIMIT 1', [itemId])
  return mapTopicItemRow(rows[0])
 }

@@ -923,14 +947,15 @@ async function getTopicDetail(topicRef) {
  return { topic, template: topic, items }
 }

-async function createTopic({ slug, name, isPublic = true }) {
+async function createTopic({ slug, name, tags = [], isPublic = true }) {
  const topicId = nanoid()
  const topicSlug = assertTopicSlug(slug)
-  await query('INSERT INTO topics (id, slug, name, thumbnail_src, is_public, display_rank, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)', [
+  await query('INSERT INTO topics (id, slug, name, thumbnail_src, tags_json, is_public, display_rank, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)', [
    topicId,
    topicSlug,
    name,
    '',
+    serializeJson(normalizeTags(tags)),
    isPublic ? 1 : 0,
    null,
    now(),
@@ -938,11 +963,12 @@ async function createTopic({ slug, name, isPublic = true }) {
  return findTopicById(topicId)
 }

-async function updateTopicMeta(topicId, { slug, name, isPublic }) {
+async function updateTopicMeta(topicId, { slug, name, tags = [], isPublic }) {
  const topicSlug = assertTopicSlug(slug)
-  await query('UPDATE topics SET slug = ?, name = ?, is_public = ? WHERE id = ?', [
+  await query('UPDATE topics SET slug = ?, name = ?, tags_json = ?, is_public = ? WHERE id = ?', [
    topicSlug,
    name,
+    serializeJson(normalizeTags(tags)),
    isPublic ? 1 : 0,
    topicId,
  ])
@@ -1152,7 +1178,22 @@ function replaceItemSrc(items, fromSrc, toSrc, toLabel = '') {
  return { changed, items: nextItems }
 }

-async function replaceUploadSourceReferences({ fromSrc, toSrc, toLabel = '' }) {
+function replaceItemById(items, itemId, nextSrc, nextLabel = '') {
+  let changed = false
+  const normalizedLabel = typeof nextLabel === 'string' ? nextLabel.trim().slice(0, 60) : ''
+  const nextItems = (items || []).map((item) => {
+    if (item?.id !== itemId) return item
+    changed = true
+    return {
+      ...item,
+      ...(typeof nextSrc === 'string' && nextSrc ? { src: nextSrc } : {}),
+      ...(normalizedLabel ? { label: normalizedLabel } : {}),
+    }
+  })
+  return { changed, items: nextItems }
+}
+
+async function replaceUploadSourceReferences({ fromSrc, toSrc, toLabel = '', updateCustomItemsBySrc = true }) {
  if (!fromSrc || !toSrc || fromSrc === toSrc) return { updatedRows: 0 }
  const normalizedLabel = typeof toLabel === 'string' ? toLabel.trim().slice(0, 60) : ''

@@ -1162,9 +1203,11 @@ async function replaceUploadSourceReferences({ fromSrc, toSrc, toLabel = '' }) {
    normalizedLabel
      ? query('UPDATE topic_items SET src = ?, label = ? WHERE src = ?', [toSrc, normalizedLabel, fromSrc])
      : query('UPDATE topic_items SET src = ? WHERE src = ?', [toSrc, fromSrc]),
-    normalizedLabel
-      ? query('UPDATE custom_items SET src = ?, label = ? WHERE src = ?', [toSrc, normalizedLabel, fromSrc])
-      : query('UPDATE custom_items SET src = ? WHERE src = ?', [toSrc, fromSrc]),
+    updateCustomItemsBySrc
+      ? normalizedLabel
+        ? query('UPDATE custom_items SET src = ?, label = ? WHERE src = ?', [toSrc, normalizedLabel, fromSrc])
+        : query('UPDATE custom_items SET src = ? WHERE src = ?', [toSrc, fromSrc])
+      : Promise.resolve({ affectedRows: 0 }),
  ])

  let updatedRows = Number(userResult.affectedRows || 0) + Number(topicResult.affectedRows || 0) + Number(topicItemResult.affectedRows || 0) + Number(customItemResult.affectedRows || 0)
@@ -1220,6 +1263,40 @@ async function replaceUploadSourceReferences({ fromSrc, toSrc, toLabel = '' }) {
  return { updatedRows }
 }

+async function updateCustomItemDisplayReferences({ itemId, src = '', label = '' }) {
+  if (!itemId) return { updatedRows: 0 }
+  const normalizedLabel = typeof label === 'string' ? label.trim().slice(0, 60) : ''
+  let updatedRows = 0
+
+  const tierListRows = await query('SELECT id, pool_json FROM tierlists')
+  for (const row of tierListRows) {
+    const replacedPool = replaceItemById(parseJson(row.pool_json, []), itemId, src, normalizedLabel)
+    if (!replacedPool.changed) continue
+    await query('UPDATE tierlists SET pool_json = ?, updated_at = ? WHERE id = ?', [
+      serializeJson(replacedPool.items),
+      now(),
+      row.id,
+    ])
+    updatedRows += 1
+  }
+
+  const requestRows = await query('SELECT id, items_json, board_items_json FROM template_requests')
+  for (const row of requestRows) {
+    const replacedItems = replaceItemById(parseJson(row.items_json, []), itemId, src, normalizedLabel)
+    const replacedBoardItems = replaceItemById(parseJson(row.board_items_json, []), itemId, src, normalizedLabel)
+    if (!replacedItems.changed && !replacedBoardItems.changed) continue
+    await query('UPDATE template_requests SET items_json = ?, board_items_json = ?, updated_at = ? WHERE id = ?', [
+      serializeJson(replacedItems.items),
+      serializeJson(replacedBoardItems.items),
+      now(),
+      row.id,
+    ])
+    updatedRows += 1
+  }
+
+  return { updatedRows }
+}
+
 async function listImageAssets() {
  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 ORDER BY created_at DESC'
@@ -1501,26 +1578,37 @@ async function clearImageOptimizationJobs({ month } = {}) {
  const result = await query('DELETE FROM image_optimization_jobs')
  return Number(result.affectedRows || 0)
 }
-async function createTopicItem({ id, topicId, src, label }) {
+async function createTopicItem({ id, topicId, src, label, tags = [] }) {
  const createdAt = now()
  const minOrderRows = await query('SELECT MIN(display_order) AS min_display_order FROM topic_items WHERE topic_id = ?', [topicId])
  const nextDisplayOrder =
    minOrderRows[0]?.min_display_order == null ? 0 : Number(minOrderRows[0].min_display_order) - 1
-  await query('INSERT INTO topic_items (id, topic_id, src, label, display_order, created_at) VALUES (?, ?, ?, ?, ?, ?)', [
+  await query('INSERT INTO topic_items (id, topic_id, src, label, tags_json, display_order, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)', [
    id,
    topicId,
    src,
    label,
+    serializeJson(normalizeTags(tags)),
    nextDisplayOrder,
    createdAt,
  ])
-  const rows = await query('SELECT id, topic_id, src, label, display_order, created_at FROM topic_items WHERE id = ? LIMIT 1', [id])
+  const rows = await query('SELECT id, topic_id, src, label, tags_json, display_order, created_at FROM topic_items WHERE id = ? LIMIT 1', [id])
  return mapTopicItemRow(rows[0])
 }

 async function updateTopicItemLabel(itemId, label) {
  await query('UPDATE topic_items SET label = ? WHERE id = ?', [label, itemId])
-  const rows = await query('SELECT id, topic_id, src, label, display_order, created_at FROM topic_items WHERE id = ? LIMIT 1', [itemId])
+  const rows = await query('SELECT id, topic_id, src, label, tags_json, display_order, created_at FROM topic_items WHERE id = ? LIMIT 1', [itemId])
+  return mapTopicItemRow(rows[0])
+}
+
+async function updateTopicItemMeta(itemId, { label, tags = [] }) {
+  await query('UPDATE topic_items SET label = ?, tags_json = ? WHERE id = ?', [
+    label,
+    serializeJson(normalizeTags(tags)),
+    itemId,
+  ])
+  const rows = await query('SELECT id, topic_id, src, label, tags_json, display_order, created_at FROM topic_items WHERE id = ? LIMIT 1', [itemId])
  return mapTopicItemRow(rows[0])
 }

@@ -1542,7 +1630,29 @@ async function updateTopicItemDisplayOrder(topicId, itemIds) {
 async function updateCustomItemLabel(itemId, label) {
  await query('UPDATE custom_items SET label = ? WHERE id = ?', [label, itemId])
  const rows = await query(`
-    SELECT c.id, c.owner_id, c.src, c.label, c.replaced_by_item_id, c.replaced_by_src, c.replaced_by_label, c.replaced_at, c.created_at, u.nickname, u.email
+    SELECT c.id, c.owner_id, c.src, c.label, c.tags_json, c.replaced_by_item_id, c.replaced_by_src, c.replaced_by_label, c.replaced_at, c.created_at, u.nickname, u.email
+    FROM custom_items c
+    INNER JOIN users u ON u.id = c.owner_id
+    WHERE c.id = ?
+    LIMIT 1
+  `, [itemId])
+  const row = rows[0]
+  if (!row) return null
+  return {
+    ...mapCustomItemRow(row),
+    ownerName: row.nickname || row.email,
+    ownerEmail: row.email,
+  }
+}
+
+async function updateCustomItemMeta(itemId, { label, tags = [] }) {
+  await query('UPDATE custom_items SET label = ?, tags_json = ? WHERE id = ?', [
+    label,
+    serializeJson(normalizeTags(tags)),
+    itemId,
+  ])
+  const rows = await query(`
+    SELECT c.id, c.owner_id, c.src, c.label, c.tags_json, c.replaced_by_item_id, c.replaced_by_src, c.replaced_by_label, c.replaced_at, c.created_at, u.nickname, u.email
    FROM custom_items c
    INNER JOIN users u ON u.id = c.owner_id
    WHERE c.id = ?
@@ -1565,6 +1675,14 @@ async function markCustomItemReplaced({ itemId, replacedByItemId = '', replacedB
  return findCustomItemById(itemId)
 }

+async function clearCustomItemReplacement(itemId) {
+  await query(
+    'UPDATE custom_items SET replaced_by_item_id = ?, replaced_by_src = ?, replaced_by_label = ?, replaced_at = 0 WHERE id = ?',
+    ['', '', '', itemId]
+  )
+  return findCustomItemById(itemId)
+}
+
 async function updateImageAssetLabel(assetId, label) {
  await query('UPDATE image_assets SET label_override = ? WHERE id = ?', [label, assetId])
  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 id = ? LIMIT 1', [assetId])
@@ -1621,16 +1739,17 @@ async function updateTopicDisplayOrder(topicIds) {
  return listTopics()
 }

-async function createCustomItem({ id, ownerId, src, label }) {
+async function createCustomItem({ id, ownerId, src, label, tags = [] }) {
  const createdAt = now()
-  await query('INSERT INTO custom_items (id, owner_id, src, label, created_at) VALUES (?, ?, ?, ?, ?)', [
+  await query('INSERT INTO custom_items (id, owner_id, src, label, tags_json, created_at) VALUES (?, ?, ?, ?, ?, ?)', [
    id,
    ownerId,
    src,
    label,
+    serializeJson(normalizeTags(tags)),
    createdAt,
  ])
-  return { id, ownerId, src, label, origin: 'custom', createdAt }
+  return { id, ownerId, src, label, tags: normalizeTags(tags), origin: 'custom', createdAt }
 }

 async function syncOwnedCustomItemLabels({ ownerId, items }) {
@@ -1654,7 +1773,7 @@ async function syncOwnedCustomItemLabels({ ownerId, items }) {
 async function findCustomItemById(id) {
  const rows = await query(
    `
-      SELECT id, owner_id, src, label, replaced_by_item_id, replaced_by_src, replaced_by_label, replaced_at, created_at
+      SELECT id, owner_id, src, label, tags_json, replaced_by_item_id, replaced_by_src, replaced_by_label, replaced_at, created_at
      FROM custom_items
      WHERE id = ?
      LIMIT 1
@@ -1728,6 +1847,7 @@ async function listCustomItems({ queryText = '', page = 1, limit = 50, filterMod
          c.owner_id,
          c.src,
          c.label,
+          c.tags_json,
          c.replaced_by_item_id,
          c.replaced_by_src,
          c.replaced_by_label,
@@ -1737,10 +1857,10 @@ async function listCustomItems({ queryText = '', page = 1, limit = 50, filterMod
          u.email
        FROM custom_items c
        INNER JOIN users u ON u.id = c.owner_id
-        ${hasQuery ? 'WHERE c.label LIKE ? OR c.src LIKE ? OR u.email LIKE ? OR u.nickname LIKE ?' : ''}
+        ${hasQuery ? 'WHERE c.label LIKE ? OR c.src LIKE ? OR c.tags_json LIKE ? OR u.email LIKE ? OR u.nickname LIKE ?' : ''}
        ORDER BY c.created_at DESC
      `,
-      hasQuery ? [search, search, search, search] : []
+      hasQuery ? [search, search, search, search, search] : []
    ),
    query(
      `
@@ -1749,14 +1869,15 @@ async function listCustomItems({ queryText = '', page = 1, limit = 50, filterMod
          gi.topic_id,
          gi.src,
          gi.label,
+          gi.tags_json,
          gi.created_at,
          tp.name AS topic_name
        FROM topic_items gi
        INNER JOIN topics tp ON tp.id = gi.topic_id
-        ${hasQuery ? 'WHERE gi.label LIKE ? OR gi.src LIKE ? OR gi.topic_id LIKE ? OR tp.name LIKE ?' : ''}
+        ${hasQuery ? 'WHERE gi.label LIKE ? OR gi.src LIKE ? OR gi.tags_json LIKE ? OR gi.topic_id LIKE ? OR tp.name LIKE ?' : ''}
        ORDER BY gi.created_at DESC
      `,
-      hasQuery ? [search, search, search, search] : []
+      hasQuery ? [search, search, search, search, search] : []
    ),
    query(
      `
@@ -1837,8 +1958,9 @@ async function listCustomItems({ queryText = '', page = 1, limit = 50, filterMod
      ownerId: '',
      src: row.src,
      label: row.label_override || (row.src.split('/').pop() || '').replace(/\.[^.]+$/, '') || '이름 없음',
+      tags: [],
      createdAt: Number(row.created_at || 0),
-      ownerName: '관리자 보관 자산',
+      ownerName: '관리자 미사용 이미지',
      ownerEmail: '',
      usageCount: 0,
      linkedTemplates: [],
@@ -1856,6 +1978,7 @@ async function listCustomItems({ queryText = '', page = 1, limit = 50, filterMod
    ownerId: '',
    src: row.src,
    label: row.label,
+    tags: normalizeTags(parseJson(row.tags_json, [])),
    createdAt: Number(row.created_at),
    ownerName: row.topic_name || row.topic_id,
    ownerEmail: '',
@@ -1917,6 +2040,7 @@ async function listCustomItems({ queryText = '', page = 1, limit = 50, filterMod
            usageCount: entry.usageCount || 0,
            linkedTemplates: entry.linkedTemplates || [],
            isAssetLibraryItem: !!entry.isAssetLibraryItem,
+            tags: entry.tags || [],
            replacedByItemId: entry.replacedByItemId || '',
            replacedBySrc: entry.replacedBySrc || '',
            replacedByLabel: entry.replacedByLabel || '',
@@ -1938,8 +2062,12 @@ async function listCustomItems({ queryText = '', page = 1, limit = 50, filterMod
          return item.assetKind === 'avatar'
        case 'library':
          return item.sourceType === 'user' || (item.sourceType === 'template' && !item.isAssetLibraryItem)
+        case 'unused':
+          return (item.sourceType === 'user' && ((item.usageCount === 0 && item.linkedTemplates.length === 0) || !!item.replacedAt)) || item.sourceType === 'asset' || !!item.isAssetLibraryItem
        case 'unused-user':
-          return item.sourceType === 'user' && item.usageCount === 0 && item.linkedTemplates.length === 0
+          return item.sourceType === 'user' && ((item.usageCount === 0 && item.linkedTemplates.length === 0) || !!item.replacedAt)
+        case 'replaced-user':
+          return item.sourceType === 'user' && !!item.replacedAt
        case 'unused-admin':
          return item.sourceType === 'asset' || !!item.isAssetLibraryItem
        default:
@@ -1963,40 +2091,59 @@ async function listCustomItems({ queryText = '', page = 1, limit = 50, filterMod
 async function findUnusedCustomItems({ queryText = '' } = {}) {
  const hasQuery = !!(queryText || '').trim()
  const search = `%${(queryText || '').trim()}%`
-  const whereClause = hasQuery ? 'WHERE c.label LIKE ? OR c.src LIKE ? OR u.email LIKE ? OR u.nickname LIKE ?' : ''
-  const params = hasQuery ? [search, search, search, search] : []

-  const rows = await query(
-    `
-      SELECT
-        c.id,
-        c.owner_id,
-        c.src,
-        c.label,
-        c.replaced_by_item_id,
-        c.replaced_by_src,
-        c.replaced_by_label,
-        c.replaced_at,
-        c.created_at,
-        u.nickname,
-        u.email
-      FROM custom_items c
-      INNER JOIN users u ON u.id = c.owner_id
-      ${whereClause}
-      ORDER BY c.created_at DESC
-    `,
-    params
-  )
+  const [rows, topicItemRows, usageMeta] = await Promise.all([
+    query(
+      `
+        SELECT
+          c.id,
+          c.owner_id,
+          c.src,
+          c.label,
+          c.tags_json,
+          c.replaced_by_item_id,
+          c.replaced_by_src,
+          c.replaced_by_label,
+          c.replaced_at,
+          c.created_at,
+          u.nickname,
+          u.email
+        FROM custom_items c
+        INNER JOIN users u ON u.id = c.owner_id
+        ${hasQuery ? 'WHERE c.label LIKE ? OR c.src LIKE ? OR c.tags_json LIKE ? OR u.email LIKE ? OR u.nickname LIKE ?' : ''}
+        ORDER BY c.created_at DESC
+      `,
+      hasQuery ? [search, search, search, search, search] : []
+    ),
+    query(
+      `
+        SELECT ti.topic_id, tp.name AS topic_name, ti.src
+        FROM topic_items ti
+        LEFT JOIN topics tp ON tp.id = ti.topic_id
+      `
+    ),
+    getCustomItemUsageMeta(),
+  ])
+
+  const templateLinkedBySrc = new Map()
+  topicItemRows.forEach((row) => {
+    if (!row?.src) return
+    if (!templateLinkedBySrc.has(row.src)) templateLinkedBySrc.set(row.src, new Map())
+    templateLinkedBySrc.get(row.src).set(row.topic_id, {
+      id: row.topic_id,
+      name: row.topic_name || row.topic_id,
+    })
+  })

-  const { usageMap } = await getCustomItemUsageMeta()
  return rows
    .map((row) => ({
      ...mapCustomItemRow(row),
      ownerName: row.nickname || row.email,
      ownerEmail: row.email,
-      usageCount: usageMap.get(row.id) || 0,
+      usageCount: usageMeta.usageMap.get(row.id) || 0,
+      linkedTemplates: Array.from((templateLinkedBySrc.get(row.src) || new Map()).values()),
    }))
-    .filter((item) => item.usageCount === 0)
+    .filter((item) => ((item.usageCount === 0 && item.linkedTemplates.length === 0) || !!item.replacedAt))
 }

 async function getFavoriteStatsForTierListIds(tierListIds, userId = '') {
@@ -2921,7 +3068,7 @@ async function findCustomItemsByIds(ids) {
  const placeholders = ids.map(() => '?').join(', ')
  const rows = await query(
    `
-      SELECT id, owner_id, src, label, replaced_by_item_id, replaced_by_src, replaced_by_label, replaced_at, created_at
+      SELECT id, owner_id, src, label, tags_json, replaced_by_item_id, replaced_by_src, replaced_by_label, replaced_at, created_at
      FROM custom_items
      WHERE id IN (${placeholders})
    `,
@@ -3073,17 +3220,21 @@ module.exports = {
  listReferencedUploadSources,
  listReferencedUploadUsage,
  replaceUploadSourceReferences,
+  updateCustomItemDisplayReferences,
  clearImageOptimizationJobs,
  getImageAssetStats,
  cleanupMissingUploadReferences,
  createTopicItem,
  updateTopicItemLabel,
+  updateTopicItemMeta,
  updateTopicItemDisplayOrder,
  countTierListsUsingTopicItem,
  deleteTopicItem,
  deleteTopic,
  updateTopicDisplayOrder,
  updateCustomItemLabel,
+  updateCustomItemMeta,
+  clearCustomItemReplacement,
  markCustomItemReplaced,
  updateImageAssetLabel,
  createCustomItem,
--- a/backend/src/routes/admin.js
+++ b/backend/src/routes/admin.js
@@ -20,9 +20,11 @@ const {
  updateTopicThumbnail,
  createTopicItem,
  updateTopicItemLabel,
+  updateTopicItemMeta,
  updateTopicItemDisplayOrder,
  countTierListsUsingTopicItem,
  updateCustomItemLabel,
+  updateCustomItemMeta,
  updateImageAssetLabel,
  deleteTopicItem,
  deleteTopic,
@@ -54,7 +56,10 @@ const {
  listRecentImageOptimizationJobs,
  clearImageOptimizationJobs,
  cleanupMissingUploadReferences,
+  listReferencedUploadSources,
  replaceUploadSourceReferences,
+  updateCustomItemDisplayReferences,
+  clearCustomItemReplacement,
 } = require('../db')
 const { requireAdmin } = require('../middleware/auth')
 const { createMemoryUpload, writeOptimizedImage, getImageOptimizationQueueState } = require('../lib/image-storage')
@@ -96,6 +101,17 @@ function buildItemLabelFromSrc(src) {
 const upload = createMemoryUpload(multer, { fileSize: 20 * 1024 * 1024, maxCount: 100 })
 const avatarUpload = createMemoryUpload(multer, { fileSize: 4 * 1024 * 1024 })

+function normalizeRouteTags(tags) {
+  const values = Array.isArray(tags) ? tags : typeof tags === 'string' ? tags.split(',') : []
+  return Array.from(
+    new Set(
+      values
+        .map((tag) => String(tag || '').trim().replace(/^#/, '').slice(0, 40))
+        .filter(Boolean)
+    )
+  ).slice(0, 30)
+}
+
 function decorateAdminUser(user, primaryAdmin) {
  if (!user) return null
  const isPrimaryAdmin = !!user.isAdmin && primaryAdmin?.id === user.id
@@ -124,6 +140,7 @@ router.post('/templates', requireAdmin, async (req, res) => {
  const schema = z.object({
    slug: z.string().trim().min(1).max(120).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
    name: z.string().min(1).max(60),
+    tags: z.array(z.string().trim().min(1).max(40)).max(30).optional().default([]),
    isPublic: z.boolean().optional().default(false),
    thumbnailSrc: z.string().max(255).optional().default(''),
  })
@@ -133,7 +150,12 @@ router.post('/templates', requireAdmin, async (req, res) => {
  if (exists) return res.status(409).json({ error: 'topic_slug_taken' })
  let template
  try {
-    template = await createTopic({ slug: parsed.data.slug, name: parsed.data.name, isPublic: parsed.data.isPublic })
+    template = await createTopic({
+      slug: parsed.data.slug,
+      name: parsed.data.name,
+      tags: normalizeRouteTags(parsed.data.tags),
+      isPublic: parsed.data.isPublic,
+    })
  } catch (error) {
    if (error?.code === 'TOPIC_SLUG_INVALID') return res.status(400).json({ error: 'topic_slug_invalid' })
    if (error?.code === 'ER_DUP_ENTRY') return res.status(409).json({ error: 'topic_slug_taken' })
@@ -151,6 +173,7 @@ router.patch('/templates/:templateId', requireAdmin, async (req, res) => {
  const schema = z.object({
    slug: z.string().trim().min(1).max(120).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).optional(),
    name: z.string().trim().min(1).max(60).optional(),
+    tags: z.array(z.string().trim().min(1).max(40)).max(30).optional(),
    isPublic: z.boolean().optional(),
  })
  const parsed = schema.safeParse(req.body)
@@ -166,6 +189,7 @@ router.patch('/templates/:templateId', requireAdmin, async (req, res) => {
        ? await updateTopicMeta(template.id, {
          slug: parsed.data.slug || template.slug,
          name: parsed.data.name || template.name,
+          tags: typeof parsed.data.tags !== 'undefined' ? normalizeRouteTags(parsed.data.tags) : template.tags || [],
          isPublic: typeof parsed.data.isPublic === 'boolean' ? parsed.data.isPublic : template.isPublic,
        })
        : await findTopicById(template.id)
@@ -306,14 +330,20 @@ router.get('/templates/:templateId/items/:itemId/usage', requireAdmin, async (re
 })

 router.patch('/templates/:templateId/items/:itemId', requireAdmin, async (req, res) => {
-  const schema = z.object({ label: z.string().trim().min(1).max(60) })
+  const schema = z.object({
+    label: z.string().trim().min(1).max(60),
+    tags: z.array(z.string().trim().min(1).max(40)).max(30).optional().default([]),
+  })
  const parsed = schema.safeParse(req.body)
  if (!parsed.success) return res.status(400).json({ error: 'bad_request' })

  const template = await findTopicById(getTemplateIdFromParams(req))
  if (!template) return res.status(404).json({ error: 'not_found' })

-  const updated = await updateTopicItemLabel(req.params.itemId, parsed.data.label)
+  const updated = await updateTopicItemMeta(req.params.itemId, {
+    label: parsed.data.label,
+    tags: normalizeRouteTags(parsed.data.tags),
+  })
  if (!updated || updated.topicId !== template.id) return res.status(404).json({ error: 'not_found' })
  res.json({ item: updated })
 })
@@ -329,6 +359,7 @@ router.delete('/templates/:templateId', requireAdmin, async (req, res) => {
 router.patch('/custom-items/:itemId/label', requireAdmin, async (req, res) => {
  const schema = z.object({
    label: z.string().trim().min(1).max(60),
+    tags: z.array(z.string().trim().min(1).max(40)).max(30).optional().default([]),
    sourceType: z.enum(['template', 'user', 'asset']).optional().default('user'),
  })
  const parsed = schema.safeParse(req.body)
@@ -342,12 +373,18 @@ router.patch('/custom-items/:itemId/label', requireAdmin, async (req, res) => {
  }

  if (parsed.data.sourceType === 'template') {
-    const updated = await updateTopicItemLabel(itemId, parsed.data.label)
+    const updated = await updateTopicItemMeta(itemId, {
+      label: parsed.data.label,
+      tags: normalizeRouteTags(parsed.data.tags),
+    })
    if (!updated) return res.status(404).json({ error: 'not_found' })
    return res.json({ item: updated })
  }

-  const updated = await updateCustomItemLabel(itemId, parsed.data.label)
+  const updated = await updateCustomItemMeta(itemId, {
+    label: parsed.data.label,
+    tags: normalizeRouteTags(parsed.data.tags),
+  })
  if (!updated) return res.status(404).json({ error: 'not_found' })
  return res.json({ item: updated })
 })
@@ -358,7 +395,7 @@ router.get('/custom-items', requireAdmin, async (req, res) => {
    page: z.coerce.number().int().min(1).optional().default(1),
    limit: z.coerce.number().int().min(1).max(200).optional().default(50),
    filter: z
-      .enum(['library', 'all', 'user', 'template', 'asset', 'thumbnail', 'avatar', 'unused-user', 'unused-admin'])
+      .enum(['library', 'all', 'user', 'template', 'asset', 'thumbnail', 'avatar', 'unused', 'unused-user', 'replaced-user', 'unused-admin'])
      .optional()
      .default('library'),
  })
@@ -544,12 +581,19 @@ async function removeCustomItemFiles(items) {
  )
 }

+async function removeUnreferencedCustomItemFiles(items) {
+  const referencedSrcs = new Set(await listReferencedUploadSources())
+  const removableItems = (items || []).filter((item) => item?.src && !referencedSrcs.has(item.src))
+  await removeCustomItemFiles(removableItems)
+}
+
 async function promoteLibraryItemToTemplateItem({ item, templateId }) {
  return createTopicItem({
    id: nanoid(),
    topicId: templateId,
    src: item.src || '',
    label: item.label,
+    tags: item.tags || [],
  })
 }

@@ -567,6 +611,7 @@ async function findLibraryItemForReplacement(itemId, sourceType = '') {
      sourceType: 'asset',
      src: asset.src || '',
      label: asset.labelOverride || buildItemLabelFromSrc(asset.src),
+      tags: [],
    }
  }

@@ -578,6 +623,7 @@ async function findLibraryItemForReplacement(itemId, sourceType = '') {
      sourceType: 'template',
      src: item.src || '',
      label: item.label || buildItemLabelFromSrc(item.src),
+      tags: item.tags || [],
    }
  }

@@ -588,6 +634,7 @@ async function findLibraryItemForReplacement(itemId, sourceType = '') {
      sourceType: 'user',
      src: customItem.src || '',
      label: customItem.label || buildItemLabelFromSrc(customItem.src),
+      tags: customItem.tags || [],
    }
  }

@@ -598,6 +645,7 @@ async function findLibraryItemForReplacement(itemId, sourceType = '') {
      sourceType: 'template',
      src: templateItem.src || '',
      label: templateItem.label || buildItemLabelFromSrc(templateItem.src),
+      tags: templateItem.tags || [],
    }
  }

@@ -774,13 +822,14 @@ router.delete('/custom-items/:itemId', requireAdmin, async (req, res) => {
    return res.json({ ok: true, sourceType: 'template' })
  }

+  const canDeleteReplacedUserItem = target.sourceType === 'user' && !!target.replacedAt
  if (!target.canDelete) return res.status(409).json({ error: 'item_locked' })
-  if (target.linkedTemplates.length > 0) return res.status(409).json({ error: 'item_linked' })
-  if (target.usageCount > 0) return res.status(409).json({ error: 'item_in_use' })
+  if (!canDeleteReplacedUserItem && target.linkedTemplates.length > 0) return res.status(409).json({ error: 'item_linked' })
+  if (!canDeleteReplacedUserItem && target.usageCount > 0) return res.status(409).json({ error: 'item_in_use' })

  const items = await findCustomItemsByIds([target.id])
  await deleteCustomItems([target.id])
-  await removeCustomItemFiles(items)
+  await removeUnreferencedCustomItemFiles(items)
  res.json({ ok: true, sourceType: 'user' })
 })

@@ -835,6 +884,12 @@ router.post('/custom-items/:itemId/replace', requireAdmin, async (req, res) => {
    fromSrc: sourceItem.src,
    toSrc: targetItem.src,
    toLabel: targetItem.label || '',
+    updateCustomItemsBySrc: false,
+  })
+  const displayResult = await updateCustomItemDisplayReferences({
+    itemId: sourceItem.id,
+    src: targetItem.src,
+    label: targetItem.label || '',
  })
  await markCustomItemReplaced({
    itemId: sourceItem.id,
@@ -845,12 +900,31 @@ router.post('/custom-items/:itemId/replace', requireAdmin, async (req, res) => {

  res.json({
    ok: true,
-    updatedRows: result.updatedRows || 0,
+    updatedRows: (result.updatedRows || 0) + (displayResult.updatedRows || 0),
    sourceItem,
    targetItem,
  })
 })

+router.post('/custom-items/:itemId/restore', requireAdmin, async (req, res) => {
+  const sourceItem = await findCustomItemById(req.params.itemId)
+  if (!sourceItem?.id) return res.status(404).json({ error: 'not_found' })
+  if (!sourceItem.replacedAt) return res.status(409).json({ error: 'not_replaced' })
+
+  const restored = await updateCustomItemDisplayReferences({
+    itemId: sourceItem.id,
+    src: sourceItem.src,
+    label: sourceItem.label || '',
+  })
+  await clearCustomItemReplacement(sourceItem.id)
+
+  res.json({
+    ok: true,
+    restoredRows: restored.updatedRows || 0,
+    item: await findCustomItemById(sourceItem.id),
+  })
+})
+
 router.post('/tierlists/:tierListId/promote-items', requireAdmin, async (req, res) => {
  const schema = z.object({
    topicId: z.string().min(1),
@@ -1105,11 +1179,27 @@ router.delete('/custom-items', requireAdmin, async (req, res) => {
  const parsed = schema.safeParse(req.query)
  if (!parsed.success) return res.status(400).json({ error: 'bad_request' })

-  const items = await findUnusedCustomItems({ queryText: parsed.data.q })
-  const ids = items.map((item) => item.id)
-  await deleteCustomItems(ids)
-  await removeCustomItemFiles(items)
-  res.json({ ok: true, deletedCount: ids.length })
+  const result = await listCustomItems({
+    queryText: parsed.data.q,
+    page: 1,
+    limit: 10000,
+    filterMode: 'unused',
+  })
+  const customItems = result.items.filter((item) => item?.sourceType === 'user')
+  const assetItems = result.items.filter((item) => item?.sourceType === 'asset' || item?.isAssetLibraryItem)
+  const customItemIds = customItems.map((item) => item.id)
+  const assetIds = assetItems
+    .map((item) => String(item.id || ''))
+    .filter((id) => id.startsWith('asset:'))
+    .map((id) => id.slice('asset:'.length))
+
+  await deleteCustomItems(customItemIds)
+  await removeUnreferencedCustomItemFiles(customItems)
+
+  const deletedAssets = await deleteImageAssets(assetIds)
+  await removeImageAssetFiles(deletedAssets)
+
+  res.json({ ok: true, deletedCount: customItemIds.length + deletedAssets.length })
 })

 router.get('/users', requireAdmin, async (req, res) => {
--- a/docs/history.md
+++ b/docs/history.md
@@ -1,5 +1,30 @@
 # 의사결정 이력

+## 2026-04-06 v1.4.86
+- 내부 운영용 분류는 공개 노출용 필드와 분리하는 편이 맞다고 보고, 태그는 템플릿과 아이템의 관리자 전용 메타로만 저장하고 검색에 활용하는 방향으로 정리했다.
+- 기존 분기 템플릿이나 요청 아이템을 다시 재조합해 새 템플릿을 만드는 흐름은 완전히 별도 마법 기능보다, 이미 있는 `초안 목록`에 다른 출처의 아이템을 합류시키고 `제외` 버튼으로 정리하는 편이 훨씬 예측 가능하다고 판단했다.
+- 사용자가 잘못 올린 이미지는 파일 업로드 자체를 되돌리는 것보다 “현재 티어표에서 이 커스텀 아이템을 제거”하는 조작이 먼저 필요하다고 보고, 저장 전 blob 이미지와 저장 후 커스텀 아이템 모두 같은 제거 UX로 다루는 쪽을 채택했다.
+
+## 2026-04-06 v1.4.85
+- 썸네일과 프로필 이미지는 이미 별도 필터로 분리돼 있고, 템플릿 아이템/사용자 아이템도 각각 구분되고 있으므로, 그 어디에도 속하지 않는 관리자 업로드 자산은 운영 의미상 `보관 자산`보다 `미사용 이미지`로 보는 편이 더 직관적이라고 정리했다.
+- 또 관리자 아이템 화면에서 삭제 버튼이 필터 조건에 따라 갑자기 비활성으로만 보이면 흐름을 이해하기 어려우므로, 평소에는 `미사용 이미지 확인`, 해당 화면 안에서만 `미사용 이미지 일괄 삭제`로 바뀌는 점진적 동작이 더 낫다고 판단했다.
+
+## 2026-04-06 v1.4.84
+- 대체된 원본 아이템은 운영상 이미 교체 완료된 이력이므로, 현재 저장본에서 같은 item id 사용량이 남아 있더라도 개별 삭제를 막아 두는 쪽보다 명시적으로 정리 가능하게 두는 편이 더 맞다고 판단했다.
+- 또 관리자 목록에서 보이는 `미사용` 기준과 실제 일괄 삭제 API 기준이 다르면 운영자가 버튼 상태를 신뢰하기 어려워지므로, 둘은 반드시 같은 조건으로 맞추기로 정리했다.
+- 마지막으로 업로드 파일은 하나의 레코드가 없어졌다고 곧바로 지우기보다, 전체 참조를 다시 확인한 뒤 정말 고아 파일일 때만 삭제하는 방식이 더 안전하다고 판단했다.
+
+## 2026-04-06 v1.4.83
+- 대체 이력이 쌓이기 시작하면 일반 사용자 업로드 목록 안에 섞여 보이는 것보다, 운영자가 후속 검수와 정리를 위해 `대체된 항목만` 따로 모아 보는 필터가 있는 편이 더 실용적이라고 판단했다.
+
+## 2026-04-06 v1.4.82
+- 원본 A를 보존하더라도 실제 저장본이 계속 A의 item id를 쓰는 구조라면, 대체/복구는 `custom_items` 레코드 자체를 바꾸는 방식보다 “그 item id가 참조되는 보드 표시 데이터(src/label)만 바꾸는 방식”이 더 자연스럽다고 판단했다.
+- 또 대체된 원본은 집계상 사용량이 남더라도 운영 의미상 이미 정리 가능한 이력이므로, `미사용 아이템 일괄 삭제`에서 제외하면 오히려 계속 쌓이게 된다. 그래서 대체 이력 아이템은 예외적으로 미사용 정리 대상으로 포함하는 쪽이 맞다고 정리했다.
+
+## 2026-04-06 v1.4.81
+- 원본 보존을 하더라도 실제 `custom_items.src`와 `label`까지 대체 대상 값으로 덮어쓰면 관리자 입장에서는 “원본을 남겼다”기보다 “같은 새 이미지가 두 번 보이는 상태”로 읽히므로, 원본 아이템 레코드는 실제 이미지/라벨을 그대로 유지하고 참조 이동 대상에서만 제외하는 편이 맞다고 정리했다.
+- 즉 대체 이력 메타(`어떤 아이템으로 대체됐는지`)와 원본 본문 데이터(`원래 A 이미지/이름`)는 분리해서 보존해야, 이후 복구나 검수 기준으로 의미가 살아난다고 판단했다.
+
 ## 2026-04-06 v1.4.80
 - 이미지 대체 직후 원본 사용자 아이템을 완전히 지워버리면 관리자 입장에서는 “왜 바꿨는지”, “나중에 정리해도 되는지”를 다시 확인할 근거가 사라지므로, 참조 이동과 원본 보존을 분리하는 편이 운영 흐름에 더 맞다고 판단했다.
 - 다만 대체 완료된 원본까지 별도 보호 대상으로 빼면 라이브러리 정리가 끝없이 쌓일 수 있으므로, 원본은 `대체됨` 상태로 계속 보이게 하되 이미 미사용인 이상 `미사용 아이템 일괄 삭제`와 개별 삭제로 언제든 정리할 수 있게 두는 쪽이 균형이 맞는다고 정리했다.
--- a/docs/update.md
+++ b/docs/update.md
@@ -1,5 +1,39 @@
 # 업데이트 로그

+## 2026-04-06 v1.4.86
+- 관리자 전용 내부 태그를 템플릿과 아이템 메타에 추가했다. 이제 템플릿 설정과 기본 아이템/관리자 아이템 모달에서 태그를 쉼표 기준으로 저장할 수 있고, 관리자 검색에서도 이름·파일명뿐 아니라 태그까지 함께 조회할 수 있다.
+- 템플릿 관리 화면에 `기존 템플릿 가져오기`를 추가했다. 현재 선택한 템플릿에 다른 템플릿들의 기본 아이템을 초안으로 모아 온 뒤, 필요 없는 항목은 `제외`하고 저장할 수 있다. 여러 분기 템플릿을 합쳐 연간 통합 템플릿을 만드는 흐름을 염두에 둔 기능이다.
+- 에디터에서 사용자가 잘못 올린 커스텀 이미지는 이제 현재 티어표 상태에서 바로 제거할 수 있다. 풀 목록과 보드 셀에 `삭제` 버튼을 추가했고, 우클릭 메뉴에서도 같은 동작을 열어 저장 전 임시 이미지와 저장 후 커스텀 아이템을 모두 현재 작업에서 빼낼 수 있게 했다.
+- 확인: `node --check backend/src/db.js`, `node --check backend/src/routes/admin.js`, `npm run build`
+
+## 2026-04-06 v1.4.85
+- 관리자 아이템 관리의 `미사용 이미지` 범위를 다시 정리해, 사용자 업로드 미사용 항목뿐 아니라 현재 어디에도 연결되지 않은 관리자 자산(`asset`)도 같은 미사용 이미지 목록에서 함께 보이도록 통합했다.
+- 그래서 이제 관리자 업로드 이미지라도 템플릿 아이템, 사용자 아이템, 썸네일, 프로필 등 어느 경로에도 연결되지 않으면 `미사용 이미지`로 보고 일괄 삭제할 수 있다.
+- 필터 UI도 함께 다듬어, 다른 필터를 보고 있을 때는 위험한 삭제 버튼 대신 `미사용 이미지 확인` 버튼을 보여주고, 그 화면에 들어왔을 때만 `미사용 이미지 일괄 삭제` 버튼이 나타나도록 바꿨다.
+- 확인: `node --check backend/src/db.js`, `node --check backend/src/routes/admin.js`, `npm run build`
+
+## 2026-04-06 v1.4.84
+- 대체된 사용자 업로드 아이템은 이미 다른 이미지로 참조가 옮겨진 상태라면, 관리자 개별 삭제에서 더 이상 `삭제 실패`로 막히지 않도록 삭제 조건을 보정했다.
+- `미사용 아이템` 필터 화면과 `미사용 아이템 일괄 삭제` API가 같은 기준으로 움직이도록 맞췄다. 이제 사용 중인 티어표가 0개이고 템플릿 연결도 없을 때만 일반 미사용으로 잡히고, 대체된 아이템은 별도 예외로 계속 정리 대상에 포함된다.
+- 커스텀 이미지 레코드를 지운 뒤 실제 업로드 파일을 정리할 때는, 다른 곳에서 같은 파일 경로를 아직 참조 중이면 파일은 남겨 두도록 안전장치를 추가했다.
+
+## 2026-04-06 v1.4.83
+- 관리자 아이템 관리 필터에 `대체된 아이템` 모드를 추가해, 이미지 대체 이력이 있는 사용자 업로드 항목만 따로 모아 볼 수 있게 했다.
+- 이 필터는 `replaced_at` 메타가 있는 사용자 아이템만 대상으로 하므로, 운영자는 대체 이력 검수와 후속 정리를 일반 사용자 업로드 목록과 분리해 확인할 수 있다.
+- 확인: `node --check backend/src/db.js`, `node --check backend/src/routes/admin.js`, `npm run build`
+
+## 2026-04-06 v1.4.82
+- 관리자 이미지 대체 구조를 다시 정리해, 대체 후에도 원본 A 아이템은 원래 썸네일/라벨 그대로 남고 `대체됨` 메타만 표시되도록 맞췄다. 더 이상 원본 카드가 F 이미지처럼 덮여 보이지 않는다.
+- 실제 대체는 이제 `A 아이템 ID`가 가리키는 저장본 표시 정보만 새 이미지/라벨로 바꾸는 방식이라, 대체된 원본 카드에서 `원래 이미지로 복구`를 눌러 A 기준으로 되돌릴 수 있다.
+- 대체된 사용자 아이템은 사용량 집계가 남아 있어도 운영상 이미 정리 가능한 상태로 간주해 `미사용 아이템 일괄 삭제`와 개별 삭제 대상에 포함되도록 조정했다.
+- 확인: `node --check backend/src/db.js`, `node --check backend/src/routes/admin.js`, `npm run build`
+
+## 2026-04-06 v1.4.81
+- 관리자 이미지 대체 시 원본 사용자 아이템 레코드의 `src / label`까지 대체 대상 이미지로 덮어써져, 카드와 상세 모달에서 원래 A 이미지 정보를 다시 볼 수 없던 문제를 바로잡았다.
+- 이제 대체 처리에서는 티어표/요청/템플릿 참조만 새 이미지로 옮기고, 원본 사용자 아이템 레코드는 원래 이미지와 이름을 그대로 유지한 채 `대체됨` 메타만 남긴다.
+- 그래서 관리자 화면에서는 원래 A 썸네일과 A 라벨을 계속 확인하면서도, 이 아이템이 어떤 대상(Y)으로 대체되었는지 함께 보고 이후 수동 정리나 복구 판단을 할 수 있다.
+- 확인: `node --check backend/src/db.js`, `node --check backend/src/routes/admin.js`, `npm run build`
+
 ## 2026-04-06 v1.4.80
 - 관리자 이미지 대체는 더 이상 원본 사용자 아이템을 즉시 삭제하지 않고, 원본 레코드와 파일을 남겨 둔 채 `어떤 아이템으로 대체됐는지` 메타만 기록하도록 바꿨다.
 - 따라서 대체 후에도 원본 이미지는 아이템 라이브러리에서 계속 확인할 수 있고, 카드와 상세 모달에서 `대체됨` 상태와 대체 대상 라벨을 함께 볼 수 있다.
--- a/frontend/src/components/admin/AdminTemplatesSection.vue
+++ b/frontend/src/components/admin/AdminTemplatesSection.vue
@@ -9,12 +9,14 @@ const props = defineProps({
  stagedRequestDraftCount: { type: Number, required: true },
  appliedRequestItemCount: { type: Number, required: true },
  openTemplateCreateModal: { type: Function, required: true },
+  openTemplateSourceImportModal: { type: Function, required: true },
  isTemplateLoading: { type: Boolean, required: true },
  hasSelectedTemplate: { type: Boolean, required: true },
  selectedTemplate: { type: Object, default: null },
  displayThumbnailUrl: { type: String, default: '' },
  templateMetaDraftName: { type: String, default: '' },
  templateMetaDraftSlug: { type: String, default: '' },
+  templateMetaDraftTags: { type: String, default: '' },
  templateMetaSaving: { type: Boolean, required: true },
  canSaveTemplateMeta: { type: Boolean, required: true },
  saveTemplateMeta: { type: Function, required: true },
@@ -52,7 +54,7 @@ const props = defineProps({
  selectedTemplateId: { type: String, default: '' },
 })

-defineEmits(['update:templateMetaDraftName', 'update:templateMetaDraftSlug'])
+defineEmits(['update:templateMetaDraftName', 'update:templateMetaDraftSlug', 'update:templateMetaDraftTags'])

 function setTemplateItemListElement(el) {
  props.templateItemListRef(el)
@@ -161,6 +163,17 @@ function setThumbFileElement(el) {
              @input="$emit('update:templateMetaDraftSlug', $event.target.value)"
            />
          </label>
+          <label class="templateMetaField">
+            <span class="templateMetaField__label">내부 태그</span>
+            <input
+              class="input input--dense"
+              type="text"
+              maxlength="240"
+              :value="props.templateMetaDraftTags"
+              placeholder="예: 2026Q1, 애니, 여캐릭"
+              @input="$emit('update:templateMetaDraftTags', $event.target.value)"
+            />
+          </label>
        </div>
        <div class="templateSettingsCard__meta">공개 URL: /topics/{{ props.selectedTemplate.template.slug || props.selectedTemplate.template.id }}</div>
        <label class="toggleSwitch" :class="{ 'toggleSwitch--disabled': props.templateVisibilitySaving }">
@@ -170,8 +183,9 @@ function setThumbFileElement(el) {
        </label>
        <div class="templateSettingsCard__actions">
          <button class="btn btn--ghost" :disabled="!props.canSaveTemplateMeta || props.templateMetaSaving" @click="props.saveTemplateMeta">
-            {{ props.templateMetaSaving ? '저장중...' : '이름/slug 저장' }}
+            {{ props.templateMetaSaving ? '저장중...' : '템플릿 메타 저장' }}
          </button>
+          <button class="btn btn--ghost" @click="props.openTemplateSourceImportModal">기존 템플릿 가져오기</button>
          <button class="btn" :disabled="!props.canApplyThumbnail" @click="props.uploadThumbnail">썸네일 적용</button>
          <button class="btn btn--danger" @click="props.removeTemplate">템플릿 삭제</button>
        </div>
@@ -218,10 +232,11 @@ function setThumbFileElement(el) {
                </div>
                <div class="itemDraftRow__body">
                  <input v-model="draft.label" class="input input--labelEdit input--dense" maxlength="60" placeholder="아이템 이름" />
+                  <input v-model="draft.tagsText" class="input input--labelEdit input--dense" maxlength="240" placeholder="내부 태그 (쉼표로 구분)" />
                  <div class="hint hint--tight">{{ draft.sourceName }}</div>
                  <div class="itemDraftRow__meta">
                    <span class="pill" :class="draft.kind === 'request' ? 'pill--requestItem' : 'pill--directFile'">
-                      {{ draft.kind === 'request' ? '요청 아이템' : '직접 추가 파일' }}
+                      {{ draft.kind === 'request' ? '요청 아이템' : draft.kind === 'library' ? '기존 템플릿' : '직접 추가 파일' }}
                    </span>
                    <button class="btn btn--danger btn--small" type="button" @click="props.removeUploadDraft(draft)">제외</button>
                  </div>
@@ -246,18 +261,19 @@ function setThumbFileElement(el) {
        <button class="btn btn--primary btn--small" :disabled="!props.hasTemplateItemOrderChanges" @click="props.saveTemplateItemOrder">순서 저장</button>
      </div>
      <div v-if="!props.selectedTemplate?.items?.length" class="hint">아직 등록된 기본 아이템이 없어요.</div>
-      <div v-else :ref="setTemplateItemListElement" class="thumbGrid">
+        <div v-else :ref="setTemplateItemListElement" class="thumbGrid">
        <div v-for="item in props.selectedTemplate.items" :key="item.id" class="thumbCard" :data-template-item-id="item.id">
          <img class="thumb thumb--template" :src="toApiUrl(item.src)" :alt="item.label" draggable="false" />
          <input v-model="item.draftLabel" class="input input--labelEdit" placeholder="아이템 이름" data-no-drag />
+          <input v-model="item.draftTags" class="input input--labelEdit input--dense" 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"
+              :disabled="item.isSavingLabel || !item.draftLabel?.trim() || (item.draftLabel.trim() === item.label && (item.draftTags || '') === ((item.tags || []).join(', ')))"
              @click="props.saveTemplateItemLabel(item)"
            >
-              {{ item.isSavingLabel ? '저장중...' : '이름 저장' }}
+              {{ item.isSavingLabel ? '저장중...' : '메타 저장' }}
            </button>
            <button class="btn btn--danger btn--small" data-no-drag @click="props.removeTemplateItem(item.id)">아이템 삭제</button>
          </div>
--- a/frontend/src/composables/useAdminCustomItems.js
+++ b/frontend/src/composables/useAdminCustomItems.js
@@ -14,6 +14,7 @@ export function useAdminCustomItems({
  customItemModalHistoryActive,
  modalTargetCustomItem,
  customItemModalDraftLabel,
+  customItemModalDraftTags,
  customItemModalLabelSaving,
  customItemModalTargetTemplateId,
  customItemReplacementQuery,
@@ -88,6 +89,7 @@ export function useAdminCustomItems({
  function openCustomItemModal(item) {
    modalTargetCustomItem.value = item || null
    customItemModalDraftLabel.value = item?.label || ''
+    customItemModalDraftTags.value = Array.isArray(item?.tags) ? item.tags.join(', ') : ''
    customItemModalTargetTemplateId.value = ''
    customItemReplacementQuery.value = ''
    customItemReplacementItems.value = []
@@ -102,6 +104,7 @@ export function useAdminCustomItems({
    customItemDeleteModalOpen.value = false
    modalTargetCustomItem.value = null
    customItemModalDraftLabel.value = ''
+    customItemModalDraftTags.value = ''
    customItemModalLabelSaving.value = false
    customItemModalTargetTemplateId.value = ''
    customItemReplacementQuery.value = ''
@@ -123,7 +126,7 @@ export function useAdminCustomItems({

  function openCustomItemDeleteModal(item) {
    if (!item) return
-    if (item.sourceType === 'user' && (item.usageCount > 0 || item.linkedTemplates.length > 0)) {
+    if (item.sourceType === 'user' && !item.replacedAt && (item.usageCount > 0 || item.linkedTemplates.length > 0)) {
      error.value = '사용 중이거나 템플릿에 연결된 사용자 업로드 이미지는 먼저 참조를 정리해야 삭제할 수 있어요.'
      return
    }
@@ -147,7 +150,7 @@ export function useAdminCustomItems({
  async function removeCustomItem(item = modalTargetCustomItem.value) {
    resetMessages()
    if (!item) return
-    if (item.sourceType === 'user' && (item.usageCount > 0 || item.linkedTemplates.length > 0)) {
+    if (item.sourceType === 'user' && !item.replacedAt && (item.usageCount > 0 || item.linkedTemplates.length > 0)) {
      error.value = '사용 중이거나 템플릿에 연결된 사용자 업로드 이미지는 먼저 참조를 정리해야 삭제할 수 있어요.'
      return
    }
@@ -175,32 +178,57 @@ export function useAdminCustomItems({

  async function removeUnusedCustomItems() {
    resetMessages()
-    const ok = window.confirm('현재 검색 조건에 맞는 미사용 커스텀 이미지를 모두 삭제할까요?')
+    const ok = window.confirm('현재 검색 조건에 맞는 미사용 이미지를 모두 삭제할까요?')
    if (!ok) return

    try {
      const data = await api.deleteAdminUnusedCustomItems({ q: customItemQuery.value })
      await refreshCustomItems()
-      success.value = `${data.deletedCount || 0}개의 미사용 사용자 업로드 이미지를 삭제했어요.`
+      success.value = `${data.deletedCount || 0}개의 미사용 이미지를 삭제했어요.`
    } catch (e) {
-      error.value = '미사용 커스텀 이미지 일괄 삭제에 실패했어요.'
+      error.value = '미사용 이미지 일괄 삭제에 실패했어요.'
    }
  }

+  function showUnusedCustomItems() {
+    if (customItemFilter.value === 'unused') return
+    resetMessages()
+    customItemFilter.value = 'unused'
+    customItemPage.value = 1
+    refreshCustomItems()
+  }
+
  async function saveCustomItemModalLabel() {
    const item = modalTargetCustomItem.value
    const nextLabel = customItemModalDraftLabel.value.trim().slice(0, 60)
-    if (!item || !nextLabel || nextLabel === item.label || customItemModalLabelSaving.value) return
+    const nextTags = Array.from(
+      new Set(
+        String(customItemModalDraftTags.value || '')
+          .split(',')
+          .map((tag) => tag.trim().replace(/^#/, '').slice(0, 40))
+          .filter(Boolean)
+      )
+    ).slice(0, 30)
+    if (
+      !item ||
+      !nextLabel ||
+      (nextLabel === item.label && JSON.stringify(nextTags) === JSON.stringify(Array.isArray(item.tags) ? item.tags : [])) ||
+      customItemModalLabelSaving.value
+    ) {
+      return
+    }

    try {
      customItemModalLabelSaving.value = true
-      const data = await api.updateAdminCustomItemLabel(item.id, { label: nextLabel, sourceType: item.sourceType })
+      const data = await api.updateAdminCustomItemLabel(item.id, { label: nextLabel, tags: nextTags, sourceType: item.sourceType })
      item.label = data.item?.label || nextLabel
+      item.tags = Array.isArray(data.item?.tags) ? data.item.tags : nextTags
      customItemModalDraftLabel.value = item.label
-      customItems.value = customItems.value.map((entry) => (entry.id === item.id ? { ...entry, label: item.label } : entry))
-      toast.success('아이템 이름을 변경했어요.')
+      customItemModalDraftTags.value = item.tags.join(', ')
+      customItems.value = customItems.value.map((entry) => (entry.id === item.id ? { ...entry, label: item.label, tags: item.tags } : entry))
+      toast.success('아이템 메타를 변경했어요.')
    } catch (e) {
-      error.value = '아이템 이름 변경에 실패했어요.'
+      error.value = '아이템 메타 변경에 실패했어요.'
    } finally {
      customItemModalLabelSaving.value = false
    }
@@ -257,6 +285,27 @@ export function useAdminCustomItems({
    }
  }

+  async function restoreCustomItem(item = modalTargetCustomItem.value) {
+    resetMessages()
+    if (!item?.id || !item.replacedAt) {
+      error.value = '복구할 대체 이력이 없어요.'
+      return
+    }
+
+    try {
+      customItemReplacementBusy.value = true
+      await api.restoreAdminCustomItem(item.id)
+      if (selectedTemplateId.value) await loadTemplate()
+      await refreshCustomItems()
+      closeCustomItemModal()
+      success.value = `"${item.label}" 아이템을 원래 이미지로 복구했어요.`
+    } catch (e) {
+      error.value = '원래 이미지로 복구하지 못했어요.'
+    } finally {
+      customItemReplacementBusy.value = false
+    }
+  }
+
  return {
    submitCustomItemSearch,
    changeCustomItemFilter,
@@ -270,9 +319,11 @@ export function useAdminCustomItems({
    jumpToTemplateAdmin,
    removeCustomItem,
    removeUnusedCustomItems,
+    showUnusedCustomItems,
    saveCustomItemModalLabel,
    promoteCustomItem,
    refreshReplacementCandidates,
    replaceCustomItem,
+    restoreCustomItem,
  }
 }
--- a/frontend/src/composables/useAdminTemplateManager.js
+++ b/frontend/src/composables/useAdminTemplateManager.js
@@ -31,6 +31,17 @@ export function useAdminTemplateManager({
  success,
  error,
 }) {
+  function parseTagsText(value) {
+    return Array.from(
+      new Set(
+        String(value || '')
+          .split(',')
+          .map((tag) => tag.trim().replace(/^#/, '').slice(0, 40))
+          .filter(Boolean)
+      )
+    ).slice(0, 30)
+  }
+
  function normalizeDraftSrc(src) {
    if (typeof src !== 'string') return ''
    const raw = src.trim()
@@ -108,6 +119,32 @@ export function useAdminTemplateManager({
    }
  }

+  function mergeLibraryItemsIntoDrafts(items, sourceLabel = '') {
+    const existingTemplateSrcs = new Set((selectedTemplate.value?.items || []).map((item) => normalizeDraftSrc(item?.src)).filter(Boolean))
+    const existingDraftSrcs = new Set(uploadItemDrafts.value.map((draft) => normalizeDraftSrc(draft?.src)).filter(Boolean))
+    const existingKeys = new Set(uploadItemDrafts.value.map((draft) => `${draft.kind}:${draft.itemSourceType || ''}:${draft.itemId || draft.file?.name || ''}`))
+    const nextDrafts = (items || [])
+      .filter((item) => item?.id && item?.src)
+      .map((item) => ({
+        kind: 'library',
+        itemId: item.id,
+        itemSourceType: item.sourceType || 'template',
+        previewUrl: toApiUrl(item.src),
+        label: item.label || '',
+        tagsText: Array.isArray(item.tags) ? item.tags.join(', ') : '',
+        sourceName: sourceLabel ? `${sourceLabel} · ${item.label || item.id}` : (item.label || item.id),
+        src: item.src,
+      }))
+      .filter((draft) => !existingTemplateSrcs.has(normalizeDraftSrc(draft.src)))
+      .filter((draft) => !existingDraftSrcs.has(normalizeDraftSrc(draft.src)))
+      .filter((draft) => !existingKeys.has(`${draft.kind}:${draft.itemSourceType}:${draft.itemId}`))
+
+    if (nextDrafts.length) {
+      uploadItemDrafts.value = [...uploadItemDrafts.value, ...nextDrafts]
+    }
+    return nextDrafts.length
+  }
+
  function removeUploadDraft(targetDraft) {
    const targetKey = `${targetDraft.kind}:${targetDraft.requestId || ''}:${targetDraft.itemId || targetDraft.file?.name || ''}:${targetDraft.previewUrl || ''}`
    uploadItemDrafts.value = uploadItemDrafts.value.filter((draft) => {
@@ -139,6 +176,7 @@ export function useAdminTemplateManager({
        items: (data.items || []).map((item) => ({
          ...item,
          draftLabel: item.label,
+          draftTags: Array.isArray(item.tags) ? item.tags.join(', ') : '',
        })),
      }
      savedTemplateItemOrderIds.value = (data.items || []).map((item) => item.id)
@@ -293,6 +331,7 @@ export function useAdminTemplateManager({

      const fileDrafts = uploadItemDrafts.value.filter((entry) => entry.kind === 'file')
      const requestDrafts = uploadItemDrafts.value.filter((entry) => entry.kind === 'request')
+      const libraryDrafts = uploadItemDrafts.value.filter((entry) => entry.kind === 'library')
      const totalUploadBytes = fileDrafts.reduce((sum, entry) => sum + Number(entry.file?.size || 0), 0)
      let uploadCount = 0

@@ -352,6 +391,28 @@ export function useAdminTemplateManager({
        }
      }

+      if (libraryDrafts.length) {
+        for (const draft of libraryDrafts) {
+          const promoted = await api.promoteAdminTemplateItem(draft.itemId, {
+            topicId: selectedTemplateId.value,
+          })
+          const createdItem = promoted?.item || null
+          if (createdItem?.id) {
+            const nextTags = parseTagsText(draft.tagsText)
+            const needsMetaUpdate =
+              (draft.label || '').trim() !== (createdItem.label || '').trim() ||
+              JSON.stringify(nextTags) !== JSON.stringify(Array.isArray(createdItem.tags) ? createdItem.tags : [])
+            if (needsMetaUpdate) {
+              await api.updateAdminTemplateItem(selectedTemplateId.value, createdItem.id, {
+                label: (draft.label || createdItem.label || '').trim(),
+                tags: nextTags,
+              })
+            }
+            uploadCount += 1
+          }
+        }
+      }
+
      resetUploadState()
      await loadTemplate()
      success.value = `템플릿 기본 아이템 ${uploadCount}개 추가를 완료했어요.`
@@ -397,6 +458,7 @@ export function useAdminTemplateManager({
        items: (data.items || []).map((item) => ({
          ...item,
          draftLabel: item.label,
+          draftTags: Array.isArray(item.tags) ? item.tags.join(', ') : '',
        })),
      }
      savedTemplateItemOrderIds.value = (data.items || []).map((item) => item.id)
@@ -412,6 +474,7 @@ export function useAdminTemplateManager({
    destroyTemplateItemSortable,
    syncTemplateItemSortable,
    mergeRequestItemsIntoDrafts,
+    mergeLibraryItemsIntoDrafts,
    removeUploadDraft,
    loadTemplate,
    createTemplate,
--- a/frontend/src/lib/api.js
+++ b/frontend/src/lib/api.js
@@ -106,6 +106,8 @@ export const api = {
    request(`/api/admin/custom-items/${encodeURIComponent(itemId)}/promote`, { method: 'POST', body: payload }),
  replaceAdminCustomItem: (itemId, payload) =>
    request(`/api/admin/custom-items/${encodeURIComponent(itemId)}/replace`, { method: 'POST', body: payload }),
+  restoreAdminCustomItem: (itemId) =>
+    request(`/api/admin/custom-items/${encodeURIComponent(itemId)}/restore`, { method: 'POST', body: {} }),
  updateAdminCustomItemLabel: (itemId, payload) =>
    request(`/api/admin/custom-items/${encodeURIComponent(itemId)}/label`, { method: 'PATCH', body: payload }),
  promoteAdminTierListItems: (tierListId, payload) =>
--- a/frontend/src/views/AdminView.vue
+++ b/frontend/src/views/AdminView.vue
@@ -70,6 +70,9 @@ const importModalItems = ref([])
 const importModalTargetTemplateId = ref('')
 const importModalNewTemplateId = ref('')
 const importModalNewTemplateName = ref('')
+const templateSourceImportModalOpen = ref(false)
+const templateSourceImportQuery = ref('')
+const templateSourceImportSelectedIds = ref([])
 const previewModalOpen = ref(false)
 const previewTierList = ref(null)
 const adminTierListManageModalOpen = ref(false)
@@ -89,6 +92,7 @@ const modalUserDraftNickname = ref('')
 const modalUserDraftIsAdmin = ref(false)
 const modalTargetCustomItem = ref(null)
 const customItemModalDraftLabel = ref('')
+const customItemModalDraftTags = ref('')
 const customItemModalLabelSaving = ref(false)
 const modalTargetAdminTierList = ref(null)
 const adminTierListDraftTitle = ref('')
@@ -117,6 +121,7 @@ const newTemplateName = ref('')
 const newTemplateIsPublic = ref(false)
 const templateMetaDraftName = ref('')
 const templateMetaDraftSlug = ref('')
+const templateMetaDraftTags = ref('')
 const templateMetaSaving = ref(false)
 const templateVisibilitySaving = ref(false)

@@ -184,16 +189,30 @@ function normalizeAdminSrc(src) {
  }
 }

+function parseAdminTagsText(value) {
+  return Array.from(
+    new Set(
+      String(value || '')
+        .split(',')
+        .map((tag) => tag.trim().replace(/^#/, '').slice(0, 40))
+        .filter(Boolean)
+    )
+  ).slice(0, 30)
+}
+
 const hasSelectedTemplate = computed(() => !!selectedTemplate.value?.template?.id)
 const canSaveTemplateMeta = computed(() => {
  const template = selectedTemplate.value?.template
  if (!template?.id) return false
  const nextName = templateMetaDraftName.value.trim()
  const nextSlug = templateMetaDraftSlug.value.trim()
+  const nextTags = parseAdminTagsText(templateMetaDraftTags.value)
  return (
    !!nextName &&
    !!nextSlug &&
-    (nextName !== (template.name || '') || nextSlug !== (template.slug || template.id || ''))
+    (nextName !== (template.name || '') ||
+      nextSlug !== (template.slug || template.id || '') ||
+      JSON.stringify(nextTags) !== JSON.stringify(Array.isArray(template.tags) ? template.tags : []))
  )
 })
 const canApplyThumbnail = computed(() => !!thumbFile.value && !!selectedTemplateId.value)
@@ -222,7 +241,7 @@ const filteredTemplatePickerTemplates = computed(() => {
  const query = templatePickerQuery.value.trim().toLowerCase()
  const list = templates.value.filter((template) => {
    if (!query) return true
-    const haystack = `${template.name || ''} ${template.slug || ''} ${template.id || ''}`.toLowerCase()
+    const haystack = `${template.name || ''} ${template.slug || ''} ${template.id || ''} ${(template.tags || []).join(' ')}`.toLowerCase()
    return haystack.includes(query)
  })

@@ -236,6 +255,17 @@ const customItemReplacementTarget = computed(
  () => customItemReplacementItems.value.find((item) => item.id === customItemReplacementTargetId.value) || null
 )
 const importModalItemCount = computed(() => importModalItems.value.length)
+const filteredTemplateSourceImportTemplates = computed(() => {
+  const query = templateSourceImportQuery.value.trim().toLowerCase()
+  return templates.value
+    .filter((template) => template.id !== selectedTemplateId.value)
+    .filter((template) => {
+      if (!query) return true
+      const haystack = `${template.name || ''} ${template.slug || ''} ${template.id || ''} ${(template.tags || []).join(' ')}`.toLowerCase()
+      return haystack.includes(query)
+    })
+    .sort((a, b) => Number(b.createdAt || 0) - Number(a.createdAt || 0))
+})
 const activeTabTitle = computed(() => {
  if (activeTab.value === 'featured') return '목록 관리'
  if (activeTab.value === 'template-admin') return '템플릿 관리'
@@ -486,6 +516,7 @@ watch(
  async (templateId) => {
    templateMetaDraftName.value = selectedTemplate.value?.template?.name || ''
    templateMetaDraftSlug.value = selectedTemplate.value?.template?.slug || selectedTemplate.value?.template?.id || ''
+    templateMetaDraftTags.value = Array.isArray(selectedTemplate.value?.template?.tags) ? selectedTemplate.value.template.tags.join(', ') : ''
    await refreshSelectedTemplateTierListStats(templateId)
  },
  { immediate: true }
@@ -657,6 +688,16 @@ const visibleLinkedTemplates = computed(() =>
 const linkedCustomItemTemplateIds = computed(() => new Set(visibleLinkedTemplates.value.map((template) => template.id).filter(Boolean)))
 const canReplaceModalTarget = computed(() => modalTargetCustomItem.value?.sourceType === 'user')
 const replacementCandidateCount = computed(() => customItemReplacementItems.value.length)
+const hasDeletableUnusedItems = computed(() =>
+  customItems.value.some(
+    (item) =>
+      (item?.sourceType === 'user' &&
+        (!!item.replacedAt ||
+          (Number(item.usageCount || 0) === 0 && !(Array.isArray(item.linkedTemplates) && item.linkedTemplates.length > 0)))) ||
+      item?.sourceType === 'asset' ||
+      !!item?.isAssetLibraryItem
+  )
+)

 const imageStatsPeriodLabel = computed(() => (imageStatsMonth.value ? `${imageStatsMonth.value} 기준` : '전체 기간'))
 const imageStatsYearOptions = computed(() => {
@@ -976,6 +1017,7 @@ const {
  destroyTemplateItemSortable,
  syncTemplateItemSortable,
  mergeRequestItemsIntoDrafts,
+  mergeLibraryItemsIntoDrafts,
  removeUploadDraft,
  loadTemplate,
  createTemplate,
@@ -1049,10 +1091,12 @@ const {
  jumpToTemplateAdmin,
  removeCustomItem,
  removeUnusedCustomItems,
+  showUnusedCustomItems,
  saveCustomItemModalLabel,
  promoteCustomItem,
  refreshReplacementCandidates,
  replaceCustomItem,
+  restoreCustomItem,
 } = useAdminCustomItems({
  api,
  toast,
@@ -1067,6 +1111,7 @@ const {
  customItemModalHistoryActive,
  modalTargetCustomItem,
  customItemModalDraftLabel,
+  customItemModalDraftTags,
  customItemModalLabelSaving,
  customItemModalTargetTemplateId,
  customItemReplacementQuery,
@@ -1225,6 +1270,7 @@ async function saveTemplateVisibility() {
    templateVisibilitySaving.value = true
    const data = await api.updateAdminTemplate(selectedTemplate.value.template.id, {
      isPublic: !!selectedTemplate.value.template.isPublic,
+      tags: Array.isArray(selectedTemplate.value.template.tags) ? selectedTemplate.value.template.tags : [],
    })
    const nextTemplate = data.template || {}
    selectedTemplate.value = {
@@ -1253,6 +1299,7 @@ async function saveTemplateMeta() {
    const data = await api.updateAdminTemplate(selectedTemplate.value.template.id, {
      name: templateMetaDraftName.value.trim(),
      slug: templateMetaDraftSlug.value.trim().toLowerCase(),
+      tags: parseAdminTagsText(templateMetaDraftTags.value),
      isPublic: !!selectedTemplate.value.template.isPublic,
    })
    const nextTemplate = data.template || {}
@@ -1265,8 +1312,9 @@ async function saveTemplateMeta() {
    }
    templateMetaDraftName.value = nextTemplate.name || selectedTemplate.value.template.name || ''
    templateMetaDraftSlug.value = nextTemplate.slug || selectedTemplate.value.template.slug || selectedTemplate.value.template.id || ''
+    templateMetaDraftTags.value = Array.isArray(nextTemplate.tags) ? nextTemplate.tags.join(', ') : templateMetaDraftTags.value
    await refreshTemplates()
-    success.value = '템플릿 이름과 slug를 저장했어요.'
+    success.value = '템플릿 메타를 저장했어요.'
  } catch (e) {
    const errorCode = e?.data?.error || ''
    if (errorCode === 'topic_slug_taken') {
@@ -1277,7 +1325,7 @@ async function saveTemplateMeta() {
      error.value = 'slug는 영문 소문자, 숫자, 하이픈만 사용할 수 있어요.'
      return
    }
-    error.value = '템플릿 이름/slug를 저장하지 못했어요.'
+    error.value = '템플릿 메타를 저장하지 못했어요.'
  } finally {
    templateMetaSaving.value = false
  }
@@ -1348,20 +1396,23 @@ async function saveTemplateItemLabel(item) {
  resetMessages()
  if (!selectedTemplateId.value) return
  const nextLabel = (item.draftLabel || '').trim()
+  const nextTags = parseAdminTagsText(item.draftTags || '')
  if (!nextLabel) {
    error.value = '아이템 이름을 입력해주세요.'
    return
  }
-  if (nextLabel === item.label) return
+  if (nextLabel === item.label && JSON.stringify(nextTags) === JSON.stringify(Array.isArray(item.tags) ? item.tags : [])) return

  try {
    item.isSavingLabel = true
-    const data = await api.updateAdminTemplateItem(selectedTemplateId.value, item.id, { label: nextLabel })
+    const data = await api.updateAdminTemplateItem(selectedTemplateId.value, item.id, { label: nextLabel, tags: nextTags })
    item.label = data.item.label
    item.draftLabel = data.item.label
-    success.value = '기본 아이템 이름을 수정했어요.'
+    item.tags = Array.isArray(data.item.tags) ? data.item.tags : []
+    item.draftTags = item.tags.join(', ')
+    success.value = '기본 아이템 메타를 수정했어요.'
  } catch (e) {
-    error.value = '기본 아이템 이름 수정에 실패했어요.'
+    error.value = '기본 아이템 메타 수정에 실패했어요.'
  } finally {
    item.isSavingLabel = false
  }
@@ -1470,6 +1521,7 @@ function buildModalItemFromTierListItem(item, tierList) {
    sourceType: matchedItem?.sourceType || (String(id).startsWith('asset:') ? 'asset' : 'user'),
    sourceLabel: matchedItem?.sourceLabel || '티어표 추가 아이템',
    ownerName: matchedItem?.ownerName || tierListAuthorDisplayName(tierList),
+    tags: Array.isArray(matchedItem?.tags) ? matchedItem.tags : [],
    linkedTemplates: Array.isArray(matchedItem?.linkedTemplates) ? matchedItem.linkedTemplates : [],
    usageCount: matchedItem?.usageCount || 0,
    canDelete: typeof matchedItem?.canDelete === 'boolean' ? matchedItem.canDelete : false,
@@ -1704,6 +1756,63 @@ function closeTierListImportModal() {
  importModalItems.value = []
 }

+function openTemplateSourceImportModal() {
+  resetMessages()
+  if (!selectedTemplateId.value) {
+    error.value = '먼저 가져올 대상을 받을 템플릿을 선택해주세요.'
+    return
+  }
+  templateSourceImportSelectedIds.value = []
+  templateSourceImportQuery.value = ''
+  templateSourceImportModalOpen.value = true
+}
+
+function closeTemplateSourceImportModal() {
+  templateSourceImportModalOpen.value = false
+  templateSourceImportSelectedIds.value = []
+  templateSourceImportQuery.value = ''
+}
+
+function toggleTemplateSourceImportSelection(templateId) {
+  if (!templateId) return
+  if (templateSourceImportSelectedIds.value.includes(templateId)) {
+    templateSourceImportSelectedIds.value = templateSourceImportSelectedIds.value.filter((id) => id !== templateId)
+    return
+  }
+  templateSourceImportSelectedIds.value = [...templateSourceImportSelectedIds.value, templateId]
+}
+
+async function confirmTemplateSourceImport() {
+  resetMessages()
+  if (!selectedTemplateId.value) {
+    error.value = '가져올 대상을 받을 템플릿을 먼저 선택해주세요.'
+    return
+  }
+  if (!templateSourceImportSelectedIds.value.length) {
+    error.value = '아이템을 가져올 원본 템플릿을 하나 이상 선택해주세요.'
+    return
+  }
+
+  try {
+    let stagedCount = 0
+    for (const templateId of templateSourceImportSelectedIds.value) {
+      const template = templates.value.find((entry) => entry.id === templateId)
+      const data = await api.getTopic(templateId)
+      const libraryItems = (data.items || []).map((item) => ({
+        ...item,
+        sourceType: 'template',
+      }))
+      stagedCount += mergeLibraryItemsIntoDrafts(libraryItems, template?.name || data.topic?.name || templateId)
+    }
+    closeTemplateSourceImportModal()
+    success.value = stagedCount
+      ? `${stagedCount}개의 기존 템플릿 아이템을 초안 목록에 추가했어요. 필요 없는 항목은 제외한 뒤 저장하면 됩니다.`
+      : '추가로 가져올 새 아이템이 없었어요.'
+  } catch (e) {
+    error.value = '기존 템플릿 아이템을 가져오지 못했어요.'
+  }
+}
+
 async function confirmTierListImport() {
  resetMessages()
  if (!importModalTierList.value || !importModalItems.value.length) {
@@ -1837,12 +1946,14 @@ function openUserProfile(user) {
              :staged-request-draft-count="stagedRequestDraftCount"
              :applied-request-item-count="appliedRequestItemCount"
              :open-template-create-modal="openTemplateCreateModal"
+              :open-template-source-import-modal="openTemplateSourceImportModal"
              :is-template-loading="isTemplateLoading"
              :has-selected-template="hasSelectedTemplate"
              :selected-template="selectedTemplate"
              :display-thumbnail-url="displayThumbnailUrl"
              v-model:template-meta-draft-name="templateMetaDraftName"
              v-model:template-meta-draft-slug="templateMetaDraftSlug"
+              v-model:template-meta-draft-tags="templateMetaDraftTags"
              :template-meta-saving="templateMetaSaving"
              :can-save-template-meta="canSaveTemplateMeta"
              :save-template-meta="saveTemplateMeta"
@@ -2079,6 +2190,40 @@ function openUserProfile(user) {
              </div>
            </div>

+            <div v-if="templateSourceImportModalOpen" class="modalOverlay" @click.self="closeTemplateSourceImportModal">
+              <div class="modalCard modalCard--import" role="dialog" aria-modal="true">
+                <div class="modalCard__title">기존 템플릿 아이템 가져오기</div>
+                <div class="modalCard__desc">
+                  여러 템플릿의 기본 아이템을 초안 목록으로 모아둘 수 있어요. 이후 필요 없는 항목은 제외하고 현재 템플릿에만 저장하면 됩니다.
+                </div>
+
+                <div class="modalCard__form">
+                  <input v-model="templateSourceImportQuery" class="input" placeholder="템플릿 이름, slug, 태그 검색" />
+                </div>
+
+                <div class="templateImportList">
+                  <button
+                    v-for="template in filteredTemplateSourceImportTemplates"
+                    :key="template.id"
+                    type="button"
+                    class="adminTemplatePicker__item"
+                    :class="{ 'adminTemplatePicker__item--active': templateSourceImportSelectedIds.includes(template.id) }"
+                    @click="toggleTemplateSourceImportSelection(template.id)"
+                  >
+                    <span class="adminTemplatePicker__name">{{ template.name }}</span>
+                    <span class="adminTemplatePicker__meta">{{ template.slug || template.id }}</span>
+                    <span v-if="template.tags?.length" class="adminTemplatePicker__meta">#{{ template.tags.join(' #') }}</span>
+                  </button>
+                  <div v-if="!filteredTemplateSourceImportTemplates.length" class="hint">조건에 맞는 템플릿이 없어요.</div>
+                </div>
+
+                <div class="modalCard__actions">
+                  <button class="btn btn--ghost" @click="closeTemplateSourceImportModal">취소</button>
+                  <button class="btn btn--primary" @click="confirmTemplateSourceImport">초안으로 가져오기</button>
+                </div>
+              </div>
+            </div>
+
            <div v-if="customItemModalOpen" class="modalOverlay" @click.self="closeCustomItemModal">
              <div class="modalCard modalCard--customItem" role="dialog" aria-modal="true">
                <div v-if="modalTargetCustomItem" class="customItemModal">
@@ -2162,13 +2307,18 @@ function openUserProfile(user) {
                          <span class="field__label">아이템 이름</span>
                          <input v-model="customItemModalDraftLabel" class="field__input" type="text" maxlength="60" placeholder="아이템 이름" />
                        </label>
-                        <button class="btn btn--ghost customItemModal__renameButton" type="button" :disabled="customItemModalLabelSaving || !customItemModalDraftLabel.trim() || customItemModalDraftLabel.trim() === modalTargetCustomItem.label" @click="saveCustomItemModalLabel">
-                          {{ customItemModalLabelSaving ? '저장중...' : '이름 저장' }}
+                        <label v-if="modalTargetCustomItem.sourceType !== 'asset'" class="field">
+                          <span class="field__label">내부 태그</span>
+                          <input v-model="customItemModalDraftTags" class="field__input" type="text" maxlength="240" placeholder="예: 여캐릭, 귀멸, 2026Q1" />
+                        </label>
+                        <button class="btn btn--ghost customItemModal__renameButton" type="button" :disabled="customItemModalLabelSaving || !customItemModalDraftLabel.trim() || (customItemModalDraftLabel.trim() === modalTargetCustomItem.label && (modalTargetCustomItem.sourceType === 'asset' || JSON.stringify(parseAdminTagsText(customItemModalDraftTags)) === JSON.stringify(modalTargetCustomItem.tags || [])))" @click="saveCustomItemModalLabel">
+                          {{ customItemModalLabelSaving ? '저장중...' : '메타 저장' }}
                        </button>
                      </div>
                    <div class="customItemModal__metaList">
                      <div class="customItemModal__metaRow"><span>파일</span><strong :title="modalTargetCustomItem.src.split('/').pop()">{{ modalTargetCustomItem.src.split('/').pop() }}</strong></div>
                      <div class="customItemModal__metaRow"><span>업로더/출처</span><strong :title="modalTargetCustomItem.ownerName">{{ modalTargetCustomItem.ownerName }}</strong></div>
+                      <div class="customItemModal__metaRow"><span>태그</span><strong>{{ modalTargetCustomItem.tags?.length ? '#' + modalTargetCustomItem.tags.join(' #') : '없음' }}</strong></div>
                      <div class="customItemModal__metaRow"><span>템플릿 연결</span><strong>{{ visibleLinkedTemplates.length }}개 템플릿</strong></div>
                      <div class="customItemModal__metaRow"><span>등록일</span><strong>{{ fmt(modalTargetCustomItem.createdAt) }}</strong></div>
                    </div>
@@ -2200,7 +2350,10 @@ function openUserProfile(user) {
                        <button v-if="canReplaceModalTarget" class="btn btn--primary customItemModal__action" :disabled="!customItemReplacementTargetId || customItemReplacementBusy" @click="replaceCustomItem(modalTargetCustomItem)">
                          {{ customItemReplacementBusy ? '대체중...' : '선택한 이미지로 대체' }}
                        </button>
-                        <button v-if="modalTargetCustomItem.canDelete" class="btn btn--danger customItemModal__action" :disabled="modalTargetCustomItem.sourceType === 'user' && (modalTargetCustomItem.usageCount > 0 || visibleLinkedTemplates.length > 0)" @click="openCustomItemDeleteModal(modalTargetCustomItem)">삭제</button>
+                        <button v-if="modalTargetCustomItem.replacedAt" class="btn btn--ghost customItemModal__action" :disabled="customItemReplacementBusy" @click="restoreCustomItem(modalTargetCustomItem)">
+                          {{ customItemReplacementBusy ? '복구중...' : '원래 이미지로 복구' }}
+                        </button>
+                        <button v-if="modalTargetCustomItem.canDelete" class="btn btn--danger customItemModal__action" :disabled="modalTargetCustomItem.sourceType === 'user' && !modalTargetCustomItem.replacedAt && (modalTargetCustomItem.usageCount > 0 || visibleLinkedTemplates.length > 0)" @click="openCustomItemDeleteModal(modalTargetCustomItem)">삭제</button>
                      </div>
                    </div>
                  </div>
@@ -2428,7 +2581,7 @@ function openUserProfile(user) {
        <div class="adminSidebar__label">Filters</div>
        <div class="adminSidebar__group">
          <div class="adminSidebar__inlineRow">
-            <input v-model="customItemQuery" class="input" placeholder="파일명, 라벨, 업로더 검색" @keydown.enter.prevent="submitCustomItemSearch" />
+            <input v-model="customItemQuery" class="input" placeholder="파일명, 라벨, 태그, 업로더 검색" @keydown.enter.prevent="submitCustomItemSearch" />
            <button class="btn btn--ghost" @click="submitCustomItemSearch">검색</button>
          </div>
        </div>
@@ -2442,14 +2595,23 @@ function openUserProfile(user) {
            <option value="library">아이템(템플릿 + 사용자)</option>
            <option value="template">템플릿 아이템</option>
            <option value="user">사용자 아이템</option>
+            <option value="replaced-user">대체된 아이템</option>
            <option value="thumbnail">썸네일 이미지</option>
            <option value="avatar">프로필 이미지</option>
-            <option value="unused-user">미사용 아이템</option>
+            <option value="unused">미사용 이미지</option>
          </select>
        </div>
        <div class="adminSidebar__actions">
          <button class="btn btn--ghost" @click="refreshCustomItems">새로고침</button>
-          <button class="btn btn--danger" :disabled="customItemFilter !== 'unused-user' || !customItems.length" @click="removeUnusedCustomItems">미사용 아이템 일괄 삭제</button>
+          <button
+            v-if="customItemFilter === 'unused'"
+            class="btn btn--danger"
+            :disabled="!hasDeletableUnusedItems"
+            @click="removeUnusedCustomItems"
+          >
+            미사용 이미지 일괄 삭제
+          </button>
+          <button v-else class="btn btn--ghost" @click="showUnusedCustomItems">미사용 이미지 확인</button>
        </div>
        <div class="adminSidebar__stats">
          <div class="sidebarStat">
@@ -2806,6 +2968,12 @@ function openUserProfile(user) {
  opacity: 0.58;
  border-style: dashed;
 }
+.adminUiScope .templateImportList {
+  display: grid;
+  gap: 10px;
+  max-height: 360px;
+  overflow: auto;
+}
 .adminUiScope .adminTemplatePicker__name {
  font-size: 13px;
  font-weight: 800;
@@ -3278,7 +3446,7 @@ function openUserProfile(user) {
  display: flex;
  justify-content: space-between;
  gap: 10px;
-  /* flex-wrap: wrap; */
+  flex-wrap: wrap;
 }
 .adminUiScope .selectedThumb {
  width: min(100%, 256px);
--- a/frontend/src/views/TierEditorView.vue
+++ b/frontend/src/views/TierEditorView.vue
@@ -473,6 +473,25 @@ function duplicateItemToPool() {
  toast.success('아이템 추가 완료')
 }

+function canRemoveEditorItem(itemId) {
+  return canEdit.value && itemsById.value[itemId]?.origin === 'custom'
+}
+
+function deleteEditorItem(itemId) {
+  if (!canRemoveEditorItem(itemId)) return
+  const targetItem = itemsById.value[itemId]
+  detachItemById(itemId)
+  if (typeof targetItem?.src === 'string' && targetItem.src.startsWith('blob:')) {
+    URL.revokeObjectURL(targetItem.src)
+  }
+  const nextItems = { ...itemsById.value }
+  delete nextItems[itemId]
+  itemsById.value = nextItems
+  if (selectedItemId.value === itemId) selectedItemId.value = ''
+  if (itemContextMenu.value.itemId === itemId) closeItemContextMenu()
+  toast.success('커스텀 이미지를 현재 티어표에서 제거했어요.')
+}
+
 function handleGlobalContextMenu(event) {
  const target = event?.target
  if (target?.closest?.('[data-item-context-menu]')) {
@@ -1684,6 +1703,16 @@ onUnmounted(() => {
                        >
                          ×
                        </button>
+                        <button
+                          v-if="canRemoveEditorItem(id) && !isExporting"
+                          class="cellDeleteBtn"
+                          type="button"
+                          title="커스텀 이미지 제거"
+                          @pointerdown.stop
+                          @click.stop="deleteEditorItem(id)"
+                        >
+                          삭제
+                        </button>
                      </div>
                    </div>
                  </div>
@@ -1760,6 +1789,16 @@ onUnmounted(() => {
                draggable="false"
              />
              <div class="poolItem__label">{{ itemsById[id]?.label || id }}</div>
+              <button
+                v-if="canRemoveEditorItem(id)"
+                class="poolItem__deleteBtn"
+                type="button"
+                title="커스텀 이미지 제거"
+                @pointerdown.stop
+                @click.stop="deleteEditorItem(id)"
+              >
+                삭제
+              </button>
              <div v-if="!canEdit" class="poolItem__state">미배치</div>
            </div>
          </div>
@@ -1777,6 +1816,9 @@ onUnmounted(() => {
        <button class="itemContextMenu__action" type="button" @click="duplicateItemToPool">
          아이템 복제
        </button>
+        <button v-if="canRemoveEditorItem(itemContextMenu.itemId)" class="itemContextMenu__action itemContextMenu__action--danger" type="button" @click="deleteEditorItem(itemContextMenu.itemId)">
+          이 커스텀 이미지 제거
+        </button>
      </div>

    </div>
@@ -3024,6 +3066,7 @@ onUnmounted(() => {
  cursor: copy;
 }
 .poolItem {
+  position: relative;
  min-width: 0;
  display: grid;
  grid-template-columns: 1fr;
@@ -3070,6 +3113,23 @@ onUnmounted(() => {
  text-transform: uppercase;
  color: var(--theme-text-soft);
 }
+.poolItem__deleteBtn,
+.cellDeleteBtn {
+  position: absolute;
+  right: 8px;
+  bottom: 8px;
+  border: 0;
+  border-radius: 999px;
+  padding: 6px 9px;
+  background: rgba(11, 18, 32, 0.84);
+  color: #fff;
+  font-size: 10px;
+  font-weight: 800;
+  cursor: pointer;
+}
+.cellDeleteBtn {
+  bottom: 34px;
+}
 .poolItem--hidden {
  display: none;
 }
@@ -3101,6 +3161,9 @@ onUnmounted(() => {
 .itemContextMenu__action:hover {
  background: var(--theme-pill-bg);
 }
+.itemContextMenu__action--danger {
+  color: #fca5a5;
+}

 .hidden {
  display: none;
Author	SHA1	Message	Date
zenn	fe79c91e82	feat: 템플릿 태그와 병합 가져오기 및 에디터 제거 추가	2026-04-06 11:48:22 +09:00
zenn	2d5506e35a	feat: 미사용 이미지 기준과 관리자 자산 정리 통합	2026-04-06 11:29:06 +09:00
zenn	8b3d469503	fix: 대체 아이템 삭제와 미사용 정리 기준 보정	2026-04-06 11:17:19 +09:00
zenn	a2fc8f8cd4	feat: 관리자 대체 아이템 전용 필터 추가	2026-04-06 11:09:48 +09:00
zenn	b134431d91	fix: 이미지 대체 시 원본 사용자 아이템 정보 보존	2026-04-06 11:03:32 +09:00