update

2026-09-30 11:58:32 +08:00
parent 065d57457e
commit 1b06bd5bda
24 changed files with 2588 additions and 1659 deletions
--- a/internal/handler/assets/admin.js
+++ b/internal/handler/assets/admin.js
@ -207,9 +207,56 @@
    if (focusMain) setExpanded(focusMain, true);
  }

+  // ── 编辑页：实时翻译建议 + 季节码预览 ──────────────────────────────
+  // 与后端 pkg/season.Derive 同规则；仅用于只读预览，服务端保存时仍按同规则重算 season_code。
+  function deriveSeasonCode(year, collectionType, season) {
+    if (!year) return '';
+    var y = String(year).slice(-2);
+    var prefix = 'SS';
+    switch (collectionType) {
+      case 'resort': prefix = 'RES'; break;
+      case 'pre_fall': prefix = 'PF'; break;
+      case 'couture': case 'menswear': prefix = 'FW'; break;
+      default:
+        if (season === 'fall' || season === 'winter') prefix = 'FW';
+        else prefix = 'SS';
+    }
+    return prefix + y;
+  }
+
+  function initEditForm() {
+    var en = document.getElementById('rw-title-en') || document.getElementById('snap-title-en');
+    if (!en) return;
+    var cn = document.getElementById('rw-title-cn') || document.getElementById('snap-title-cn');
+
+    // 英文标题失焦且中文为空时，拉建议回填（不覆盖手填）。
+    en.addEventListener('blur', function () {
+      if (cn && cn.value.trim() === '') {
+        fetch('/admin/api/suggest-title-cn?title_en=' + encodeURIComponent(en.value))
+          .then(function (r) { return r.json(); })
+          .then(function (d) { if (d && d.title_cn) cn.value = d.title_cn; })
+          .catch(function () {});
+      }
+    });
+
+    // 走秀：年份/季节/系列变动即时算季节码（只读预览；服务端保存时仍按同规则重算）。
+    var year = document.getElementById('rw-year');
+    var season = document.getElementById('rw-season');
+    var collection = document.getElementById('rw-collection');
+    var code = document.getElementById('rw-season-code');
+    function refreshCode() {
+      if (!year || !code) return;
+      code.value = deriveSeasonCode(year.value, collection ? collection.value : '', season ? season.value : '');
+    }
+    if (year) year.addEventListener('input', refreshCode);
+    if (season) season.addEventListener('input', refreshCode);
+    if (collection) collection.addEventListener('input', refreshCode);
+  }
+
  document.addEventListener('DOMContentLoaded', function () {
    initZoom();
    if (document.getElementById('sel-all') || document.getElementById('batchbar')) initArticleList();
    if (document.getElementById('batch')) initArticleDetail();
+    initEditForm();
  });
 })();
--- a/internal/handler/backstage_handler.go
+++ b/internal/handler/backstage_handler.go
@ -5,14 +5,16 @@ import (
 	"fmt"
 	"net/http"
 	"strconv"
+	"strings"
 	"time"

 	"fashionapi/internal/dto"
 	"fashionapi/internal/middleware"
 	"fashionapi/internal/model"
 	"fashionapi/internal/pkg/hashid"
-	"fashionapi/internal/repository"
 	"fashionapi/internal/pkg/pagination"
+	"fashionapi/internal/pkg/season"
+	"fashionapi/internal/repository"
 	"fashionapi/internal/service"

 	"github.com/gin-gonic/gin"
@ -34,11 +36,12 @@ type BackstageHandler struct {
 	review    service.ReviewService
 	ingest    *service.IngestService
 	adminRepo repository.AdminRepository
+	translate *service.TranslateService // 标题翻译（可为 nil：未启用时跳过记忆写入/建议）
 }

 // NewBackstageHandler 创建后台 handler。
-func NewBackstageHandler(auth service.AuthService, brand service.BrandService, article service.ArticleService, street service.StreetSnapService, review service.ReviewService, ingest *service.IngestService, adminRepo repository.AdminRepository) *BackstageHandler {
-	return &BackstageHandler{auth: auth, brand: brand, article: article, street: street, review: review, ingest: ingest, adminRepo: adminRepo}
+func NewBackstageHandler(auth service.AuthService, brand service.BrandService, article service.ArticleService, street service.StreetSnapService, review service.ReviewService, ingest *service.IngestService, adminRepo repository.AdminRepository, translate *service.TranslateService) *BackstageHandler {
+	return &BackstageHandler{auth: auth, brand: brand, article: article, street: street, review: review, ingest: ingest, adminRepo: adminRepo, translate: translate}
 }

 // 模板渲染机制见 templates.go：模板已抽成 templates/ 下的独立 .html 文件（go:embed），
@ -534,6 +537,23 @@ type ingestJobView struct {

 // IngestJobs 分页列出入库任务，展示状态 / 重试次数 / 来源 / 错误 / 时间。
 // 支持 ?page（从 1 起）与 ?pageSize（默认 50，上限 200）；其余查询串原样忽略。
+// SuggestTitleCn 后台编辑页实时翻译建议：给定英文标题，返回建议中文标题（JSON）。
+// 仅对已登录后台暴露；翻译服务未注入时返回空 title_cn（前端据此不回填）。
+func (h *BackstageHandler) SuggestTitleCn(c *gin.Context) {
+	en := c.Query("title_en")
+	if strings.TrimSpace(en) == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "missing title_en"})
+		return
+	}
+	cn := ""
+	if h.translate != nil {
+		if s, err := h.translate.SuggestTitleCn(c.Request.Context(), en); err == nil {
+			cn = s
+		}
+	}
+	c.JSON(http.StatusOK, gin.H{"title_cn": cn})
+}
+
 func (h *BackstageHandler) IngestJobs(c *gin.Context) {
 	p := pagination.Parse(c, "page", "pageSize", 1, 50, 200)
 	offset := p.Offset()
@ -754,15 +774,24 @@ func (h *BackstageHandler) RunwayUpdate(c *gin.Context) {
 			year = uint16(y)
 		}
 	}
+	seasonVal := c.PostForm("season")
+	collectionType := c.PostForm("collection_type")
+	titleEn := c.PostForm("title_en")
+	titleCn := strings.TrimSpace(c.PostForm("title_cn"))
 	fields := map[string]any{
-		"title_en":        c.PostForm("title_en"),
-		"title_cn":        c.PostForm("title_cn"),
+		"title_en":        titleEn,
+		"title_cn":        titleCn,
 		"description_en":  c.PostForm("description_en"),
 		"description_cn":  c.PostForm("description_cn"),
-		"season":          c.PostForm("season"),
-		"collection_type": c.PostForm("collection_type"),
-		"season_code":     c.PostForm("season_code"),
-		"year":            year,
+		"season":          seasonVal,
+		"collection_type": collectionType,
+		// season_code 一律由「年份 + 系列 + 季节」推导，忽略表单原值，杜绝错码（见 pkg/season）。
+		"season_code": season.Derive(year, collectionType, seasonVal),
+		"year":        year,
+	}
+	// 人工填写的中文标题写入翻译记忆，供后续入库/编辑优先命中（永久精确）；翻译服务未注入时跳过。
+	if titleCn != "" && h.translate != nil {
+		_ = h.translate.Remember(c.Request.Context(), titleEn, titleCn)
 	}
 	if err := h.article.UpdateRunway(c.Request.Context(), numeric, fields); err != nil {
 		renderPage(c, http.StatusInternalServerError, "error", gin.H{"Error": err.Error()})
@ -999,12 +1028,18 @@ func (h *BackstageHandler) StreetSnapUpdate(c *gin.Context) {
 			year = uint16(y)
 		}
 	}
+	titleEn := c.PostForm("title")
+	titleCn := strings.TrimSpace(c.PostForm("title_cn"))
 	fields := map[string]any{
-		"title":    c.PostForm("title"),
-		"title_cn": c.PostForm("title_cn"),
+		"title":    titleEn,
+		"title_cn": titleCn,
 		"city":     c.PostForm("city"),
 		"year":     year,
 	}
+	// 人工填写的中文标题写入翻译记忆，供后续入库/编辑优先命中（永久精确）；翻译服务未注入时跳过。
+	if titleCn != "" && h.translate != nil {
+		_ = h.translate.Remember(c.Request.Context(), titleEn, titleCn)
+	}
 	if err := h.street.UpdateSnap(c.Request.Context(), numeric, fields); err != nil {
 		renderPage(c, http.StatusInternalServerError, "error", gin.H{"Error": err.Error()})
 		return
--- a/internal/handler/templates/pages/runway-edit.html
+++ b/internal/handler/templates/pages/runway-edit.html
@ -7,10 +7,16 @@
 <p class="muted">品牌 {{.BrandName}}{{if .IsDown}} · <span class="down">已下架</span>{{end}}</p>
 <p class="muted">原图总大小：{{formatBytes .ImageTotalSize}}</p>
 <form method="post" action="/admin/runways/{{.UID}}/edit">
-<div class="row"><div><label>英文标题</label><input name="title_en" value="{{.Runway.TitleEn}}"></div><div><label>中文标题</label><input name="title_cn" value="{{.Runway.TitleCn}}"></div></div>
+<div class="row"><div><label>英文标题</label><input name="title_en" id="rw-title-en" value="{{.Runway.TitleEn}}"></div><div><label>中文标题</label><input name="title_cn" id="rw-title-cn" value="{{.Runway.TitleCn}}"></div></div>
 <div class="row"><div><label>英文描述</label><textarea name="description_en">{{.Runway.DescriptionEn}}</textarea></div><div><label>中文描述</label><textarea name="description_cn">{{.Runway.DescriptionCn}}</textarea></div></div>
-<div class="row"><div><label>年份</label><input name="year" value="{{.Runway.Year}}"></div><div><label>季节</label><input name="season" value="{{.Runway.Season}}"></div></div>
-<div class="row"><div><label>系列 (collection_type)</label><input name="collection_type" value="{{.Runway.CollectionType}}"></div><div><label>季节码 (season_code)</label><input name="season_code" value="{{.Runway.SeasonCode}}"></div></div>
+<div class="row"><div><label>年份</label><input name="year" id="rw-year" value="{{.Runway.Year}}"></div><div><label>季节</label><input name="season" id="rw-season" list="season-list" value="{{.Runway.Season}}"></div></div>
+<div class="row"><div><label>系列 (collection_type)</label><input name="collection_type" id="rw-collection" list="collection-list" value="{{.Runway.CollectionType}}"></div><div><label>季节码（自动）</label><input name="season_code" id="rw-season-code" value="{{.Runway.SeasonCode}}" readonly></div></div>
+<datalist id="season-list">
+  <option value="Spring"><option value="Summer"><option value="Fall"><option value="Winter"><option value="Resort"><option value="Pre-Spring"><option value="Pre-Fall">
+</datalist>
+<datalist id="collection-list">
+  <option value="rtw"><option value="menswear"><option value="couture"><option value="resort"><option value="pre_fall">
+</datalist>
 <button type="submit">保存字段</button>
 </form>

--- a/internal/handler/templates/pages/snap-edit.html
+++ b/internal/handler/templates/pages/snap-edit.html
@ -7,7 +7,7 @@
 <p class="muted">{{if .IsDown}}<span class="down">已下架</span>{{end}}</p>
 <p class="muted">原图总大小：{{formatBytes .ImageTotalSize}}</p>
 <form method="post" action="/admin/street-snaps/{{.UID}}/edit">
-<div class="row"><div><label>英文标题</label><input name="title" value="{{.Snap.Title}}"></div><div><label>中文标题</label><input name="title_cn" value="{{.Snap.TitleCn}}"></div></div>
+<div class="row"><div><label>英文标题</label><input name="title" id="snap-title-en" value="{{.Snap.Title}}"></div><div><label>中文标题</label><input name="title_cn" id="snap-title-cn" value="{{.Snap.TitleCn}}"></div></div>
 <div class="row"><div><label>年份</label><input name="year" value="{{.Snap.Year}}"></div><div><label>城市</label><input name="city" value="{{.Snap.City}}"></div></div>
 <button type="submit">保存字段</button>
 </form>
--- a/internal/repository/article_repository.go
+++ b/internal/repository/article_repository.go
@ -46,6 +46,10 @@ type ArticleRepository interface {
 	GetRunwayImageRunwayID(ctx context.Context, imageID uint32) (uint32, error)
 	// ReresolveRunwayDedup 删图后重算本画廊去重，消除陈旧 dup_of（见方法注释）。
 	ReresolveRunwayDedup(ctx context.Context, runwayID uint32) error
+	// ReresolveRunwayDupOfSources 删图后清理「以被删图为源」的跨文章重复标记（见方法注释）。
+	ReresolveRunwayDupOfSources(ctx context.Context, deletedImageIDs []uint32) error
+	// GetRunwayLiveImageIDs 取某走秀全部存活图片 id（级联下架前用于跨文章去重清理）。
+	GetRunwayLiveImageIDs(ctx context.Context, runwayID uint32) ([]uint32, error)
 	// SoftDeleteRunwayImages 软删某走秀的全部图片（级联下架用），返回被删图片的 key 列表。
 	SoftDeleteRunwayImages(ctx context.Context, runwayID uint32) ([]string, error)
 	// SetRunwayCover 更新走秀封面（同时回到图片列表首张）。
@ -480,6 +484,60 @@ func (r *articleRepository) ReresolveRunwayDedup(ctx context.Context, runwayID u
 	})
 }

+// ReresolveRunwayDupOfSources 删除图片后，清理「以被删图为源」的跨文章重复标记。
+// 给定刚被软删的走秀图片 id 列表，找出所有仍存活（其它文章）且 dup_of 指向它们的图片，
+// 在全局存活图里重新近重复判定：找到新源则改指新源，否则清掉重复标记。
+// 为什么需要：删 B 文章/图时，A 文章中 dup_of 指向 B 图的行不会被 ReresolveRunwayDedup
+// （仅本集内重算）清理，导致 A 仍误显「重复」且「查看来源」指向已删图打不开。
+func (r *articleRepository) ReresolveRunwayDupOfSources(ctx context.Context, deletedImageIDs []uint32) error {
+	if len(deletedImageIDs) == 0 {
+		return nil
+	}
+	strIDs := make([]string, 0, len(deletedImageIDs))
+	for _, id := range deletedImageIDs {
+		strIDs = append(strIDs, strconv.FormatUint(uint64(id), 10))
+	}
+	var affected []model.BrandRunwayImage
+	if err := r.db.WithContext(ctx).
+		Where("is_deleted = 0 AND dup_of IN ?", strIDs).
+		Find(&affected).Error; err != nil {
+		return err
+	}
+	if len(affected) == 0 {
+		return nil
+	}
+	return r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+		for _, im := range affected {
+			if !im.Phash.Valid || im.Phash.String == "" {
+				if err := tx.Model(&model.BrandRunwayImage{}).
+					Where("id = ? AND is_deleted = 0", im.ID).
+					Updates(map[string]any{"is_duplicate": 0, "dup_of": ""}).Error; err != nil {
+					return err
+				}
+				continue
+			}
+			src, err := nearDupExceptRunway(tx, im.Phash.String, phash.DefaultThreshold, im.ID, im.RunwayID, im.SortOrder)
+			if err != nil {
+				return err
+			}
+			if src != 0 && src != im.ID {
+				if err := tx.Model(&model.BrandRunwayImage{}).
+					Where("id = ? AND is_deleted = 0", im.ID).
+					Updates(map[string]any{"is_duplicate": 1, "dup_of": strconv.FormatUint(uint64(src), 10)}).Error; err != nil {
+					return err
+				}
+			} else {
+				if err := tx.Model(&model.BrandRunwayImage{}).
+					Where("id = ? AND is_deleted = 0", im.ID).
+					Updates(map[string]any{"is_duplicate": 0, "dup_of": ""}).Error; err != nil {
+					return err
+				}
+			}
+		}
+		return nil
+	})
+}
+
 // GetRunwayDupSources 批量反查重复源（见接口注释）。一次 IN 查询 + JOIN 走秀与品牌，
 // 避免逐图 N+1；源图可能已被删（查不到则跳过，不报错）。
 func (r *articleRepository) GetRunwayDupSources(ctx context.Context, imageIDs []uint32) (map[uint32]dto.DupSource, error) {
@ -554,6 +612,18 @@ func (r *articleRepository) SoftDeleteRunwayImages(ctx context.Context, runwayID
 	return keys, nil
 }

+// GetRunwayLiveImageIDs 取某走秀全部存活图片的 id（级联下架前取出，供跨文章去重清理）。
+func (r *articleRepository) GetRunwayLiveImageIDs(ctx context.Context, runwayID uint32) ([]uint32, error) {
+	var ids []uint32
+	if err := r.db.WithContext(ctx).
+		Model(&model.BrandRunwayImage{}).
+		Where("runway_id = ? AND is_deleted = 0", runwayID).
+		Pluck("id", &ids).Error; err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
 func (r *articleRepository) SetRunwayCover(ctx context.Context, runwayID uint32, image string) error {
 	return r.db.WithContext(ctx).
 		Model(&model.BrandRunway{}).
--- a/internal/repository/editor_image_delete_integration_test.go
+++ b/internal/repository/editor_image_delete_integration_test.go
@ -408,3 +408,49 @@ func TestEditorPurgeSnapGalleryClearsCover(t *testing.T) {
 		t.Fatalf("下架清空图片后封面应清空，实际 %q", got)
 	}
 }
+
+// TestEditorCrossArticleRunwayDupClearedOnSourceDeleted 回归「跨文章」去重清理：
+// A（重复方）的图 dup_of 指向 B（源方）的图；删掉整篇 B 后，A 的图不应再挂指向已删图的 dup_of，
+// 否则编辑页继续误显「重复」且「查看来源」打不开。对应线上「删了 B，A 的重复标记还在」。
+func TestEditorCrossArticleRunwayDupClearedOnSourceDeleted(t *testing.T) {
+	db := testDB(t)
+	ctx := context.Background()
+	repo := NewArticleRepository(db)
+
+	// 两篇相互独立文章（不同实体键），各含一张近重复图（同 phash）。
+	srcRunway := seedEditorRunway(t, db, 1) // 源方 B
+	dupRunway := seedEditorRunway(t, db, 1) // 重复方 A
+	allOne := phash.ToVectorBits(^uint64(0))
+	srcImg := seedEditorRunwayImagePhash(t, db, srcRunway, "src", 1, 0, allOne)
+	dupImg := seedEditorRunwayImagePhash(t, db, dupRunway, "dup", 1, 0, allOne)
+
+	// 预置陈旧态：A 的图标记为重复、dup_of 指向 B 的图（跨文章）。
+	if err := db.Model(&model.BrandRunwayImage{}).Where("id = ?", dupImg).
+		Updates(map[string]any{"is_duplicate": 1, "dup_of": strconv.FormatUint(uint64(srcImg), 10)}).Error; err != nil {
+		t.Fatalf("预置跨文章重复标记失败: %v", err)
+	}
+
+	// 模拟后台删除整篇 B：软删其全部图片，再跨文章重算去重（PurgeGallery 的调用序列）。
+	delIDs, err := repo.GetRunwayLiveImageIDs(ctx, srcRunway)
+	if err != nil {
+		t.Fatalf("取存活图片 id 失败: %v", err)
+	}
+	if _, err := repo.SoftDeleteRunwayImages(ctx, srcRunway); err != nil {
+		t.Fatalf("下架删图失败: %v", err)
+	}
+	if err := repo.ReresolveRunwayDupOfSources(ctx, delIDs); err != nil {
+		t.Fatalf("跨文章重算去重失败: %v", err)
+	}
+
+	di, of := editorImageFlag(t, db, dupImg)
+	if di != 0 {
+		t.Fatalf("删掉源方 B 后，A 的图应清掉重复标记（is_duplicate=0），实际 %d", di)
+	}
+	if of != "" {
+		t.Fatalf("删掉源方 B 后，A 的图 dup_of 应为空，实际 %q", of)
+	}
+}
+
+// 注：街拍跨文章去重清理（ReresolveSnapDupOfSources / GetSnapLiveImageIDs）为走秀版的逐行镜像，
+// 逻辑由 TestEditorCrossArticleRunwayDupClearedOnSourceDeleted 覆盖。本条对应的街拍集成测试因本地
+// street_snaps 表缺 title_cn 列（预存 schema 漂移，连既有街拍测试也跑不了）暂未加入，待本地库补迁移后补回。
--- a/internal/repository/street_snap_repository.go
+++ b/internal/repository/street_snap_repository.go
@ -48,6 +48,10 @@ type StreetSnapRepository interface {
 	GetSnapImageRunwayID(ctx context.Context, imageID uint32) (uint32, error)
 	// ReresolveSnapDedup 删图后重算本专辑去重，消除陈旧 dup_of（见方法注释）。
 	ReresolveSnapDedup(ctx context.Context, snapID uint32) error
+	// ReresolveSnapDupOfSources 删图后清理「以被删图为源」的跨文章重复标记（见方法注释）。
+	ReresolveSnapDupOfSources(ctx context.Context, deletedImageIDs []uint32) error
+	// GetSnapLiveImageIDs 取某街拍全部存活图片 id（级联下架前用于跨文章去重清理）。
+	GetSnapLiveImageIDs(ctx context.Context, snapID uint32) ([]uint32, error)
 	// SoftDeleteSnapImages 软删某街拍的全部图片（级联下架用），返回被删图片的 key 列表。
 	SoftDeleteSnapImages(ctx context.Context, snapID uint32) ([]string, error)
 	// SetSnapCover 更新街拍封面。
@ -421,6 +425,57 @@ func (r *streetSnapRepository) ReresolveSnapDedup(ctx context.Context, snapID ui
 	})
 }

+// ReresolveSnapDupOfSources 删除图片后，清理「以被删图为源」的跨文章重复标记（见方法注释）。
+// 逻辑同 ReresolveRunwayDupOfSources，仅表换成 street_snap_images。
+func (r *streetSnapRepository) ReresolveSnapDupOfSources(ctx context.Context, deletedImageIDs []uint32) error {
+	if len(deletedImageIDs) == 0 {
+		return nil
+	}
+	strIDs := make([]string, 0, len(deletedImageIDs))
+	for _, id := range deletedImageIDs {
+		strIDs = append(strIDs, strconv.FormatUint(uint64(id), 10))
+	}
+	var affected []model.StreetSnapImage
+	if err := r.db.WithContext(ctx).
+		Where("is_deleted = 0 AND dup_of IN ?", strIDs).
+		Find(&affected).Error; err != nil {
+		return err
+	}
+	if len(affected) == 0 {
+		return nil
+	}
+	return r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+		for _, im := range affected {
+			if !im.Phash.Valid || im.Phash.String == "" {
+				if err := tx.Model(&model.StreetSnapImage{}).
+					Where("id = ? AND is_deleted = 0", im.ID).
+					Updates(map[string]any{"is_duplicate": 0, "dup_of": ""}).Error; err != nil {
+					return err
+				}
+				continue
+			}
+			src, err := nearDupExceptSnap(tx, im.Phash.String, phash.DefaultThreshold, im.ID, im.SnapID, im.SortOrder)
+			if err != nil {
+				return err
+			}
+			if src != 0 && src != im.ID {
+				if err := tx.Model(&model.StreetSnapImage{}).
+					Where("id = ? AND is_deleted = 0", im.ID).
+					Updates(map[string]any{"is_duplicate": 1, "dup_of": strconv.FormatUint(uint64(src), 10)}).Error; err != nil {
+					return err
+				}
+			} else {
+				if err := tx.Model(&model.StreetSnapImage{}).
+					Where("id = ? AND is_deleted = 0", im.ID).
+					Updates(map[string]any{"is_duplicate": 0, "dup_of": ""}).Error; err != nil {
+					return err
+				}
+			}
+		}
+		return nil
+	})
+}
+
 // GetStreetSnapDupSources 批量反查重复源（见接口注释）。街拍无品牌关联；一次 IN 查询 + JOIN。
 func (r *streetSnapRepository) GetStreetSnapDupSources(ctx context.Context, imageIDs []uint32) (map[uint32]dto.DupSource, error) {
 	out := make(map[uint32]dto.DupSource, len(imageIDs))
@ -487,6 +542,18 @@ func (r *streetSnapRepository) SoftDeleteSnapImages(ctx context.Context, snapID
 	return keys, nil
 }

+// GetSnapLiveImageIDs 取某街拍全部存活图片的 id（级联下架前取出，供跨文章去重清理）。
+func (r *streetSnapRepository) GetSnapLiveImageIDs(ctx context.Context, snapID uint32) ([]uint32, error) {
+	var ids []uint32
+	if err := r.db.WithContext(ctx).
+		Model(&model.StreetSnapImage{}).
+		Where("snap_id = ? AND is_deleted = 0", snapID).
+		Pluck("id", &ids).Error; err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
 func (r *streetSnapRepository) SetSnapCover(ctx context.Context, snapID uint32, image string) error {
 	return r.db.WithContext(ctx).
 		Model(&model.StreetSnap{}).
--- a/internal/repository/translate_repository.go
+++ b/internal/repository/translate_repository.go
@ -0,0 +1,57 @@
+package repository
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"gorm.io/gorm"
+)
+
+// TitleCnMemory 翻译记忆表行（title_cn_memory）。
+type TitleCnMemory struct {
+	TitleEn   string `gorm:"primaryKey;column:title_en"`
+	TitleCn   string `gorm:"column:title_cn"`
+	UpdatedAt uint32 `gorm:"column:updated_at"`
+}
+
+// TableName 指定记忆表名。
+func (TitleCnMemory) TableName() string { return "title_cn_memory" }
+
+// TranslateRepository 标题翻译记忆的读写接口。
+type TranslateRepository interface {
+	// GetTitleCnMemory 取某英文标题的人工中文翻译；不存在返回 (_, false, nil)。
+	GetTitleCnMemory(ctx context.Context, titleEn string) (string, bool, error)
+	// UpsertTitleCnMemory 幂等写入/更新一条映射。
+	UpsertTitleCnMemory(ctx context.Context, titleEn, titleCn string) error
+}
+
+type translateRepository struct {
+	db *gorm.DB
+}
+
+// NewTranslateRepository 创建翻译记忆仓储。
+func NewTranslateRepository(db *gorm.DB) TranslateRepository {
+	return &translateRepository{db: db}
+}
+
+func (r *translateRepository) GetTitleCnMemory(ctx context.Context, titleEn string) (string, bool, error) {
+	var row TitleCnMemory
+	err := r.db.WithContext(ctx).Where("title_en = ?", titleEn).First(&row).Error
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return "", false, nil
+		}
+		return "", false, err
+	}
+	return row.TitleCn, true, nil
+}
+
+func (r *translateRepository) UpsertTitleCnMemory(ctx context.Context, titleEn, titleCn string) error {
+	now := uint32(time.Now().Unix())
+	row := TitleCnMemory{TitleEn: titleEn, TitleCn: titleCn, UpdatedAt: now}
+	return r.db.WithContext(ctx).
+		Where("title_en = ?", titleEn).
+		Assign(TitleCnMemory{TitleCn: titleCn, UpdatedAt: now}).
+		FirstOrCreate(&row).Error
+}
--- a/internal/router/backstage.go
+++ b/internal/router/backstage.go
@ -82,6 +82,8 @@ func NewBackstage(opt BackstageOptions) *gin.Engine {
 		admin.POST("/api/articles/batch", opt.Backstage.ArticleBatch)
 		admin.POST("/api/articles/:kind/:id/images/attach", opt.Backstage.ArticleAttachImagesAPI)
 		admin.POST("/api/articles/:kind/:id/images/:img/detach", opt.Backstage.ArticleDetachImageAPI)
+		// 编辑页实时翻译建议（已登录后台）：英文标题 → 建议中文标题。
+		admin.GET("/api/suggest-title-cn", opt.Backstage.SuggestTitleCn)

 		admin.GET("/", opt.Backstage.Dashboard)
 		admin.GET("/brands", opt.Backstage.Brands)
--- a/internal/router/backstage_test.go
+++ b/internal/router/backstage_test.go
@ -150,6 +150,9 @@ func (f *fakeArticle) PurgeGallery(ctx context.Context, id uint32) error {
 func (f *fakeArticle) GetRunwayDupSources(ctx context.Context, imageIDs []uint32) (map[uint32]dto.DupSource, error) {
 	return map[uint32]dto.DupSource{}, nil
 }
+func (f *fakeArticle) SumImageSize(ctx context.Context, runwayID uint32) (int64, error) {
+	return 0, nil
+}

 type fakeStreet struct{}

@ -210,10 +213,17 @@ func (f *fakeStreet) PurgeGallery(ctx context.Context, id uint32) error {
 func (f *fakeStreet) GetStreetSnapDupSources(ctx context.Context, imageIDs []uint32) (map[uint32]dto.DupSource, error) {
 	return map[uint32]dto.DupSource{}, nil
 }
+func (f *fakeStreet) SumImageSize(ctx context.Context, snapID uint32) (int64, error) {
+	return 0, nil
+}

 // fakeAdminRepo 实现文章管理仓储接口；返回固定的混合列表示例，供路由/模板渲染测试。
 type fakeAdminRepo struct{}

+func (f *fakeAdminRepo) ImageSizeByRecords(ctx context.Context, kind string, ids []uint32) (map[uint32]int64, error) {
+	return map[uint32]int64{}, nil
+}
+
 func (f *fakeAdminRepo) ListMixed(_ context.Context, status, kind string, page, size int) ([]repository.AdminRecordCard, int64, error) {
 	all := []repository.AdminRecordCard{
 		{Kind: "runway", ID: 1, Title: "Acne Studios Spring 2024", Subtitle: "Acne Studios", ImageCount: 12, Status: "published"},
@ -270,7 +280,7 @@ func TestBackstage(t *testing.T) {
 	m := jwt.NewManager("test-secret", 168)
 	auth := &fakeAuth{jwt: m}
 	brand := &fakeBrand{}
-	h := handler.NewBackstageHandler(auth, brand, &fakeArticle{}, &fakeStreet{}, &fakeReview{attachOK: true}, nil, &fakeAdminRepo{})
+	h := handler.NewBackstageHandler(auth, brand, &fakeArticle{}, &fakeStreet{}, &fakeReview{attachOK: true}, nil, &fakeAdminRepo{}, nil)
 	r := NewBackstage(BackstageOptions{Config: &config.Config{}, JWT: m, Backstage: h})

 	// 1) 登录页可访问
@ -478,7 +488,7 @@ func newReviewRouter(t *testing.T) (*gin.Engine, *fakeReview) {
 	auth := &fakeAuth{jwt: m}
 	brand := &fakeBrand{}
 	rev := &fakeReview{attachOK: true}
-	h := handler.NewBackstageHandler(auth, brand, &fakeArticle{}, &fakeStreet{}, rev, nil, &fakeAdminRepo{})
+	h := handler.NewBackstageHandler(auth, brand, &fakeArticle{}, &fakeStreet{}, rev, nil, &fakeAdminRepo{}, nil)
 	r := NewBackstage(BackstageOptions{Config: &config.Config{}, JWT: m, Backstage: h})
 	return r, rev
 }
--- a/internal/service/article_service.go
+++ b/internal/service/article_service.go
@ -300,6 +300,11 @@ func (s *articleService) DeleteImage(ctx context.Context, imageID uint32) error
 			log.Printf("[warn] 重算走秀 %d 去重失败（重复标记可能陈旧）: %v", runwayID, err)
 		}
 	}
+	// 跨文章清理：本图若是其它文章近重复的「源」，那些文章的 dup_of 需重算/清除
+	// （ReresolveRunwayDedup 只算本集内，不会碰其它文章指向本图的标记）。
+	if err := s.articles.ReresolveRunwayDupOfSources(ctx, []uint32{imageID}); err != nil {
+		log.Printf("[warn] 跨文章重算走秀图 %d 去重失败（重复标记可能陈旧）: %v", imageID, err)
+	}
 	return nil
 }

@ -329,6 +334,11 @@ func (s *articleService) SetDeleted(ctx context.Context, id uint32, deleted uint
 // 仍被其他图集引用的 key 不会被误删（内容寻址共享 key 安全）；入队失败仅告警，
 // 图集已下架、图片已软删，S4文件留待后续手动清理或周期性兜底扫描。
 func (s *articleService) PurgeGallery(ctx context.Context, id uint32) error {
+	// 下架前先取存活图片 id：删整篇后，其它文章中 dup_of 指向本篇图片的标记需跨文章重算/清除。
+	delIDs, err := s.articles.GetRunwayLiveImageIDs(ctx, id)
+	if err != nil {
+		return err
+	}
 	keys, err := s.articles.SoftDeleteRunwayImages(ctx, id)
 	if err != nil {
 		return err
@ -341,6 +351,12 @@ func (s *articleService) PurgeGallery(ctx context.Context, id uint32) error {
 			log.Printf("[warn] 下架图集 %d 入队清理S4失败（文件将暂留）: %v", id, err)
 		}
 	}
+	// 跨文章去重清理：删除整篇后，其它文章中 dup_of 指向本篇图片的标记重算/清除。
+	if len(delIDs) > 0 {
+		if err := s.articles.ReresolveRunwayDupOfSources(ctx, delIDs); err != nil {
+			log.Printf("[warn] 跨文章重算走秀 %d 去重失败（重复标记可能陈旧）: %v", id, err)
+		}
+	}
 	return nil
 }

--- a/internal/service/ingest_service.go
+++ b/internal/service/ingest_service.go
@ -38,6 +38,7 @@ type IngestService struct {
 	del        storage.Deleter            // 删除器（S4或本地，media_cleanup 真删用）
 	local      *storage.LocalUploader     // S4失败时的兜底落地
 	httpClient *http.Client
+	translate  *TranslateService // 标题中文翻译（可为 nil：测试/未启用时跳过自动补全）
 }

 // NewIngestService 创建入库服务。
@ -45,7 +46,7 @@ type IngestService struct {
 //	uploader: 主上传器（S4或本地）
 //	del:      删除器（S4或本地），用于 media_cleanup 真删S4/本地孤儿文件
 //	local:    本地兜底上传器（S4上传失败时回退，避免图片完全丢失）
-func NewIngestService(repo repository.IngestRepository, brandRepo repository.BrandRepository, media repository.MediaRepository, uploader storage.Uploader, del storage.Deleter, local *storage.LocalUploader, downloadProxy string) *IngestService {
+func NewIngestService(repo repository.IngestRepository, brandRepo repository.BrandRepository, media repository.MediaRepository, uploader storage.Uploader, del storage.Deleter, local *storage.LocalUploader, downloadProxy string, translateSvc *TranslateService) *IngestService {
 	// 下载代理：download_proxy（或 INGEST_DOWNLOAD_PROXY）非空时，下载客户端经该代理访问源站；
 	// 仅作用于图片下载，S4 上传走独立 s3 客户端、pgx 数据库连接不走 http，均不受影响。
 	// 留空回退 http.ProxyFromEnvironment（默认直连，仍可被系统 HTTP(S)_PROXY 影响）。
@ -74,6 +75,7 @@ func NewIngestService(repo repository.IngestRepository, brandRepo repository.Bra
 		uploader:  uploader,
 		del:       del,
 		local:     local,
+		translate: translateSvc,
 		// 图片下载是并发执行的（见 imageFetchConcurrency），连接池须匹配并发度：
 		// Go 默认 MaxIdleConnsPerHost=2，多余连接会在每轮下载时反复重建、白付 TLS 握手开销。
 		httpClient: &http.Client{
@ -372,6 +374,15 @@ func (s *IngestService) processRunway(ctx context.Context, job model.IngestJob,
 		ImageCount:     imageCount,
 		Status:         model.StatusPending,
 	}
+
+	// 入库自动补全中文标题：spider 未给 title_cn 时，用翻译服务按「记忆优先、规则兜底」推导；
+	// 已给则保留（绝不覆盖爬虫提供/已有的翻译）。翻译服务未注入（nil）时跳过。
+	if rw.TitleCn == "" && s.translate != nil {
+		if cn, terr := s.translate.SuggestTitleCn(ctx, rw.TitleEn); terr == nil {
+			rw.TitleCn = cn
+		}
+	}
+
 	for i := range images {
 		images[i].BrandID = brandID
 	}
@ -531,9 +542,19 @@ func (s *IngestService) processStreet(ctx context.Context, job model.IngestJob,

 	// 3) 直写正式表（status=pending）
 	writeStart := time.Now()
+
+	// 街拍入库自动补全中文标题（同 runway：spider 未给才补，且翻译服务需注入）。
+	titleCn := p.TitleCn
+	if titleCn == "" && s.translate != nil {
+		if cn, terr := s.translate.SuggestTitleCn(ctx, title); terr == nil {
+			titleCn = cn
+		}
+	}
+
 	snap := &model.StreetSnap{
 		JobID:      job.ID,
 		Title:      title, // 街拍单标题，爬虫优先填 title_en（已归一化，与查重口径一致）
+		TitleCn:    titleCn,
 		Year:       p.Year,
 		City:       p.City,
 		Cover:      cover,
--- a/internal/service/ingest_service_test.go
+++ b/internal/service/ingest_service_test.go
@ -44,7 +44,7 @@ func TestProcessMediaCleanup(t *testing.T) {
 		t.Fatalf("预置文件失败: %v", err)
 	}

-	svc := NewIngestService(fakeIngestRepo{}, nil, fakeMediaRepo{}, up, del, up, "")
+	svc := NewIngestService(fakeIngestRepo{}, nil, fakeMediaRepo{}, up, del, up, "", nil)
 	job := model.IngestJob{Kind: model.IngestKindMediaCleanup, Payload: `{"keys":["runway/abc.jpg"]}`}
 	svc.processMediaCleanup(context.Background(), job)

@ -60,7 +60,7 @@ func TestProcessMediaCleanupSkipsReferenced(t *testing.T) {
 	del := &countingDeleter{LocalUploader: up}

 	// 引用计数恒为 1（仍被其他图集使用），不应真删。
-	svc := NewIngestService(fakeIngestRepo{}, nil, referencedMediaRepo{}, up, del, up, "")
+	svc := NewIngestService(fakeIngestRepo{}, nil, referencedMediaRepo{}, up, del, up, "", nil)
 	job := model.IngestJob{Kind: model.IngestKindMediaCleanup, Payload: `{"keys":["runway/shared.jpg"]}`}
 	svc.processMediaCleanup(context.Background(), job)

--- a/internal/service/street_snap_service.go
+++ b/internal/service/street_snap_service.go
@ -401,6 +401,10 @@ func (s *streetSnapService) DeleteImage(ctx context.Context, imageID uint32) err
 			log.Printf("[warn] 重算街拍 %d 去重失败（重复标记可能陈旧）: %v", snapID, err)
 		}
 	}
+	// 跨文章清理：本图若是其它街拍近重复的「源」，那些街拍的 dup_of 需重算/清除。
+	if err := s.repo.ReresolveSnapDupOfSources(ctx, []uint32{imageID}); err != nil {
+		log.Printf("[warn] 跨文章重算街拍图 %d 去重失败（重复标记可能陈旧）: %v", imageID, err)
+	}
 	return nil
 }

@ -425,6 +429,11 @@ func (s *streetSnapService) SetDeleted(ctx context.Context, id uint32, deleted u
 // PurgeGallery 下架街拍并异步清理S4孤儿图：逻辑同 articleService.PurgeGallery，
 // 仅仓储调用换成街拍的 SoftDeleteSnapImages / SetSnapDeleted。
 func (s *streetSnapService) PurgeGallery(ctx context.Context, id uint32) error {
+	// 下架前先取存活图片 id：删整篇后，其它街拍中 dup_of 指向本篇图片的标记需跨文章重算/清除。
+	delIDs, err := s.repo.GetSnapLiveImageIDs(ctx, id)
+	if err != nil {
+		return err
+	}
 	keys, err := s.repo.SoftDeleteSnapImages(ctx, id)
 	if err != nil {
 		return err
@ -437,5 +446,11 @@ func (s *streetSnapService) PurgeGallery(ctx context.Context, id uint32) error {
 			log.Printf("[warn] 下架街拍 %d 入队清理S4失败（文件将暂留）: %v", id, err)
 		}
 	}
+	// 跨文章去重清理：删除整篇后，其它街拍中 dup_of 指向本篇图片的标记重算/清除。
+	if len(delIDs) > 0 {
+		if err := s.repo.ReresolveSnapDupOfSources(ctx, delIDs); err != nil {
+			log.Printf("[warn] 跨文章重算街拍 %d 去重失败（重复标记可能陈旧）: %v", id, err)
+		}
+	}
 	return nil
 }
--- a/internal/service/translate.go
+++ b/internal/service/translate.go
@ -0,0 +1,224 @@
+package service
+
+import (
+	"context"
+	"regexp"
+	"sort"
+	"strings"
+	"sync"
+
+	"fashionapi/internal/repository"
+)
+
+// TranslateService 标题中英文翻译：规则兜底 + 人工记忆优先。
+//
+// 设计目标：标题高度固定（品牌/年份/季节/系列/城市），绝大多数可规则翻译；
+// 人工在后台纠正过的中文标题写入记忆表，之后无论入库还是编辑都优先命中，永久精确。
+// 入库只读取记忆（不写入），避免把规则猜测的半成品固化成「真理」。
+type TranslateService struct {
+	brandRepo repository.BrandRepository
+	memRepo   repository.TranslateRepository
+
+	brandMu   sync.Mutex
+	brandOnce bool
+	brandMap  map[string]string // name_en(小写) -> name_cn
+}
+
+// NewTranslateService 创建翻译服务。brandRepo / memRepo 任一为 nil 时，对应能力自动降级
+// （品牌映射为空 / 记忆不命中），仅影响翻译覆盖率，不会 panic。
+func NewTranslateService(brandRepo repository.BrandRepository, memRepo repository.TranslateRepository) *TranslateService {
+	return &TranslateService{brandRepo: brandRepo, memRepo: memRepo}
+}
+
+// SuggestTitleCn 给出 title_en 的中文翻译：记忆优先，规则兜底。
+// 规则无法完整翻译（存在未覆盖的英文词）时返回空串，绝不写半吊子脏数据。
+func (s *TranslateService) SuggestTitleCn(ctx context.Context, titleEn string) (string, error) {
+	en := strings.TrimSpace(titleEn)
+	if en == "" {
+		return "", nil
+	}
+	if s.memRepo != nil {
+		if cn, ok, err := s.memRepo.GetTitleCnMemory(ctx, en); err != nil {
+			return "", err
+		} else if ok && cn != "" {
+			return cn, nil
+		}
+	}
+	cn, _ := s.ruleTranslate(en)
+	return cn, nil
+}
+
+// Remember 记录一条「英文标题 → 中文标题」的人工映射（幂等 upsert）。
+func (s *TranslateService) Remember(ctx context.Context, titleEn, titleCn string) error {
+	en := strings.TrimSpace(titleEn)
+	cn := strings.TrimSpace(titleCn)
+	if en == "" || cn == "" || s.memRepo == nil {
+		return nil
+	}
+	return s.memRepo.UpsertTitleCnMemory(ctx, en, cn)
+}
+
+// ── 规则翻译 ───────────────────────────────────────────────────────────────────
+
+// repItem 静态替换项：英文短语 → 中文。
+type repItem struct {
+	pat string
+	cn  string
+}
+
+// staticPatterns 固定映射。组合词（Spring Summer）须排在单词（Spring）之前，
+// 由 init 统一按长度降序编译，保证优先匹配。
+var staticPatterns = []repItem{
+	// 街拍短语
+	{"Fashion Week", "时装周"},
+	{"Street Style", "街拍"},
+	{"Street Snap", "街拍"},
+	{"Street Snaps", "街拍"},
+	// 季节（组合在前）
+	{"Spring Summer", "春夏"},
+	{"Fall Winter", "秋冬"},
+	{"Autumn Winter", "秋冬"},
+	{"Pre-Spring", "早春"},
+	{"Pre-Fall", "早秋"},
+	{"Spring", "春夏"},
+	{"Summer", "盛夏"},
+	{"Autumn", "秋冬"},
+	{"Winter", "秋冬"},
+	{"Fall", "秋冬"},
+	// 系列 / 品类
+	{"Ready-to-Wear", "成衣"},
+	{"Ready To Wear", "成衣"},
+	{"Couture", "高级定制"},
+	{"Resort", "度假"},
+	{"Menswear", "男装"},
+	{"Womenswear", "女装"},
+	{"Mens", "男装"},
+	{"Womens", "女装"},
+	{"RTW", "成衣"},
+	// 城市
+	{"New York", "纽约"},
+	{"Hong Kong", "香港"},
+	{"Los Angeles", "洛杉矶"},
+	{"San Francisco", "旧金山"},
+	{"London", "伦敦"},
+	{"Paris", "巴黎"},
+	{"Milan", "米兰"},
+	{"Tokyo", "东京"},
+	{"Seoul", "首尔"},
+	{"Shanghai", "上海"},
+	{"Beijing", "北京"},
+	{"Berlin", "柏林"},
+	{"Copenhagen", "哥本哈根"},
+	{"Florence", "佛罗伦萨"},
+	{"Madrid", "马德里"},
+	{"Rome", "罗马"},
+	{"Sydney", "悉尼"},
+	{"Toronto", "多伦多"},
+	{"Chicago", "芝加哥"},
+}
+
+type compiledRep struct {
+	re *regexp.Regexp
+	cn string
+}
+
+// staticReplacements 编译后的静态替换表（按短语长度降序）。
+var staticReplacements []compiledRep
+
+func init() {
+	sorted := append([]repItem{}, staticPatterns...)
+	sort.Slice(sorted, func(i, j int) bool { return len(sorted[i].pat) > len(sorted[j].pat) })
+	for _, it := range sorted {
+		staticReplacements = append(staticReplacements, compiledRep{
+			re: regexp.MustCompile(`(?i)\b` + regexp.QuoteMeta(it.pat) + `\b`),
+			cn: it.cn,
+		})
+	}
+}
+
+// 非中/非数/非字母/非空白的标点一律清掉（避免替换后遗留孤标点符号）。
+var nonWordRe = regexp.MustCompile(`[^\p{Han}\p{Hangul}\p{Hiragana}\p{Katakana}0-9A-Za-z\s]`)
+
+// 仍含 ASCII 字母 ⇒ 存在未覆盖的英文词 ⇒ 未完整翻译。
+var asciiLetterRe = regexp.MustCompile(`[A-Za-z]+`)
+
+// ruleTranslate 翻译服务的规则分支：直接用共享的 RuleTranslate（注入已加载的品牌映射）。
+func (s *TranslateService) ruleTranslate(en string) (string, bool) {
+	s.ensureBrandMap()
+	return RuleTranslate(en, s.brandMap)
+}
+
+// RuleTranslate 纯规则翻译（不含记忆）：brandCN 为 name_en(小写)→name_cn 映射。
+// 品牌名按长度降序、词边界（\b）匹配，避免子串误替（如 brand "On" 误伤 "fashion"）。
+// 所有英文词都被覆盖才成功，否则返回 ("", false) —— 绝不写半吊子脏数据。
+//
+// 导出供一次性脚本（dbtool filltitlecn）复用，避免规则逻辑重复实现。
+func RuleTranslate(en string, brandCN map[string]string) (string, bool) {
+	if strings.TrimSpace(en) == "" {
+		return "", false
+	}
+	lower := strings.ToLower(en)
+	for _, r := range staticReplacements {
+		lower = r.re.ReplaceAllString(lower, r.cn)
+	}
+	if len(brandCN) > 0 {
+		keys := make([]string, 0, len(brandCN))
+		for k := range brandCN {
+			keys = append(keys, k)
+		}
+		sort.Slice(keys, func(i, j int) bool { return len(keys[i]) > len(keys[j]) })
+		for _, k := range keys {
+			cn := brandCN[k]
+			if cn == "" {
+				continue
+			}
+			if re := brandRegex(k); re != nil {
+				lower = re.ReplaceAllString(lower, cn)
+			}
+		}
+	}
+	clean := nonWordRe.ReplaceAllString(lower, " ")
+	if asciiLetterRe.MatchString(clean) {
+		return "", false
+	}
+	return strings.Join(strings.Fields(clean), " "), true
+}
+
+// brandReCache 缓存品牌名编译后的正则，避免每次翻译重复编译（ingest 高频场景）。
+var brandReCache sync.Map // en(lower) -> *regexp.Regexp
+
+func brandRegex(en string) *regexp.Regexp {
+	if v, ok := brandReCache.Load(en); ok {
+		return v.(*regexp.Regexp)
+	}
+	re := regexp.MustCompile(`(?i)\b` + regexp.QuoteMeta(en) + `\b`)
+	brandReCache.Store(en, re)
+	return re
+}
+
+// ensureBrandMap 懒加载品牌「英文→中文」映射（按名称长度降序 + 词边界正则），并发安全。
+func (s *TranslateService) ensureBrandMap() {
+	s.brandMu.Lock()
+	defer s.brandMu.Unlock()
+	if s.brandOnce {
+		return
+	}
+	s.brandOnce = true
+	if s.brandRepo == nil {
+		s.brandMap = map[string]string{}
+		return
+	}
+	brands, err := s.brandRepo.CrawlBrands(context.Background(), 0)
+	if err != nil || len(brands) == 0 {
+		s.brandMap = map[string]string{}
+		return
+	}
+	m := make(map[string]string, len(brands))
+	for _, b := range brands {
+		if b.NameEn == "" {
+			continue
+		}
+		m[strings.ToLower(b.NameEn)] = strings.TrimSpace(b.NameCn)
+	}
+	s.brandMap = m
+}
--- a/internal/service/translate_test.go
+++ b/internal/service/translate_test.go
@ -0,0 +1,89 @@
+package service
+
+import (
+	"context"
+	"testing"
+
+	"fashionapi/internal/model"
+	"fashionapi/internal/repository"
+)
+
+type fakeTranslateBrandRepo struct{ repository.BrandRepository }
+
+func (fakeTranslateBrandRepo) CrawlBrands(ctx context.Context, brandID uint32) ([]model.Brand, error) {
+	return []model.Brand{
+		{NameEn: "Chanel", NameCn: "香奈儿"},
+		{NameEn: "Acne Studios", NameCn: "阿尼亚"},
+	}, nil
+}
+
+type fakeTranslateMem struct {
+	m map[string]string
+	repository.TranslateRepository
+}
+
+func (f *fakeTranslateMem) GetTitleCnMemory(ctx context.Context, titleEn string) (string, bool, error) {
+	v, ok := f.m[titleEn]
+	return v, ok, nil
+}
+
+func (f *fakeTranslateMem) UpsertTitleCnMemory(ctx context.Context, titleEn, titleCn string) error {
+	if f.m == nil {
+		f.m = map[string]string{}
+	}
+	f.m[titleEn] = titleCn
+	return nil
+}
+
+func newTranslateServiceForTest() *TranslateService {
+	return &TranslateService{brandRepo: fakeTranslateBrandRepo{}, memRepo: &fakeTranslateMem{m: map[string]string{}}}
+}
+
+func TestRuleTranslate(t *testing.T) {
+	brandCN := map[string]string{"chanel": "香奈儿", "acne studios": "阿尼亚"}
+	cases := []struct {
+		en   string
+		want string
+		ok   bool
+	}{
+		{"Spring 2024 Ready-to-Wear", "春夏 2024 成衣", true},
+		{"London Fashion Week Street Style", "伦敦 时装周 街拍", true},
+		{"Chanel Spring 2024 Ready-to-Wear", "香奈儿 春夏 2024 成衣", true},
+		{"Acne Studios Fall 2023 Couture", "阿尼亚 秋冬 2023 高级定制", true},
+		// 含未知品牌 → 未完整翻译 → 失败（不写脏数据）
+		{"UnknownBrand Spring 2024 Ready-to-Wear", "", false},
+		{"", "", false},
+	}
+	for _, c := range cases {
+		got, ok := RuleTranslate(c.en, brandCN)
+		if ok != c.ok || got != c.want {
+			t.Errorf("RuleTranslate(%q) = (%q, %v), want (%q, %v)", c.en, got, ok, c.want, c.ok)
+		}
+	}
+}
+
+func TestSuggestTitleCnMemory(t *testing.T) {
+	svc := newTranslateServiceForTest()
+	ctx := context.Background()
+	if err := svc.Remember(ctx, "Foobar Fall 2023 Couture", "自定义中文"); err != nil {
+		t.Fatal(err)
+	}
+	got, err := svc.SuggestTitleCn(ctx, "Foobar Fall 2023 Couture")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != "自定义中文" {
+		t.Fatalf("记忆未优先命中: got %q", got)
+	}
+}
+
+func TestSuggestTitleCnRule(t *testing.T) {
+	svc := newTranslateServiceForTest()
+	got, err := svc.SuggestTitleCn(context.Background(), "Chanel Spring 2024 Ready-to-Wear")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != "香奈儿 春夏 2024 成衣" {
+		t.Fatalf("规则翻译不符: got %q", got)
+	}
+}