From d908036621d116b79c67d2495b2e28d605e82c0b Mon Sep 17 00:00:00 2001
From: toom1996 <23cm.cn@gmail.com>
Date: Tue, 22 Sep 2026 11:12:23 +0800
Subject: [PATCH] update

---
 .../2026-09-21-01-street-main-detail.sql      |   21 +
 .../2026-09-21-02-duplicate-review.sql        |   49 +
 ...026-09-21-03-ingest-source-idempotency.sql |   27 +
 .../plans/2026-09-21-street-main-detail.md    | 1446 +++++++++++++++++
 .../2026-09-20-ingest-idempotency-design.md   |    9 +-
 .../2026-09-21-duplicate-review-design.md     |    6 +-
 6 files changed, 1554 insertions(+), 4 deletions(-)
 create mode 100644 db/migrations/2026-09-21-01-street-main-detail.sql
 create mode 100644 db/migrations/2026-09-21-02-duplicate-review.sql
 create mode 100644 db/migrations/2026-09-21-03-ingest-source-idempotency.sql
 create mode 100644 docs/superpowers/plans/2026-09-21-street-main-detail.md

diff --git a/db/migrations/2026-09-21-01-street-main-detail.sql b/db/migrations/2026-09-21-01-street-main-detail.sql
new file mode 100644
index 0000000..1c47581
--- /dev/null
+++ b/db/migrations/2026-09-21-01-street-main-detail.sql
@@ -0,0 +1,21 @@
+-- 2026-09-21-01 街拍主副图：草稿表 / 正式表的图片表各加两列。
+--
+-- 对应规格：docs/superpowers/specs/2026-09-21-street-main-detail-design.md §3.1
+--   is_detail        0=主图 1=副图
+--   parent_image_id  副图指向所属主图的「行 id」；主图为 0
+--   （存行 id 而非序号：序号会因重排 / 插入 / 删除而失效）
+--
+-- 幂等：全部 ADD COLUMN IF NOT EXISTS，可重复执行。
+-- 存量行为 0/0，即「全部按主图渲染」，无需数据迁移。
+--
+-- 应用后请重新导出结构，否则目标库拿不到新列：
+--   ./bin/dbtool dump -clean -out db/backups/db_dump.sql
+--
+-- 说明：规格未给 parent_image_id 建索引。图片表当前规模为千行级（street_snap_draft_images
+-- 1052 行），按 (draft_id) 过滤走顺序扫描即可；若日后量级变大需要，再按读侧实际查询补索引。
+
+ALTER TABLE street_snap_draft_images ADD COLUMN IF NOT EXISTS is_detail       smallint NOT NULL DEFAULT 0;
+ALTER TABLE street_snap_draft_images ADD COLUMN IF NOT EXISTS parent_image_id integer  NOT NULL DEFAULT 0;
+
+ALTER TABLE street_snap_images       ADD COLUMN IF NOT EXISTS is_detail       smallint NOT NULL DEFAULT 0;
+ALTER TABLE street_snap_images       ADD COLUMN IF NOT EXISTS parent_image_id integer  NOT NULL DEFAULT 0;
diff --git a/db/migrations/2026-09-21-02-duplicate-review.sql b/db/migrations/2026-09-21-02-duplicate-review.sql
new file mode 100644
index 0000000..3c3b4ba
--- /dev/null
+++ b/db/migrations/2026-09-21-02-duplicate-review.sql
@@ -0,0 +1,49 @@
+-- 2026-09-21-02 重复检测与审核展示：新建 image_duplicates 表 + 街拍正式表按文章做键。
+--
+-- 对应规格：docs/superpowers/specs/2026-09-21-duplicate-review-design.md §3.1 / §3.7
+--
+-- 幂等：CREATE TABLE / CREATE INDEX 全带 IF NOT EXISTS，ADD COLUMN 带 IF NOT EXISTS，
+-- 可重复执行。
+--
+-- 应用后请重新导出结构：
+--   ./bin/dbtool dump -clean -out db/backups/db_dump.sql
+
+-- ---------------------------------------------------------------------------
+-- ① 重复图对表（读时预计算并落库，替代不可反查的 is_duplicate / dup_of 两列）
+-- ---------------------------------------------------------------------------
+-- kind / owner_kind 等字符串列控制长度而不做 CHECK 约束：与项目既有表风格一致
+-- （brand_runway_drafts.status 等也是裸 varchar），避免新增约束带来的迁移负担。
+CREATE TABLE IF NOT EXISTS image_duplicates (
+  id              BIGSERIAL    PRIMARY KEY,
+  kind            varchar(16)  NOT NULL,        -- runway | street
+  -- 本方（「这张图」）
+  image_id        integer      NOT NULL,        -- 图片行 id
+  owner_kind      varchar(8)   NOT NULL,        -- draft | official
+  owner_id        integer      NOT NULL,        -- 草稿 id 或正式表主键
+  -- 对手（「和它重复的那张」）
+  peer_image_id   integer      NOT NULL,
+  peer_owner_kind varchar(8)   NOT NULL,
+  peer_owner_id   integer      NOT NULL,
+  created_at      integer      NOT NULL DEFAULT 0
+);
+
+-- 唯一索引：保证重复配对计算幂等（写入侧用 ON CONFLICT ... DO NOTHING）
+CREATE UNIQUE INDEX IF NOT EXISTS uq_image_dups_pair
+  ON image_duplicates (kind, owner_kind, image_id, peer_owner_kind, peer_image_id);
+
+-- 辅助索引：读侧按草稿 / 专辑批量取数（审核详情页）
+CREATE INDEX IF NOT EXISTS idx_image_dups_owner
+  ON image_duplicates (kind, owner_kind, owner_id);
+
+-- ---------------------------------------------------------------------------
+-- ② 街拍正式表：新增 source / source_url，供「一篇文章一张专辑」的实体键使用
+-- ---------------------------------------------------------------------------
+-- 用 not null default '' 而不是可空：NULL 在唯一索引里不参与比较，
+-- 会造成「同键可重复插入」的漏洞。
+ALTER TABLE street_snaps ADD COLUMN IF NOT EXISTS source     varchar(32)  NOT NULL DEFAULT '';
+ALTER TABLE street_snaps ADD COLUMN IF NOT EXISTS source_url varchar(512) NOT NULL DEFAULT '';
+
+-- 必须是**部分**索引：存量行 source_url 为空串，全量唯一索引会因大量 ('','') 冲突
+-- 而建索引失败。
+CREATE UNIQUE INDEX IF NOT EXISTS uq_ss_source
+  ON street_snaps (source, source_url) WHERE source_url <> '';
diff --git a/db/migrations/2026-09-21-03-ingest-source-idempotency.sql b/db/migrations/2026-09-21-03-ingest-source-idempotency.sql
new file mode 100644
index 0000000..2076a25
--- /dev/null
+++ b/db/migrations/2026-09-21-03-ingest-source-idempotency.sql
@@ -0,0 +1,27 @@
+-- 2026-09-21-03 来源幂等：两张草稿表新增 source / source_url，并建部分唯一索引。
+--
+-- 对应规格：docs/superpowers/specs/2026-09-20-ingest-idempotency-design.md §3.1–3.2
+--
+-- 幂等：ADD COLUMN / CREATE INDEX 全带 IF NOT EXISTS，可重复执行。
+--
+-- 应用后请重新导出结构：
+--   ./bin/dbtool dump -clean -out db/backups/db_dump.sql
+--
+-- 注意：同规格 §3.6（month 列与「实体键并入 month」）**已作废**——
+-- 由 docs/superpowers/specs/2026-09-21-duplicate-review-design.md §3.7 取代
+-- （街拍实体键改为 (source, source_url)，不再按月区分）。故本脚本**不建 month 列**。
+
+-- 用 not null default '' 而不是可空：NULL 在唯一索引里不参与比较，
+-- 会造成「同键可重复插入」的漏洞。
+ALTER TABLE brand_runway_drafts ADD COLUMN IF NOT EXISTS source     varchar(32)  NOT NULL DEFAULT '';
+ALTER TABLE brand_runway_drafts ADD COLUMN IF NOT EXISTS source_url varchar(512) NOT NULL DEFAULT '';
+
+ALTER TABLE street_snap_drafts  ADD COLUMN IF NOT EXISTS source     varchar(32)  NOT NULL DEFAULT '';
+ALTER TABLE street_snap_drafts  ADD COLUMN IF NOT EXISTS source_url varchar(512) NOT NULL DEFAULT '';
+
+-- 两个部分唯一索引（全量唯一索引会因存量大量 ('','') 冲突而建索引失败）。
+-- 向后兼容：老爬虫不上送 source_url 时该列为空串，自动被索引豁免 —— 行为与改动前一致。
+CREATE UNIQUE INDEX IF NOT EXISTS uq_br_draft_source
+    ON brand_runway_drafts (source, source_url) WHERE source_url <> '';
+CREATE UNIQUE INDEX IF NOT EXISTS uq_ss_draft_source
+    ON street_snap_drafts  (source, source_url) WHERE source_url <> '';
diff --git a/docs/superpowers/plans/2026-09-21-street-main-detail.md b/docs/superpowers/plans/2026-09-21-street-main-detail.md
new file mode 100644
index 0000000..fff010e
--- /dev/null
+++ b/docs/superpowers/plans/2026-09-21-street-main-detail.md
@@ -0,0 +1,1446 @@
+# 街拍主副图 实现计划
+
+> **面向 AI 代理的工作者：** 必需子技能：使用 subagent-driven-development（推荐）或 executing-plans 逐任务实现此计划。步骤使用复选框（`- [ ]`）语法来跟踪进度。
+
+**目标：** 给街拍图集加「主图 / 副图」分组——审核页人工指定，详情页按组折叠，公开 API 保守扩展。
+
+**架构：** 纯人工分组，不引入算法。数据层在两张街拍图片表上加 `is_detail` + `parent_image_id`（**列已由迁移脚本加好，本计划不改 DB**）；读侧把扁平图片列表「按主副关系重排」成组视图，父引用失效时容错按主图渲染。后台沿用现有「零 JS 同步表单 POST + 302」风格，当前主图由 URL 查询参数 `?main=<imgID>` 承载。
+
+**技术栈：** Go 1.2x + Gin + GORM + PostgreSQL；后台为服务端渲染（内联 `html/template` 字符串常量，无前端框架）。
+
+**规格：** `docs/superpowers/specs/2026-09-21-street-main-detail-design.md`
+
+## 全局约束
+
+- **零 JS**：后台不得引入 `<script>` / `fetch`；交互一律同步表单 POST，成功返回 **302**。`onclick="return confirm(...)"` 仅作确认，允许保留。
+- **当前主图用 URL 查询参数承载**：`?main=<imgID>`；页面顶部渲染常驻提示条，刷新/后退/书签均保持。
+- **不变量**：`is_detail = 1` 的行，`parent_image_id` 必须指向**同一 owner 内**一张 `is_detail = 0` 的行。
+- **读侧容错**：父行不存在或已被软删时，该图**按主图渲染**，不隐藏、不报错、不丢图。
+- **公开 API 保守扩展**：`PublicStreetSnapDetail.Images`（扁平）**保持原样不变**，**新增** `Groups` 字段；`PublicStreetSnap`（列表）**不动**。
+- **`image_count` 语义不变**：仍计全部图（不是只算主图）。
+- **组序号不落库**：由读时按 `sort_order` 顺序推导（主图顺序即组序）。
+- **已被否决的做法**（不要实现）：算法自动分组；拖拽交互；修改 `image_count` 语义；给 runway 侧加同类字段。
+- **DB 前置条件**：`street_snap_draft_images` / `street_snap_images` 的 `is_detail`、`parent_image_id` 两列已由 `db/migrations/2026-09-21-01-street-main-detail.sql` 加好并应用，且已重导出进 `db/backups/db_dump.sql`。**本计划任何一步都不应再写 DDL**；若集成测试报 `column "is_detail" does not exist`，说明库未就绪，先重灌 dump（`dbtool import -clean -in db/backups/db_dump.sql`）。
+- **排序口径**：街拍图片顺序一律由 `ORDER BY sort_order ASC, id ASC` 决定（`sort_order` 越小越靠前）。本功能**不改变**任何写入时的 `sort_order` 赋值逻辑。
+- **后台错误页**：参数无效 / 操作失败一律 `renderHTML(c, http.StatusXxx, tplError, gin.H{"Error": "..."})`，不要 `c.JSON`。
+- **HTML 表单不得嵌套**：`<form>` 内不能包含另一个 `<form>`（浏览器只会认外层）。每张图的「并入 / 拆出 / 删除 / 并入上一张」按钮都是各自独立的 `<form>`，并列放在 `.acts` 容器里，绝不能用一个外层表单把它们包住。
+
+---
+
+## 文件结构
+
+| 文件 | 职责 | 动作 |
+| --- | --- | --- |
+| `internal/model/street_snap_draft.go` | 草稿图片结构 | 修改：`StreetSnapDraftImage` 加 `IsDetail` / `ParentImageID` |
+| `internal/model/street_snap.go` | 正式图片结构 | 修改：`StreetSnapImage` 加 `IsDetail` / `ParentImageID` |
+| `internal/repository/review_repository.go` | 草稿读写 + 晋升 | 修改：接口加 3 个分组方法 + `SaveStreetSnapFromDraft` 重建父引用 |
+| `internal/service/review_service.go` | 审核业务逻辑 | 修改：`DraftImageRef` 加分组字段；新增 `DraftImageGroup`；`DraftDetailView` 加 `MainID`+`Groups`；接口加 3 个方法；实现；新增错误 |
+| `internal/router/backstage.go` | 后台路由 | 修改：加 3 条路由 |
+| `internal/handler/backstage_handler.go` | 后台页面渲染与表单 | 修改：加 3 个 handler；改 `tplReviewDetail` 模板 |
+| `internal/handler/backstage_handler_test.go` | 模板解析冒烟 | 修改：既有解析测试自动覆盖新模板常量（确认仍通过） |
+| `internal/router/backstage_test.go` | 路由冒烟 | 修改：加 `fakeReview`；断言 3 条新路由的 302 与入参；断言分组渲染 |
+| `internal/dto/street_snap.go` | 公开响应结构 | 修改：新增 `PublicStreetSnapGroup` + `Groups` 字段 |
+| `internal/service/street_snap_service.go` | 公开详情组装 | 修改：`Detail` 增加 `Groups` 组装 |
+| `internal/repository/street_main_detail_integration_test.go` | 仓储层集成测试 | 创建 |
+| `internal/service/review_street_group_test.go` | service 层纯单测 | 创建 |
+| `internal/service/street_snap_group_test.go` | 公开 API 分组纯单测 | 创建 |
+
+**为什么把「并入一个自带副图的主图」放在仓储层**：它是数据不变量问题（不能出现「副图的副图」），必须和写入同一个事务；放在 service 层会拆成两次写、失去原子性。
+
+---
+
+## 实现裁决（规格未明确、由本计划定的三处）
+
+1. **并入一张自带副图的主图时**：把它原有的副图**一并改挂到新主图**（而不是拒绝、也不是留成孤儿）。理由：保留不变量，且「把这一组并到那组」符合直觉。
+2. **「并入上一张」的目标**：以「上一行所属组的主图」为目标；若上一行本身是主图，它就是目标。这样连续并入会**链式归并**到同一个主图。
+3. **拆出（detach）对主图调用**：幂等成功、无副作用（不报错），避免用户重复点击时看到错误页。
+
+**关于「批量勾选并入」的交互取舍**：规格 §3.2 提到「勾选多张 + 主图 → 合并」。但零 JS 下「一个外层表单包住所有图、里面再放各自的拆出/删除子表单」会产生**表单嵌套**（浏览器不支持）。本计划改用**逐张「并入当前主图」按钮**（每张图一个小表单，提交自身 `img`），既满足零 JS 又无嵌套；「批量」退化为多次点击，数据规模（街拍每篇 8–30 图）下完全可接受。若日后想要真批量，再开一个位于 grid 之外的独立表单。
+
+---
+
+## 任务 1：草稿图分组写入（模型字段 + 仓储三方法）
+
+**文件：**
+- 修改：`internal/model/street_snap_draft.go`（`StreetSnapDraftImage` 结构体末尾）
+- 修改：`internal/repository/review_repository.go:18-48`（接口）、文件末尾（实现）
+- 创建：`internal/repository/street_main_detail_integration_test.go`
+
+**接口新增（`review_repository.go` 的 `ReviewRepository` 内，紧接 `SoftDeleteStreetDraftImage` 那两行之后）：**
+
+```go
+	// AttachStreetDraftImages 把 imgIDs 变成 mainImgID 的副图（批量并入）。
+	// mainImgID 必须属于同一草稿、未被软删、且自身是主图（is_detail=0），否则返回 ErrInvalidImageGroup。
+	// 若某个被并入的图自身还带着副图，则它原有的副图一并改挂到 mainImgID ——
+	// 避免出现「副图的副图」破坏不变量（见本计划「实现裁决」第 1 条）。
+	// 幂等：已是 mainImgID 副图的行重复并入不报错。
+	AttachStreetDraftImages(ctx context.Context, draftID, mainImgID uint32, imgIDs []uint32) error
+	// AttachPrevStreetDraftImage 把 imgID 并入「同草稿内 sort_order 紧邻的前一行所属组的主图」。
+	// imgID 是首行（没有上一行）时返回 ErrNotFound。
+	AttachPrevStreetDraftImage(ctx context.Context, draftID, imgID uint32) error
+	// DetachStreetDraftImage 把副图恢复为主图（is_detail=0, parent_image_id=0）。
+	// 对主图调用是幂等成功（无副作用）。
+	DetachStreetDraftImage(ctx context.Context, draftID, imgID uint32) error
+```
+
+**新错误哨兵（`review_repository.go` 顶部 `var` 区，与既有 `ErrNotFound` 放一起）：**
+
+```go
+// ErrInvalidImageGroup 主副图分组操作不合法：主图不存在 / 不属于该草稿 / 自身不是主图 / 空集合。
+var ErrInvalidImageGroup = errors.New("invalid image group")
+```
+
+**模型新增（`internal/model/street_snap_draft.go`，`StreetSnapDraftImage` 内 `DupOf` 之后）：**
+
+```go
+	// 主副图分组（列由 db/migrations/2026-09-21-01-street-main-detail.sql 添加）：
+	// is_detail=0 为主图（parent_image_id=0）；=1 为副图，parent_image_id 指向同草稿内主图的行 id。
+	// 存行 id 而非序号：序号会因重排 / 插入 / 删除而失效。
+	IsDetail      uint8  `gorm:"column:is_detail;not null;default:0" json:"is_detail"`
+	ParentImageID uint32 `gorm:"column:parent_image_id;not null;default:0" json:"parent_image_id"`
+```
+
+- [ ] **步骤 1：编写失败的集成测试**
+
+创建 `internal/repository/street_main_detail_integration_test.go`：
+
+```go
+//go:build integration
+
+// 集成测试：街拍草稿主副图分组需要真实 PostgreSQL。
+//
+// 运行方式（先起库并确保结构已就绪，见 README「数据库」一节）：
+//
+//	docker compose -f scripts/pgvector/docker-compose.yml up -d
+//	go test -tags integration ./internal/repository/ -run TestStreetMainDetail -v
+//
+// 默认 `go test ./...` 不会编译本文件（build tag 隔离）。
+package repository
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"fashionapi/internal/model"
+)
+
+// seedStreetDraft 插入一条街拍草稿并返回其 id。
+func seedStreetDraft(t *testing.T, repo ReviewRepository) uint32 {
+	t.Helper()
+	ctx := context.Background()
+	db := repo.(*reviewRepository).db
+	d := model.StreetSnapDraft{Title: "主副图测试", Year: 2026, City: "TestCity", Status: model.DraftStatusPending}
+	if err := db.WithContext(ctx).Create(&d).Error; err != nil {
+		t.Fatalf("插入草稿失败: %v", err)
+	}
+	t.Cleanup(func() {
+		db.Exec("DELETE FROM street_snap_draft_images WHERE draft_id = ?", d.ID)
+		db.Exec("DELETE FROM street_snap_drafts WHERE id = ?", d.ID)
+	})
+	return d.ID
+}
+
+// seedStreetDraftImage 插入一张草稿图并返回其行 id。
+func seedStreetDraftImage(t *testing.T, repo ReviewRepository, draftID uint32, name string, order uint32) uint32 {
+	t.Helper()
+	img := model.StreetSnapDraftImage{DraftID: draftID, Image: name + ".jpg", Name: name, SortOrder: order}
+	if err := repo.(*reviewRepository).db.WithContext(context.Background()).Create(&img).Error; err != nil {
+		t.Fatalf("插入草稿图失败: %v", err)
+	}
+	return img.ID
+}
+
+// reloadStreetImages 取草稿的全部图（按 sort_order, id 升序），便于断言。
+func reloadStreetImages(t *testing.T, repo ReviewRepository, draftID uint32) []model.StreetSnapDraftImage {
+	t.Helper()
+	imgs, err := repo.StreetDraftImages(context.Background(), draftID)
+	if err != nil {
+		t.Fatalf("读草稿图失败: %v", err)
+	}
+	return imgs
+}
+
+// TestStreetMainDetail 覆盖批量并入 / 并入上一张 / 拆出 / 跨草稿拦截四条主线。
+func TestStreetMainDetail(t *testing.T) {
+	repo := NewReviewRepository(testDB(t))
+	ctx := context.Background()
+
+	draftID := seedStreetDraft(t, repo)
+	m1 := seedStreetDraftImage(t, repo, draftID, "a", 1)
+	d2 := seedStreetDraftImage(t, repo, draftID, "b", 2)
+	d3 := seedStreetDraftImage(t, repo, draftID, "c", 3)
+
+	if err := repo.AttachStreetDraftImages(ctx, draftID, m1, []uint32{d2, d3}); err != nil {
+		t.Fatalf("并入失败: %v", err)
+	}
+	for _, im := range reloadStreetImages(t, repo, draftID) {
+		switch im.ID {
+		case m1:
+			if im.IsDetail != 0 || im.ParentImageID != 0 {
+				t.Fatalf("主图应保持 is_detail=0/parent=0，实际 %d/%d", im.IsDetail, im.ParentImageID)
+			}
+		case d2, d3:
+			if im.IsDetail != 1 || im.ParentImageID != m1 {
+				t.Fatalf("副图应指向 %d，实际 is_detail=%d parent=%d", m1, im.IsDetail, im.ParentImageID)
+			}
+		}
+	}
+
+	// 幂等：重复并入同一批不报错，结果不变。
+	if err := repo.AttachStreetDraftImages(ctx, draftID, m1, []uint32{d2, d3}); err != nil {
+		t.Fatalf("重复并入应幂等，实际报错: %v", err)
+	}
+
+	// 传入主图自身：调用方过滤掉的语义由仓储兜住（id <> main 条件），不报错也不改动主图。
+	if err := repo.AttachStreetDraftImages(ctx, draftID, m1, []uint32{m1}); err != nil {
+		t.Fatalf("并入集合含主图自身应被忽略而非报错: %v", err)
+	}
+	for _, im := range reloadStreetImages(t, repo, draftID) {
+		if im.ID == m1 && (im.IsDetail != 0 || im.ParentImageID != 0) {
+			t.Fatalf("主图被自身并入后不应变化")
+		}
+	}
+
+	// 拆出：把 d3 恢复为主图。
+	if err := repo.DetachStreetDraftImage(ctx, draftID, d3); err != nil {
+		t.Fatalf("拆出失败: %v", err)
+	}
+	for _, im := range reloadStreetImages(t, repo, draftID) {
+		if im.ID == d3 && (im.IsDetail != 0 || im.ParentImageID != 0) {
+			t.Fatalf("拆出后应为 is_detail=0/parent=0，实际 %d/%d", im.IsDetail, im.ParentImageID)
+		}
+	}
+	if err := repo.DetachStreetDraftImage(ctx, draftID, m1); err != nil { // 对主图幂等成功
+		t.Fatalf("对主图拆出应幂等成功: %v", err)
+	}
+
+	// 并入上一张：d3 的前一行是 d2（d2 已是 m1 的副图）→ 目标应折回 m1。
+	if err := repo.AttachPrevStreetDraftImage(ctx, draftID, d3); err != nil {
+		t.Fatalf("并入上一张失败: %v", err)
+	}
+	for _, im := range reloadStreetImages(t, repo, draftID) {
+		if im.ID == d3 && (im.IsDetail != 1 || im.ParentImageID != m1) {
+			t.Fatalf("并入上一张应折回主图 %d，实际 is_detail=%d parent=%d", m1, im.IsDetail, im.ParentImageID)
+		}
+	}
+
+	// 首行「并入上一张」应返回 ErrNotFound。
+	first := seedStreetDraftImage(t, repo, draftID, "z", 0)
+	if err := repo.AttachPrevStreetDraftImage(ctx, draftID, first); !errors.Is(err, ErrNotFound) {
+		t.Fatalf("首行并入上一张应返回 ErrNotFound，实际 %v", err)
+	}
+
+	// 跨草稿拦截：空集合 + 跨草稿主图。
+	if err := repo.AttachStreetDraftImages(ctx, draftID, m1, nil); !errors.Is(err, ErrInvalidImageGroup) {
+		t.Fatalf("空集合应返回 ErrInvalidImageGroup，实际 %v", err)
+	}
+	otherMain := seedStreetDraftImage(t, repo, seedStreetDraft(t, repo), "x", 1)
+	if err := repo.AttachStreetDraftImages(ctx, draftID, otherMain, []uint32{d2}); !errors.Is(err, ErrInvalidImageGroup) {
+		t.Fatalf("跨草稿主图应被拦截，实际 %v", err)
+	}
+}
+
+// TestStreetMainDetailReparentGrandchildren 并入一张自带副图的主图时，其原副图应改挂到新主图。
+func TestStreetMainDetailReparentGrandchildren(t *testing.T) {
+	repo := NewReviewRepository(testDB(t))
+	ctx := context.Background()
+
+	draftID := seedStreetDraft(t, repo)
+	m1 := seedStreetDraftImage(t, repo, draftID, "m1", 1)
+	m2 := seedStreetDraftImage(t, repo, draftID, "m2", 2)
+	child := seedStreetDraftImage(t, repo, draftID, "child", 3)
+
+	if err := repo.AttachStreetDraftImages(ctx, draftID, m2, []uint32{child}); err != nil {
+		t.Fatalf("预置副图失败: %v", err)
+	}
+	if err := repo.AttachStreetDraftImages(ctx, draftID, m1, []uint32{m2}); err != nil {
+		t.Fatalf("并入整组失败: %v", err)
+	}
+	for _, im := range reloadStreetImages(t, repo, draftID) {
+		if im.ID == m2 && (im.IsDetail != 1 || im.ParentImageID != m1) {
+			t.Fatalf("m2 应成为 m1 的副图，实际 %d/%d", im.IsDetail, im.ParentImageID)
+		}
+		if im.ID == child && (im.IsDetail != 1 || im.ParentImageID != m1) {
+			t.Fatalf("child 应改挂到 m1，实际 %d/%d", im.IsDetail, im.ParentImageID)
+		}
+	}
+}
+```
+
+- [ ] **步骤 2：运行测试验证失败**
+
+运行：`go test -tags integration ./internal/repository/ -run TestStreetMainDetail -v`
+预期：编译失败，报 `repo.AttachStreetDraftImages undefined`（方法尚未实现）。
+
+- [ ] **步骤 3：加模型字段**
+
+按上文「模型新增」在 `internal/model/street_snap_draft.go` 的 `StreetSnapDraftImage` 中追加两个字段（注释一并照抄）。
+
+- [ ] **步骤 4：加接口方法与错误哨兵**
+
+按上文在 `internal/repository/review_repository.go` 中：
+1. 在 `ReviewRepository` 接口的 `SoftDeleteStreetDraftImage` 声明之后插入三个方法声明；
+2. 在 `ErrNotFound` 所在 `var` 块追加 `ErrInvalidImageGroup`。
+
+- [ ] **步骤 5：实现三个方法**
+
+在 `internal/repository/review_repository.go` 末尾追加：
+
+```go
+// ── 街拍草稿图片：主副图分组 ──────────────────────────────────────────────
+
+// AttachStreetDraftImages 把 imgIDs 变成 mainImgID 的副图（批量并入）。
+//
+// 事务内三步：1) 校验主图存在、未软删、本身是主图；2) 先「改挂孙辈」——被并入图原有的副图
+// 改挂到新主图（避免副图的副图）；3) 再把被并入图自身标为副图。第 2 步必须在第 3 步之前。
+func (r *reviewRepository) AttachStreetDraftImages(ctx context.Context, draftID, mainImgID uint32, imgIDs []uint32) error {
+	ids := make([]uint32, 0, len(imgIDs))
+	for _, id := range imgIDs {
+		if id != 0 && id != mainImgID {
+			ids = append(ids, id)
+		}
+	}
+	if mainImgID == 0 || len(ids) == 0 {
+		return ErrInvalidImageGroup
+	}
+
+	return r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+		var main model.StreetSnapDraftImage
+		if err := tx.Where("id = ? AND draft_id = ? AND is_deleted = 0 AND is_detail = 0", mainImgID, draftID).
+			First(&main).Error; err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				return ErrInvalidImageGroup
+			}
+			return err
+		}
+
+		now := uint32(time.Now().Unix())
+		if err := tx.Model(&model.StreetSnapDraftImage{}).
+			Where("draft_id = ? AND is_deleted = 0 AND parent_image_id IN ?", draftID, ids).
+			Updates(map[string]any{"parent_image_id": mainImgID, "updated_at": now}).Error; err != nil {
+			return err
+		}
+		return tx.Model(&model.StreetSnapDraftImage{}).
+			Where("draft_id = ? AND is_deleted = 0 AND id IN ?", draftID, ids).
+			Updates(map[string]any{"is_detail": 1, "parent_image_id": mainImgID, "updated_at": now}).Error
+	})
+}
+
+// AttachPrevStreetDraftImage 把 imgID 并入「同草稿内 sort_order 紧邻的前一行所属组的主图」。
+// 折回组主图是刻意的：连续「并入上一张」应链式归并到同一主图，而不是造出副图的副图。
+func (r *reviewRepository) AttachPrevStreetDraftImage(ctx context.Context, draftID, imgID uint32) error {
+	var target uint32
+	err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+		var cur model.StreetSnapDraftImage
+		if err := tx.Where("id = ? AND draft_id = ? AND is_deleted = 0", imgID, draftID).First(&cur).Error; err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				return ErrNotFound
+			}
+			return err
+		}
+
+		var prev model.StreetSnapDraftImage
+		err := tx.Where("draft_id = ? AND is_deleted = 0 AND (sort_order < ? OR (sort_order = ? AND id < ?))",
+			draftID, cur.SortOrder, cur.SortOrder, cur.ID).
+			Order("sort_order DESC, id DESC").First(&prev).Error
+		if err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				return ErrNotFound
+			}
+			return err
+		}
+
+		if prev.IsDetail == 1 && prev.ParentImageID != 0 {
+			target = prev.ParentImageID
+		} else {
+			target = prev.ID
+		}
+		if target == imgID {
+			return ErrInvalidImageGroup
+		}
+
+		now := uint32(time.Now().Unix())
+		if err := tx.Model(&model.StreetSnapDraftImage{}).
+			Where("draft_id = ? AND is_deleted = 0 AND parent_image_id = ?", draftID, imgID).
+			Updates(map[string]any{"parent_image_id": target, "updated_at": now}).Error; err != nil {
+			return err
+		}
+		return tx.Model(&model.StreetSnapDraftImage{}).
+			Where("id = ? AND draft_id = ?", imgID, draftID).
+			Updates(map[string]any{"is_detail": 1, "parent_image_id": target, "updated_at": now}).Error
+	})
+	return err
+}
+
+// DetachStreetDraftImage 把副图恢复为主图。对主图调用为幂等成功。
+// 拆出的图若自身带着副图，那些副图保持挂在它下面——它重新成为主图，不变量依然成立。
+func (r *reviewRepository) DetachStreetDraftImage(ctx context.Context, draftID, imgID uint32) error {
+	return r.db.WithContext(ctx).
+		Model(&model.StreetSnapDraftImage{}).
+		Where("id = ? AND draft_id = ? AND is_deleted = 0 AND is_detail = 1", imgID, draftID).
+		Updates(map[string]any{"is_detail": 0, "parent_image_id": 0, "updated_at": uint32(time.Now().Unix())}).
+		Error
+}
+```
+
+- [ ] **步骤 6：运行测试验证通过**
+
+运行：`go test -tags integration ./internal/repository/ -run TestStreetMainDetail -v`
+预期：`PASS`（两个测试函数都通过）。
+
+同时跑既有测试确认没打破别的：`go test -tags integration ./internal/repository/ -v`
+预期：全绿。
+
+- [ ] **步骤 7：Commit**
+
+```bash
+git add internal/model/street_snap_draft.go internal/repository/review_repository.go internal/repository/street_main_detail_integration_test.go
+git commit -m "feat(street): 草稿图支持主副分组（并入/并入上一张/拆出）"
+```
+
+---
+
+## 任务 2：晋升时重建父引用
+
+**文件：**
+- 修改：`internal/model/street_snap.go`（`StreetSnapImage` 加两字段）
+- 修改：`internal/repository/review_repository.go:376-464`（`SaveStreetSnapFromDraft`）
+- 测试：`internal/repository/street_main_detail_integration_test.go`（追加）
+
+**为什么必须重建**：晋升会**软删正式表旧图并整批重建**，新插入的正式图行拿到的是**全新的行 id**。副图的 `parent_image_id` 里存的是**草稿表的行 id**，直接复制过去会指向不存在（或属于别的图）的行 —— 详情页折叠结构就错乱了。
+
+- [ ] **步骤 1：编写失败的测试**
+
+在 `internal/repository/street_main_detail_integration_test.go` 追加：
+
+```go
+// TestStreetPromoteRebuildsParentRef 晋升时必须把副图的父引用从「草稿行 id」改写为「新正式行 id」。
+func TestStreetPromoteRebuildsParentRef(t *testing.T) {
+	repo := NewReviewRepository(testDB(t))
+	ctx := context.Background()
+
+	draftID := seedStreetDraft(t, repo)
+	m1 := seedStreetDraftImage(t, repo, draftID, "main", 1)
+	d2 := seedStreetDraftImage(t, repo, draftID, "detail-a", 2)
+	d3 := seedStreetDraftImage(t, repo, draftID, "detail-b", 3)
+	if err := repo.AttachStreetDraftImages(ctx, draftID, m1, []uint32{d2, d3}); err != nil {
+		t.Fatalf("预置主副图失败: %v", err)
+	}
+
+	snapID, err := repo.SaveStreetSnapFromDraft(ctx, draftID)
+	if err != nil {
+		t.Fatalf("晋升失败: %v", err)
+	}
+	t.Cleanup(func() {
+		db := repo.(*reviewRepository).db
+		db.Exec("DELETE FROM street_snap_images WHERE snap_id = ?", snapID)
+		db.Exec("DELETE FROM street_snaps WHERE id = ?", snapID)
+	})
+
+	db := repo.(*reviewRepository).db
+	var rows []model.StreetSnapImage
+	if err := db.WithContext(ctx).Where("snap_id = ? AND is_deleted = 0", snapID).
+		Order("sort_order ASC, id ASC").Find(&rows).Error; err != nil {
+		t.Fatalf("读正式图失败: %v", err)
+	}
+	if len(rows) != 3 {
+		t.Fatalf("期望 3 行正式图，实际 %d", len(rows))
+	}
+
+	mainRow := rows[0]
+	if mainRow.IsDetail != 0 || mainRow.ParentImageID != 0 {
+		t.Fatalf("首行应是主图，实际 is_detail=%d parent=%d", mainRow.IsDetail, mainRow.ParentImageID)
+	}
+	for _, row := range rows[1:] {
+		if row.IsDetail != 1 {
+			t.Fatalf("第 %d 行应是副图", row.ID)
+		}
+		if row.ParentImageID != mainRow.ID {
+			t.Fatalf("副图 parent 应指向新主图行 id %d，实际 %d", mainRow.ID, row.ParentImageID)
+		}
+	}
+}
+```
+
+- [ ] **步骤 2：运行测试验证失败**
+
+运行：`go test -tags integration ./internal/repository/ -run TestStreetPromoteRebuildsParentRef -v`
+预期：FAIL，`副图 parent 应指向新主图行 id N，实际 0`（当前晋升不复制分组字段）。
+
+- [ ] **步骤 3：加模型字段**
+
+在 `internal/model/street_snap.go` 的 `StreetSnapImage` 内、`DupOf` 之后追加（与草稿表同款注释）：
+
+```go
+	// 主副图分组（列由 db/migrations/2026-09-21-01-street-main-detail.sql 添加）：
+	// is_detail=0 为主图（parent_image_id=0）；=1 为副图，parent_image_id 指向同专辑内主图的行 id。
+	IsDetail      uint8  `gorm:"column:is_detail;not null;default:0" json:"is_detail"`
+	ParentImageID uint32 `gorm:"column:parent_image_id;not null;default:0" json:"parent_image_id"`
+```
+
+- [ ] **步骤 4：改晋升逻辑**
+
+把 `SaveStreetSnapFromDraft` 里「替换图片」那一段（当前是 `if len(imgs) > 0 { rows := ...; tx.Create(&rows) }`）整体替换为：
+
+```go
+		if len(imgs) > 0 {
+			// 第一遍：插入主图（is_detail=0），并记下「草稿行 id → 新正式行 id」的映射。
+			//
+			// 必须两遍插入：副图的 parent_image_id 存的是**草稿表**的行 id，
+			// 而这里插入的正式行拿到的是全新 id。若先插副图，父引用就会指向草稿表的旧 id，
+			// 详情页折叠结构随之错乱（见本计划「任务 2」标题下的说明）。
+			newIDByDraftID := make(map[uint32]uint32, len(imgs))
+			mains := make([]model.StreetSnapImage, 0, len(imgs))
+			for _, im := range imgs {
+				if im.IsDetail == 1 {
+					continue
+				}
+				mains = append(mains, model.StreetSnapImage{
+					SnapID:      snapID,
+					Image:       im.Image,
+					Name:        im.Name,
+					SortOrder:   uint32(len(mains) + 1),
+					IsDetail:    0,
+					Phash:       im.Phash,
+					IsDuplicate: im.IsDuplicate,
+					DupOf:       im.DupOf,
+					CreatedAt:   now,
+					UpdatedAt:   now,
+				})
+			}
+			for i := range mains {
+				if cErr := tx.Create(&mains[i]).Error; cErr != nil {
+					return cErr
+				}
+			}
+			mainIdx := 0
+			for _, im := range imgs {
+				if im.IsDetail == 1 {
+					continue
+				}
+				newIDByDraftID[im.ID] = mains[mainIdx].ID
+				mainIdx++
+			}
+
+			// 第二遍：插入副图，把父引用改写成新主图行 id。
+			details := make([]model.StreetSnapImage, 0, len(imgs)-len(mains))
+			for _, im := range imgs {
+				if im.IsDetail != 1 {
+					continue
+				}
+				newParent, ok := newIDByDraftID[im.ParentImageID]
+				row := model.StreetSnapImage{
+					SnapID:      snapID,
+					Image:       im.Image,
+					Name:        im.Name,
+					SortOrder:   uint32(len(mains) + len(details) + 1),
+					IsDetail:    1,
+					Phash:       im.Phash,
+					IsDuplicate: im.IsDuplicate,
+					DupOf:       im.DupOf,
+					CreatedAt:   now,
+					UpdatedAt:   now,
+				}
+				if ok {
+					row.ParentImageID = newParent
+				} else {
+					row.IsDetail = 0 // 父行缺失：按主图渲染，与读侧容错口径一致
+				}
+				details = append(details, row)
+			}
+			if len(details) > 0 {
+				if cErr := tx.Create(&details).Error; cErr != nil {
+					return cErr
+				}
+			}
+		}
+```
+
+同时把 `common` map 里的 `"image_count"` 保持不变（仍是 `uint16(len(imgs))`，即全部图 —— 规格明确不改语义）。
+
+- [ ] **步骤 5：运行测试验证通过**
+
+运行：`go test -tags integration ./internal/repository/ -run TestStreetPromote -v`
+预期：`PASS`。
+
+再跑整个仓储包：`go test -tags integration ./internal/repository/ -v`
+预期：全绿（特别是既有 `TestDedup*` 不受影响）。
+
+- [ ] **步骤 6：Commit**
+
+```bash
+git add internal/model/street_snap.go internal/repository/review_repository.go internal/repository/street_main_detail_integration_test.go
+git commit -m "fix(street): 晋升时重建副图父引用（草稿行 id → 正式行 id）"
+```
+
+---
+
+## 任务 3：审核 service 暴露分组操作 + 详情分组视图
+
+**文件：**
+- 修改：`internal/service/review_service.go`（`DraftImageRef`、`DraftImageGroup`、`DraftDetailView`、`ReviewService` 接口、实现、`streetModule.DraftDetail`、新增错误）
+- 测试：`internal/service/review_street_group_test.go`（新建）
+
+- [ ] **步骤 1：编写失败的单测**
+
+创建 `internal/service/review_street_group_test.go`：
+
+```go
+package service
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"fashionapi/internal/dto"
+	"fashionapi/internal/model"
+	"fashionapi/internal/repository"
+)
+
+// fakeGroupRepo 只实现分组相关方法与详情读取，其余由内嵌 nil 接口兜底（不会被调用）。
+type fakeGroupRepo struct {
+	repository.ReviewRepository
+
+	detail   *model.StreetSnapDraft
+	images   []model.StreetSnapDraftImage
+	mainImg  uint32
+	attach   []uint32
+	prevImg  uint32
+	detachID uint32
+	attachFn func(ctx context.Context, draftID, mainImgID uint32, imgIDs []uint32) error
+}
+
+func (f *fakeGroupRepo) StreetDraftDetail(ctx context.Context, id uint32) (*model.StreetSnapDraft, error) {
+	if f.detail == nil {
+		return nil, repository.ErrNotFound
+	}
+	return f.detail, nil
+}
+
+func (f *fakeGroupRepo) StreetDraftImages(ctx context.Context, draftID uint32) ([]model.StreetSnapDraftImage, error) {
+	return f.images, nil
+}
+
+func (f *fakeGroupRepo) AttachStreetDraftImages(ctx context.Context, draftID, mainImgID uint32, imgIDs []uint32) error {
+	f.mainImg = mainImgID
+	f.attach = imgIDs
+	if f.attachFn != nil {
+		return f.attachFn(ctx, draftID, mainImgID, imgIDs)
+	}
+	return nil
+}
+
+func (f *fakeGroupRepo) AttachPrevStreetDraftImage(ctx context.Context, draftID, imgID uint32) error {
+	f.prevImg = imgID
+	return nil
+}
+
+func (f *fakeGroupRepo) DetachStreetDraftImage(ctx context.Context, draftID, imgID uint32) error {
+	f.detachID = imgID
+	return nil
+}
+
+// TestStreetGroupDetailExposesGrouping 详情视图必须把分组信息带给模板（Images 扁平 + Groups 按组）。
+func TestStreetGroupDetailExposesGrouping(t *testing.T) {
+	repo := &fakeGroupRepo{
+		detail: &model.StreetSnapDraft{ID: 7, Title: "T", Year: 2026, City: "C", Status: model.DraftStatusPending},
+		images: []model.StreetSnapDraftImage{
+			{ID: 1, Name: "主图", SortOrder: 1},
+			{ID: 2, Name: "副图", SortOrder: 2, IsDetail: 1, ParentImageID: 1},
+			{ID: 3, Name: "独立", SortOrder: 3},
+		},
+	}
+	svc := NewReviewService(repo, nil, nil, nil)
+
+	v, err := svc.DraftDetail(context.Background(), dto.IngestKindStreet, 7)
+	if err != nil {
+		t.Fatalf("取详情失败: %v", err)
+	}
+	if len(v.Images) != 3 {
+		t.Fatalf("期望 3 张图，实际 %d", len(v.Images))
+	}
+	if len(v.Groups) != 2 {
+		t.Fatalf("期望 2 组（主图1带副图2；独立3自成一主图），实际 %d", len(v.Groups))
+	}
+	if v.Groups[0].Image.ID != 1 || len(v.Groups[0].Details) != 1 {
+		t.Fatalf("第 1 组应是主图1 + 1 张副图，实际 main=%d details=%d", v.Groups[0].Image.ID, len(v.Groups[0].Details))
+	}
+	if v.Groups[1].Image.ID != 3 {
+		t.Fatalf("第 2 组主图应是 3，实际 %d", v.Groups[1].Image.ID)
+	}
+	if v.Images[0].DetailCount != 1 {
+		t.Fatalf("主图应统计到 1 张副图，实际 %d", v.Images[0].DetailCount)
+	}
+}
+
+// TestStreetGroupAttachDelegates 并入操作应委派到仓储，并校验主图合法。
+func TestStreetGroupAttachDelegates(t *testing.T) {
+	repo := &fakeGroupRepo{detail: &model.StreetSnapDraft{ID: 7, Status: model.DraftStatusPending}, images: []model.StreetSnapDraftImage{{ID: 1, SortOrder: 1}}}
+	svc := NewReviewService(repo, nil, nil, nil)
+
+	if err := svc.AttachDraftImages(context.Background(), dto.IngestKindStreet, 7, 1, []uint32{2, 3}); err != nil {
+		t.Fatalf("并入失败: %v", err)
+	}
+	if repo.mainImg != 1 || len(repo.attach) != 2 {
+		t.Fatalf("委派参数不对: main=%d ids=%v", repo.mainImg, repo.attach)
+	}
+	if err := svc.AttachDraftImages(context.Background(), dto.IngestKindStreet, 7, 1, nil); err == nil {
+		t.Fatalf("空集合应报错")
+	}
+	if err := svc.AttachDraftImages(context.Background(), dto.IngestKindRunway, 7, 1, []uint32{2}); err == nil {
+		t.Fatalf("走秀模块应拒绝主副图操作")
+	}
+}
+
+// TestStreetGroupPreventCrossDraft 跨草稿 / 非法主图应被拦下并给出可读错误。
+func TestStreetGroupPreventCrossDraft(t *testing.T) {
+	repo := &fakeGroupRepo{
+		detail: &model.StreetSnapDraft{ID: 7, Status: model.DraftStatusPending},
+		images: []model.StreetSnapDraftImage{{ID: 1, SortOrder: 1}},
+		attachFn: func(ctx context.Context, draftID, mainImgID uint32, imgIDs []uint32) error {
+			return repository.ErrInvalidImageGroup
+		},
+	}
+	svc := NewReviewService(repo, nil, nil, nil)
+
+	err := svc.AttachDraftImages(context.Background(), dto.IngestKindStreet, 7, 99, []uint32{2})
+	if !errors.Is(err, ErrInvalidImageGroup) {
+		t.Fatalf("期望 ErrInvalidImageGroup，实际 %v", err)
+	}
+	if got := err.Error(); got != "主图无效：它必须属于本草稿、未被删除，且自身是主图" {
+		t.Fatalf("错误文案应为给用户看的中文，实际 %q", got)
+	}
+}
+
+// TestStreetGroupDetachAndPrev 拆出与「并入上一张」的委派。
+func TestStreetGroupDetachAndPrev(t *testing.T) {
+	repo := &fakeGroupRepo{detail: &model.StreetSnapDraft{ID: 7, Status: model.DraftStatusPending}}
+	svc := NewReviewService(repo, nil, nil, nil)
+
+	if err := svc.DetachDraftImage(context.Background(), dto.IngestKindStreet, 7, 5); err != nil {
+		t.Fatalf("拆出失败: %v", err)
+	}
+	if repo.detachID != 5 {
+		t.Fatalf("拆出应委派 id=5，实际 %d", repo.detachID)
+	}
+	if err := svc.AttachPrevDraftImage(context.Background(), dto.IngestKindStreet, 7, 6); err != nil {
+		t.Fatalf("并入上一张失败: %v", err)
+	}
+	if repo.prevImg != 6 {
+		t.Fatalf("并入上一张应委派 id=6，实际 %d", repo.prevImg)
+	}
+}
+```
+
+- [ ] **步骤 2：运行测试验证失败**
+
+运行：`go test ./internal/service/ -run TestStreetGroup -v`
+预期：编译失败，报 `svc.AttachDraftImages undefined`、`v.Groups undefined`、`ErrInvalidImageGroup undefined`。
+
+- [ ] **步骤 3：扩展类型与新增错误**
+
+`DraftImageRef`（`internal/service/review_service.go:28-34`）替换为：
+
+```go
+// DraftImageRef 草稿图片引用（统一结构）。
+//
+// IsDetail / ParentImageID 只有街拍模块会填（走秀的主/细节图走 LookIndex 那套，语义不同，不复用）；
+// DetailCount 让模板不用自己数副图。
+type DraftImageRef struct {
+	ID            uint32 `json:"id"`
+	Image         string `json:"image"`
+	Name          string `json:"name"`
+	SortOrder     uint32 `json:"sort_order"`
+	IsDetail      uint8  `json:"is_detail"`       // 1=副图（挂在 ParentImageID 指向的主图下）；0=主图
+	ParentImageID uint32 `json:"parent_image_id"` // 副图所属主图的行 id；主图为 0
+	DetailCount   int    `json:"detail_count"`   // 仅主图有意义：名下（存活）副图数量
+}
+```
+
+在该文件顶部错误声明区（与既有 `ErrXxx` 放一起）追加：
+
+```go
+// ErrInvalidImageGroup 主副图分组操作不合法：主图不存在 / 不属于本草稿 / 自身不是主图 / 空集合。
+// 这里是给用户看的文案，handler 直接渲染 err.Error()。
+var ErrInvalidImageGroup = errors.New("主图无效：它必须属于本草稿、未被删除，且自身是主图")
+```
+
+> 若该文件当前未导入 `errors`，在 import 块补上（`review_service.go` 现有 import 里没有它，需加）。
+
+在 `DraftDetailView`（`review_service.go:45-66`）的 `Fields` 之前加两字段：
+
+```go
+	// MainID 审核页「当前主图」的行 id，来自 URL 查询参数 ?main=；0 表示未选定。
+	// 只有街拍模块会用到（走秀无主副图概念）。
+	MainID uint32 `json:"main_id"`
+	// Groups 街拍详情的「主图 → 其副图」分组视图（按 sort_order 顺序）。走秀模块留空。
+	// 与 Images 同源同序：Images 保持扁平（既有渲染 / runway 仍用），Groups 供按组折叠。
+	Groups []DraftImageGroup `json:"groups,omitempty"`
+```
+
+在该类型之后新增 `DraftImageGroup`：
+
+```go
+// DraftImageGroup 一张主图及其副图，供审核页按组折叠渲染。
+type DraftImageGroup struct {
+	Image   DraftImageRef   `json:"image"`   // 主图
+	Details []DraftImageRef `json:"details"` // 该主图名下的副图（可为空）
+}
+```
+
+- [ ] **步骤 4：接口加三方法**
+
+`ReviewService` 接口（`review_service.go:97-107`）在 `DeleteDraftImage` 之后插入：
+
+```go
+	// AttachDraftImages 把若干张草稿图并入指定主图（街拍专用；走秀模块返回 ErrInvalidImageGroup）。
+	AttachDraftImages(ctx context.Context, kind string, draftID, mainImgID uint32, imgIDs []uint32) error
+	// AttachPrevDraftImage 把某张草稿图并入「同草稿内上一行所属组的主图」（街拍专用）。
+	AttachPrevDraftImage(ctx context.Context, kind string, draftID, imgID uint32) error
+	// DetachDraftImage 把副图拆出恢复为主图（街拍专用）。
+	DetachDraftImage(ctx context.Context, kind string, draftID, imgID uint32) error
+```
+
+- [ ] **步骤 5：实现三个方法 + 错误翻译 + 详情组装**
+
+在 `reviewService.DeleteDraftImage`（`review_service.go:238-261`）之后追加：
+
+```go
+func (s *reviewService) AttachDraftImages(ctx context.Context, kind string, draftID, mainImgID uint32, imgIDs []uint32) error {
+	if kind != dto.IngestKindStreet {
+		return ErrInvalidImageGroup
+	}
+	if len(imgIDs) == 0 {
+		return ErrInvalidImageGroup
+	}
+	return translateGroupErr(s.repo.AttachStreetDraftImages(ctx, draftID, mainImgID, imgIDs))
+}
+
+func (s *reviewService) AttachPrevDraftImage(ctx context.Context, kind string, draftID, imgID uint32) error {
+	if kind != dto.IngestKindStreet {
+		return ErrInvalidImageGroup
+	}
+	return translateGroupErr(s.repo.AttachPrevStreetDraftImage(ctx, draftID, imgID))
+}
+
+func (s *reviewService) DetachDraftImage(ctx context.Context, kind string, draftID, imgID uint32) error {
+	if kind != dto.IngestKindStreet {
+		return ErrInvalidImageGroup
+	}
+	return translateGroupErr(s.repo.DetachStreetDraftImage(ctx, draftID, imgID))
+}
+
+// translateGroupErr 把仓储层的哨兵错误翻成给用户看的中文文案；其余错误原样透传。
+func translateGroupErr(err error) error {
+	if err == nil {
+		return nil
+	}
+	if errors.Is(err, repository.ErrInvalidImageGroup) {
+		return ErrInvalidImageGroup
+	}
+	return err
+}
+```
+
+把 `streetModule.DraftDetail`（`review_service.go:364-392`）里 `Images` 的组装循环与 `v` 的字段装配替换为：
+
+```go
+	// 先算存活的主图 id 集合（副图 parent 必须命中它，否则按主图渲染），以及每张主图名下副图数。
+	mainSet := make(map[uint32]struct{}, len(imgs))
+	for _, im := range imgs {
+		if im.IsDetail == 0 {
+			mainSet[im.ID] = struct{}{}
+		}
+	}
+	detailCount := make(map[uint32]int, len(imgs))
+	for _, im := range imgs {
+		if im.IsDetail == 1 && im.ParentImageID != 0 {
+			detailCount[im.ParentImageID]++
+		}
+	}
+
+	v := &DraftDetailView{
+		Kind:       dto.IngestKindStreet,
+		ID:         d.ID,
+		Title:      d.Title,
+		Year:       d.Year,
+		City:       d.City,
+		Cover:      m.img.Compose(d.Cover),
+		ImageCount: d.ImageCount,
+		Status:     d.Status,
+		Fields: []EditField{
+			{Name: "title", Label: "标题", Value: d.Title, Type: "text"},
+			{Name: "year", Label: "年份", Value: yearStr(d.Year), Type: "number"},
+			{Name: "city", Label: "城市", Value: d.City, Type: "text"},
+		},
+	}
+
+	// 按 sort_order 顺序成组：主图各成一组；副图归入其（存活）主图组，父引用失效则自成一主图组。
+	groups := make([]DraftImageGroup, 0, len(imgs))
+	groupIndex := make(map[uint32]int, len(imgs))
+	for _, im := range imgs {
+		isDetail := im.IsDetail
+		parent := im.ParentImageID
+		if isDetail == 1 {
+			if _, ok := mainSet[parent]; !ok {
+				isDetail = 0 // 容错：父行失效 → 按主图渲染
+				parent = 0
+			}
+		}
+		ref := DraftImageRef{
+			ID:            im.ID,
+			Image:         m.img.Compose(im.Image),
+			Name:          im.Name,
+			SortOrder:     im.SortOrder,
+			IsDetail:      isDetail,
+			ParentImageID: parent,
+			DetailCount:   detailCount[im.ID],
+		}
+		v.Images = append(v.Images, ref)
+		if isDetail == 0 {
+			groups = append(groups, DraftImageGroup{Image: ref})
+			groupIndex[im.ID] = len(groups) - 1
+			continue
+		}
+		if gi, ok := groupIndex[parent]; ok {
+			groups[gi].Details = append(groups[gi].Details, ref)
+		} else { // 兜底：主图未先出现（理论上不会），自成一组
+			groups = append(groups, DraftImageGroup{Image: ref})
+			groupIndex[im.ID] = len(groups) - 1
+		}
+	}
+	v.Groups = groups
+	return v, nil
+```
+
+（注意：上面的 `Fields` 构造块与你源码里既有的 `streetModule.DraftDetail` 一致，仅把最后的 `for _, im := range imgs { v.Images = append(...) }` 循环替换成了成组逻辑；`DraftView` 字段名以你源码实际为准。）
+
+- [ ] **步骤 6：运行测试验证通过**
+
+运行：`go test ./internal/service/ -run TestStreetGroup -v`
+预期：`PASS`（4 个 `TestStreetGroup*` 全绿）；既有 `TestProcessMediaCleanup*` / `TestIngestRetryBackoff` 不受影响。
+
+- [ ] **步骤 7：Commit**
+
+```bash
+git add internal/service/review_service.go internal/service/review_street_group_test.go
+git commit -m "feat(street): 审核 service 暴露主副图分组操作与详情分组视图"
+```
+
+---
+
+## 任务 4：后台路由 + handler + 审核页分组渲染
+
+**文件：**
+- 修改：`internal/router/backstage.go:86-98`（加 3 条路由）
+- 修改：`internal/handler/backstage_handler.go`（加 3 个 handler + 改 `tplReviewDetail` + `ReviewDetail` 透传 `?main=`）
+- 修改：`internal/router/backstage_test.go`（加 `fakeReview` + 断言）
+- 修改：`internal/handler/backstage_handler_test.go`（既有解析测试自动覆盖新模板，确认通过）
+
+- [ ] **步骤 1：编写失败的测试**
+
+在 `internal/router/backstage_test.go` 的假实现区（`fakeStreet` 之后）追加 `fakeReview`，并把 `TestBackstage` 里构造 handler 的行改成传入 `fakeReview`：
+
+```go
+// fakeReview 记录审核操作入参，并返回可配置结果，用于断言新路由的 302 与委派 + 分组渲染。
+type fakeReview struct {
+	attachMain uint32
+	attachIDs  []uint32
+	attachOK   bool
+}
+
+func (f *fakeReview) ListDrafts(ctx context.Context, kind, status string, page, size int) ([]service.DraftCard, int64, error) {
+	return nil, 0, nil
+}
+func (f *fakeReview) DraftDetail(ctx context.Context, kind string, id uint32) (*service.DraftDetailView, error) {
+	return &service.DraftDetailView{
+		Kind:      kind,
+		ID:        id,
+		Title:     "街拍标题",
+		Status:    model.DraftStatusPending,
+		ImageCount: 3,
+		Images: []service.DraftImageRef{
+			{ID: 11, Name: "主图", SortOrder: 1, DetailCount: 1},
+			{ID: 12, Name: "副图", SortOrder: 2, IsDetail: 1, ParentImageID: 11},
+			{ID: 13, Name: "独立", SortOrder: 3},
+		},
+		Groups: []service.DraftImageGroup{
+			{Image: service.DraftImageRef{ID: 11, Name: "主图", SortOrder: 1, DetailCount: 1},
+				Details: []service.DraftImageRef{{ID: 12, Name: "副图", SortOrder: 2, IsDetail: 1, ParentImageID: 11}}},
+			{Image: service.DraftImageRef{ID: 13, Name: "独立", SortOrder: 3}},
+		},
+	}, nil
+}
+func (f *fakeReview) UpdateDraft(ctx context.Context, kind string, id uint32, fields map[string]any) error { return nil }
+func (f *fakeReview) Approve(ctx context.Context, kind string, id uint32, reviewer string) (uint32, error) { return 1, nil }
+func (f *fakeReview) Reject(ctx context.Context, kind string, id uint32, reviewer, reason string) error { return nil }
+func (f *fakeReview) DeleteDraftImage(ctx context.Context, kind string, draftID, imgID uint32) error { return nil }
+func (f *fakeReview) KindTabs(ctx context.Context) []service.KindTab {
+	return []service.KindTab{{Kind: "", Label: "全部", Pending: 2}, {Kind: dto.IngestKindStreet, Label: "街拍", Pending: 2}}
+}
+func (f *fakeReview) AttachDraftImages(ctx context.Context, kind string, draftID, mainImgID uint32, imgIDs []uint32) error {
+	f.attachMain = mainImgID
+	f.attachIDs = imgIDs
+	if !f.attachOK {
+		return service.ErrInvalidImageGroup
+	}
+	return nil
+}
+func (f *fakeReview) AttachPrevDraftImage(ctx context.Context, kind string, draftID, imgID uint32) error { return nil }
+func (f *fakeReview) DetachDraftImage(ctx context.Context, kind string, draftID, imgID uint32) error { return nil }
+
+// 编译期接口满足性检查
+var _ service.ReviewService = (*fakeReview)(nil)
+```
+
+把 `TestBackstage` 里的 handler 构造改为：
+
+```go
+	h := handler.NewBackstageHandler(auth, brand, &fakeArticle{}, &fakeStreet{}, &fakeReview{attachOK: true}, nil)
+```
+
+并在「街拍详情渲染图集」那段之后追加四个断言：
+
+```go
+	// 10) 审核详情页（街拍）：主图条 + 分组渲染
+	w = httptest.NewRecorder()
+	req = httptest.NewRequest(http.MethodGet, "/admin/reviews/street/7?main=11", nil)
+	req.AddCookie(&http.Cookie{Name: adminCookie, Value: token})
+	r.ServeHTTP(w, req)
+	if w.Code != 200 {
+		t.Fatalf("审核详情应 200，实际 %d %s", w.Code, w.Body.String())
+	}
+	body := w.Body.String()
+	if !strings.Contains(body, "当前主图：#11") {
+		t.Fatalf("缺少常驻主图提示条: %s", body)
+	}
+	if !strings.Contains(body, "副图 · 主图 #11") { // 分组渲染：副图挂在主图 11 下
+		t.Fatalf("缺少分组渲染：副图未标注所属主图: %s", body)
+	}
+	if !strings.Contains(body, "并入上一张") || !strings.Contains(body, "拆出") {
+		t.Fatalf("缺少并入上一张 / 拆出入口: %s", body)
+	}
+
+	// 11) 并入当前主图（单张）：302 回详情页
+	w = httptest.NewRecorder()
+	req = httptest.NewRequest(http.MethodPost, "/admin/reviews/street/7/images/attach",
+		strings.NewReader("main=11&img=12"))
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	req.AddCookie(&http.Cookie{Name: adminCookie, Value: token})
+	r.ServeHTTP(w, req)
+	if w.Code != 302 || !strings.Contains(w.Header().Get("Location"), "/admin/reviews/street/7") {
+		t.Fatalf("并入应 302 回详情，实际 %d %s", w.Code, w.Header().Get("Location"))
+	}
+
+	// 12) 拆出：302 回详情页
+	w = httptest.NewRecorder()
+	req = httptest.NewRequest(http.MethodPost, "/admin/reviews/street/7/images/12/detach", nil)
+	req.AddCookie(&http.Cookie{Name: adminCookie, Value: token})
+	r.ServeHTTP(w, req)
+	if w.Code != 302 {
+		t.Fatalf("拆出应 302，实际 %d", w.Code)
+	}
+
+	// 13) 并入上一张：302 回详情页
+	w = httptest.NewRecorder()
+	req = httptest.NewRequest(http.MethodPost, "/admin/reviews/street/7/images/13/attach-prev", nil)
+	req.AddCookie(&http.Cookie{Name: adminCookie, Value: token})
+	r.ServeHTTP(w, req)
+	if w.Code != 302 {
+		t.Fatalf("并入上一张应 302，实际 %d", w.Code)
+	}
+```
+
+- [ ] **步骤 2：运行测试验证失败**
+
+运行：`go test ./internal/router/ -v`
+预期：编译失败或路由未注册（`fakeReview` 未满足 `service.ReviewService`，或 `/images/attach` 不存在）。
+
+- [ ] **步骤 3：加路由**
+
+`internal/router/backstage.go` 在 `admin.POST("/reviews/:kind/:id/images/:img/delete", ...)`（第 96 行）之后插入：
+
+```go
+		// 街拍主副图分组：并入当前主图 / 并入上一张 / 拆出（零 JS 同步表单，均 302 回详情页）。
+		admin.POST("/reviews/:kind/:id/images/attach", opt.Backstage.ReviewDraftImagesAttach)
+		admin.POST("/reviews/:kind/:id/images/:img/attach-prev", opt.Backstage.ReviewDraftImageAttachPrev)
+		admin.POST("/reviews/:kind/:id/images/:img/detach", opt.Backstage.ReviewDraftImageDetach)
+```
+
+- [ ] **步骤 4：加 handler**
+
+`internal/handler/backstage_handler.go` 在 `ReviewDraftImageDelete`（第 453-466 行）之后插入：
+
+```go
+// ReviewDraftImagesAttach 把一张草稿图并入「当前主图」（逐张并入，零 JS 无表单嵌套）。
+// 当前主图由表单隐藏字段 main 携带（来自 URL 查询参数 ?main=）。
+func (h *BackstageHandler) ReviewDraftImagesAttach(c *gin.Context) {
+	kind := c.Param("kind")
+	id := atoiDefault(c.Param("id"), 0)
+	mainID := atoiDefault(c.PostForm("main"), 0)
+	imgID := atoiDefault(c.PostForm("img"), 0)
+	if id == 0 || mainID == 0 || imgID == 0 {
+		renderHTML(c, http.StatusBadRequest, tplError, gin.H{"Error": "请先选定主图，并指定要并入的图片"})
+		return
+	}
+	if err := h.review.AttachDraftImages(c.Request.Context(), kind, uint32(id), uint32(mainID), []uint32{imgID}); err != nil {
+		renderHTML(c, http.StatusInternalServerError, tplError, gin.H{"Error": err.Error()})
+		return
+	}
+	c.Redirect(http.StatusFound, reviewDetailURL(kind, c.Param("id")))
+}
+
+// ReviewDraftImageAttachPrev 把某张草稿图并入「上一行所属组的主图」。
+func (h *BackstageHandler) ReviewDraftImageAttachPrev(c *gin.Context) {
+	kind := c.Param("kind")
+	id := atoiDefault(c.Param("id"), 0)
+	imgID := atoiDefault(c.Param("img"), 0)
+	if id == 0 || imgID == 0 {
+		renderHTML(c, http.StatusBadRequest, tplError, gin.H{"Error": "参数无效"})
+		return
+	}
+	if err := h.review.AttachPrevDraftImage(c.Request.Context(), kind, uint32(id), uint32(imgID)); err != nil {
+		renderHTML(c, http.StatusInternalServerError, tplError, gin.H{"Error": err.Error()})
+		return
+	}
+	c.Redirect(http.StatusFound, reviewDetailURL(kind, c.Param("id")))
+}
+
+// ReviewDraftImageDetach 把副图拆出、恢复为主图。
+func (h *BackstageHandler) ReviewDraftImageDetach(c *gin.Context) {
+	kind := c.Param("kind")
+	id := atoiDefault(c.Param("id"), 0)
+	imgID := atoiDefault(c.Param("img"), 0)
+	if id == 0 || imgID == 0 {
+		renderHTML(c, http.StatusBadRequest, tplError, gin.H{"Error": "参数无效"})
+		return
+	}
+	if err := h.review.DetachDraftImage(c.Request.Context(), kind, uint32(id), uint32(imgID)); err != nil {
+		renderHTML(c, http.StatusInternalServerError, tplError, gin.H{"Error": err.Error()})
+		return
+	}
+	c.Redirect(http.StatusFound, reviewDetailURL(kind, c.Param("id")))
+}
+
+// reviewDetailURL 生成审核详情页地址（原样保留路径参数，避免对 id 二次编码）。
+func reviewDetailURL(kind, rawID string) string {
+	return "/admin/reviews/" + kind + "/" + rawID
+}
+```
+
+- [ ] **步骤 5：改 `ReviewDetail` 透传 `?main=`**
+
+`internal/handler/backstage_handler.go` 的 `ReviewDetail`（第 384-411 行）在 `draft, err := h.review.DraftDetail(...)` 成功之后、`renderHTML` 之前加：
+
+```go
+	// 当前主图由 URL 查询参数承载（零 JS、无状态、可刷新可书签）。
+	draft.MainID = uint32(atoiDefault(c.Query("main"), 0))
+```
+
+- [ ] **步骤 6：改模板 `tplReviewDetail`**
+
+`internal/handler/backstage_handler.go` 的 `tplReviewDetail`（第 1275-1292 行的图片区块）整体替换为下面这段（**街拍按组折叠；走秀保持原扁平网格**）。注意：**每个按钮都是独立 `<form>`，并列于 `.acts` / `.strip` 容器，不存在表单嵌套**。
+
+```html
+<h2 style="margin-top:24px">图片管理（{{len .Draft.Images}} 张）</h2>
+{{if eq .Draft.Kind "street"}}
+{{if .Draft.MainID}}<div class="note" style="padding:8px 10px;background:#f4f6f8;border-radius:6px;margin-bottom:12px">当前主图：<b>#{{.Draft.MainID}}</b> —— 每张图点「并入当前主图」即可归组；点「设为主图」可改选。</div>
+{{else}}<div class="note" style="padding:8px 10px;background:#fff8e1;border-radius:6px;margin-bottom:12px">未选定主图。先在图片卡片点「设为主图」。</div>{{end}}
+<div class="grid">
+{{range .Draft.Groups}}<div class="cell">
+<img src="{{.Image.Image}}" loading="lazy">
+<span style="display:block;padding:6px 8px;font-size:12px;color:#666">#{{.Image.ID}} · {{.Image.Name}}{{if gt .Image.DetailCount 0}}<span class="badge">{{.Image.DetailCount}} 张副图</span>{{end}}</span>
+<div class="acts">
+{{if eq $.Draft.MainID .Image.ID}}<span class="muted">当前主图</span>{{else}}<a href="/admin/reviews/{{$.Draft.Kind}}/{{$.Draft.ID}}?main={{.Image.ID}}">设为主图</a>{{end}}
+{{if ne .Image.ID $.Draft.MainID}}<form method="post" action="/admin/reviews/{{$.Draft.Kind}}/{{$.Draft.ID}}/images/attach" style="display:inline">
+<input type="hidden" name="main" value="{{$.Draft.MainID}}"><input type="hidden" name="img" value="{{.Image.ID}}">
+<button type="submit"{{if not $.Draft.MainID}} disabled title="请先选定主图"{{end}}>并入当前主图</button>
+</form>
+<form method="post" action="/admin/reviews/{{$.Draft.Kind}}/{{$.Draft.ID}}/images/{{.Image.ID}}/attach-prev" style="display:inline"><button type="submit">并入上一张</button></form>{{end}}
+<form method="post" action="/admin/reviews/{{$.Draft.Kind}}/{{$.Draft.ID}}/images/{{.Image.ID}}/delete" style="display:inline"><button type="submit" class="reject" onclick="return confirm('确认删除这张图片？')">删除</button></form>
+</div>
+{{if .Details}}<div class="strip" style="display:flex;gap:8px;flex-wrap:wrap;padding:6px 8px;background:#fafafa;border-radius:6px">
+{{range .Details}}<div class="det">
+<img src="{{.Image}}" loading="lazy" style="height:60px">
+<span style="display:block;font-size:11px;color:#666">#{{.ID}} · {{.Name}}<span class="badge">副图 · 主图 #{{.ParentImageID}}</span></span>
+<div class="acts">
+<form method="post" action="/admin/reviews/{{$.Draft.Kind}}/{{$.Draft.ID}}/images/{{.ID}}/detach" style="display:inline"><button type="submit">拆出</button></form>
+<form method="post" action="/admin/reviews/{{$.Draft.Kind}}/{{$.Draft.ID}}/images/{{.ID}}/delete" style="display:inline"><button type="submit" class="reject" onclick="return confirm('确认删除这张图片？')">删除</button></form>
+</div>
+</div>{{end}}
+</div>{{end}}
+</div>{{end}}
+{{else}}
+<div class="grid">
+{{range .Draft.Images}}<div class="cell">
+<img src="{{.Image}}" loading="lazy">
+<span style="display:block;padding:6px 8px;font-size:12px;color:#666">{{.Name}}</span>
+<div class="acts">
+<form method="post" action="/admin/reviews/{{$.Draft.Kind}}/{{$.Draft.ID}}/images/{{.ID}}/delete"><button type="submit" class="reject" onclick="return confirm('确认删除这张图片？')">删除</button></form>
+</div>
+</div>{{end}}
+</div>
+{{end}}
+```
+
+- [ ] **步骤 7：运行测试验证通过**
+
+运行：`go test ./internal/router/ -run TestBackstage -v`
+预期：`PASS`。
+
+再跑模板解析冒烟与全部单测：
+
+```bash
+go test ./internal/handler/ -v
+go test ./...
+```
+
+预期：全绿。
+
+- [ ] **步骤 8：Commit**
+
+```bash
+git add internal/router/backstage.go internal/router/backstage_test.go internal/handler/backstage_handler.go internal/handler/backstage_handler_test.go internal/service/review_service.go
+git commit -m "feat(street): 审核页支持人工指定主图/副图（零 JS 表单 + 按组折叠）"
+```
+
+---
+
+## 任务 5：公开 API 新增分组字段
+
+**文件：**
+- 修改：`internal/dto/street_snap.go`（`PublicStreetSnapDetail`）
+- 修改：`internal/service/street_snap_service.go:122-143`（`Detail`）+ 新增 `groupSnapImages`
+- 测试：`internal/service/street_snap_group_test.go`（新建）
+
+- [ ] **步骤 1：编写失败的单测**
+
+创建 `internal/service/street_snap_group_test.go`：
+
+```go
+package service
+
+import (
+	"testing"
+
+	"fashionapi/internal/model"
+	"fashionapi/internal/pkg/imgurl"
+)
+
+// groupSnapImages 是纯函数：把扁平图片列表按主副关系重排成组。
+func TestGroupSnapImages(t *testing.T) {
+	s := &streetSnapService{img: imgurl.New("", "", "")}
+
+	imgs := []model.StreetSnapImage{
+		{ID: 1, Image: "a.jpg", Name: "A", SortOrder: 1},
+		{ID: 2, Image: "b.jpg", Name: "B", SortOrder: 2, IsDetail: 1, ParentImageID: 1},
+		{ID: 3, Image: "c.jpg", Name: "C", SortOrder: 3},
+		{ID: 4, Image: "d.jpg", Name: "D", SortOrder: 4, IsDetail: 1, ParentImageID: 3},
+		{ID: 5, Image: "e.jpg", Name: "E", SortOrder: 5, IsDetail: 1, ParentImageID: 2}, // 父指向副图 2 → 上浮到组主图 1
+	}
+
+	flat, groups := s.groupSnapImages(imgs)
+
+	if len(flat) != 5 {
+		t.Fatalf("images 应保持 5 张，实际 %d", len(flat))
+	}
+	if flat[0].Name != "A" || flat[4].Name != "E" {
+		t.Fatalf("images 顺序应保持输入顺序")
+	}
+	if len(groups) != 2 {
+		t.Fatalf("应成 2 组，实际 %d", len(groups))
+	}
+	if groups[0].Image.Name != "A" {
+		t.Fatalf("第 1 组主图应是 A，实际 %s", groups[0].Image.Name)
+	}
+	if len(groups[0].Details) != 2 {
+		t.Fatalf("第 1 组应有 2 张副图（父引用指向副图的 5 要上浮到组主图），实际 %d", len(groups[0].Details))
+	}
+	if groups[1].Image.Name != "C" || len(groups[1].Details) != 1 {
+		t.Fatalf("第 2 组应是 C + 1 张副图，实际 %s + %d", groups[1].Image.Name, len(groups[1].Details))
+	}
+}
+
+// TestGroupSnapImagesToleratesDanglingParent 父引用失效时按主图渲染，不丢图。
+func TestGroupSnapImagesToleratesDanglingParent(t *testing.T) {
+	s := &streetSnapService{img: imgurl.New("", "", "")}
+
+	imgs := []model.StreetSnapImage{
+		{ID: 1, Name: "A", SortOrder: 1},
+		{ID: 2, Name: "孤儿副图", SortOrder: 2, IsDetail: 1, ParentImageID: 999}, // 父行不存在
+	}
+
+	flat, groups := s.groupSnapImages(imgs)
+
+	if len(flat) != 2 {
+		t.Fatalf("容错不应丢图，实际 %d", len(flat))
+	}
+	if len(groups) != 2 {
+		t.Fatalf("孤儿副图应自成一「主图」组，实际 %d 组", len(groups))
+	}
+	if groups[1].Image.Name != "孤儿副图" {
+		t.Fatalf("孤儿副图应按主图渲染，实际 %s", groups[1].Image.Name)
+	}
+}
+
+// TestGroupSnapImagesEmpty 空输入返回 nil，不 panic。
+func TestGroupSnapImagesEmpty(t *testing.T) {
+	s := &streetSnapService{img: imgurl.New("", "", "")}
+	flat, groups := s.groupSnapImages(nil)
+	if flat != nil || groups != nil {
+		t.Fatalf("空输入应返回 nil，实际 %v / %v", flat, groups)
+	}
+}
+```
+
+- [ ] **步骤 2：运行测试验证失败**
+
+运行：`go test ./internal/service/ -run TestGroupSnapImages -v`
+预期：编译失败，报 `s.groupSnapImages undefined`。
+
+- [ ] **步骤 3：加 DTO**
+
+`internal/dto/street_snap.go` 在 `PublicStreetSnapDetail` 定义之前插入：
+
+```go
+// PublicStreetSnapGroup 街拍详情里的一组「主图 + 其副图」。
+// 与 PublicStreetSnapDetail.Images **同源同序**：Groups 只是 Images 按主副关系重排后的视图，不引入新数据来源。
+type PublicStreetSnapGroup struct {
+	Image   PublicArticleImage   `json:"image"`   // 主图
+	Details []PublicArticleImage `json:"details"` // 该主图下的副图（可为空）
+}
+```
+
+并把 `PublicStreetSnapDetail` 替换为：
+
+```go
+// PublicStreetSnapDetail 对外只读街拍详情：含完整图片集。
+// 保守扩展：Images（扁平、按 sort_order 升序）保持原样不变，现有前端不受影响；新增 Groups 供择期迁移。
+type PublicStreetSnapDetail struct {
+	UID       string                 `json:"id"`
+	Title     string                 `json:"title"`
+	Cover     string                 `json:"cover"`
+	Images    []PublicArticleImage   `json:"images"`
+	Groups    []PublicStreetSnapGroup `json:"groups,omitempty"`
+	Favorited bool                   `json:"favorited,omitempty"` // 已登录时该图集是否被当前用户收藏（gallery 级）
+}
+```
+
+- [ ] **步骤 4：实现分组并接进 `Detail`**
+
+在 `internal/service/street_snap_service.go` 的 `Detail`（第 122-143 行）之后追加：
+
+```go
+// groupSnapImages 把扁平图片列表按主副关系重排成组视图，并返回扁平列表本身。
+// 两个切片都从同一份输入派生，保证「Images 与 Groups 同源同序」。
+// 容错（与后台审核页一致）：父引用缺失或指向非主图的图**按主图渲染**，自成一组，绝不丢图。
+// 父引用指向「副图」时向上一级归并到该副图所在组的主图。
+func (s *streetSnapService) groupSnapImages(imgs []model.StreetSnapImage) ([]dto.PublicArticleImage, []dto.PublicStreetSnapGroup) {
+	if len(imgs) == 0 {
+		return nil, nil
+	}
+
+	flat := s.toPublicSnapImages(imgs)
+
+	mainOf := make(map[uint32]uint32, len(imgs)) // 行 id → 组主图 id
+	for _, im := range imgs {
+		if im.IsDetail == 0 {
+			mainOf[im.ID] = im.ID
+		}
+	}
+	for _, im := range imgs { // 第一轮：副图直接挂到其 parent（可能是主图，也可能是另一张副图）
+		if im.IsDetail != 1 {
+			continue
+		}
+		if root, ok := mainOf[im.ParentImageID]; ok {
+			mainOf[im.ID] = root
+		} else if _, isDetailOf := mainOf[im.ParentImageID]; isDetailOf {
+			mainOf[im.ID] = im.ParentImageID
+		}
+		// 父不存在 → 不写 mainOf，下方按主图渲染
+	}
+	for _, im := range imgs { // 第二轮：parent→副图→主图 的链再向上归并一层
+		root, ok := mainOf[im.ID]
+		if !ok {
+			continue
+		}
+		if up, ok2 := mainOf[root]; ok2 && up != root {
+			mainOf[im.ID] = up
+		}
+	}
+
+	groups := make([]dto.PublicStreetSnapGroup, 0, len(imgs))
+	index := make(map[uint32]int, len(imgs))
+	for i, im := range imgs {
+		root, isDetail := mainOf[im.ID]
+		if !isDetail {
+			groups = append(groups, dto.PublicStreetSnapGroup{Image: flat[i]})
+			index[im.ID] = len(groups) - 1
+			continue
+		}
+		gi, ok := index[root]
+		if !ok { // 兜底（理论不发生）
+			groups = append(groups, dto.PublicStreetSnapGroup{Image: flat[i]})
+			index[im.ID] = len(groups) - 1
+			continue
+		}
+		groups[gi].Details = append(groups[gi].Details, flat[i])
+	}
+	return flat, groups
+}
+```
+
+把 `Detail` 的返回改成：
+
+```go
+	flat, groups := s.groupSnapImages(imgs)
+	return &dto.PublicStreetSnapDetail{
+		UID:    hashid.EncodeWithType(snap.ID, hashid.TypeSnap),
+		Title:  snap.Title,
+		Cover:  s.img.Compose(snap.Cover),
+		Images: flat,
+		Groups: groups,
+	}, nil
+```
+
+- [ ] **步骤 5：运行测试验证通过**
+
+运行：`go test ./internal/service/ -run TestGroupSnapImages -v`
+预期：`PASS`（三个用例全绿）。
+
+再跑全部：`go test ./...`
+预期：全绿。
+
+- [ ] **步骤 6：Commit**
+
+```bash
+git add internal/dto/street_snap.go internal/service/street_snap_service.go internal/service/street_snap_group_test.go
+git commit -m "feat(street): 公开详情新增 groups 分组（images 保持兼容）"
+```
+
+---
+
+## 收尾（全部任务完成后）
+
+- [ ] `gofmt -l .`：本次改动涉及的文件必须无输出（注意：仓库 `.go` 文件多为 CRLF，`gofmt -l .` 会列出大量**既有**文件，与本计划无关 —— 只需确认你改过的文件不在其中）。
+- [ ] `go vet ./...` 与 `go vet -tags integration ./internal/repository/`：均为 0。
+- [ ] `go build ./...`：0。
+- [ ] `go test ./...`：全绿。
+- [ ] `go test -tags integration ./internal/repository/ -v`：全绿（需库已就绪）。
+- [ ] **若改了表结构相关代码（本计划没有），记得重导 dump**：`dbtool dump -clean -out db/backups/db_dump.sql`。本计划**不触碰 DB 结构**，通常无需重导；但若你在实现时顺手改了 model 的 gorm tag 导致结构变化，则必须重导。
+- [ ] 手工验收（需启动后端并登录后台）：
+  - 打开一篇街拍草稿详情 → 点某张图「设为主图」→ URL 出现 `?main=<id>`、顶部出现「当前主图：#<id>」
+  - 点另一张图的「并入当前主图」→ 该图出现「副图 · 主图 #<id>」角标，主图出现「1 张副图」，详情页该主图卡片下出现副图缩略条
+  - 点副图的「拆出」→ 角标消失、缩略条消失
+  - 点第 3 张图的「并入上一张」→ 归并到与上一张相同的组
+  - 审核通过后，公开详情接口返回的 `groups` 结构与后台一致，且 `images` 仍为扁平全量
+
+## 不做的事（防止越界）
+
+- 不改 `image_count` 语义（仍计全部图）。
+- 不动 `PublicStreetSnap`（列表）结构。
+- 不给 `brand_runway_*` 加同类字段，也不改 `look_index` / `is_detail`（走秀既有语义）。
+- 不加 `parent_image_id` 索引（图片表千行级，顺序扫描足够；需要时另开迁移脚本）。
+- 不引入任何 JS。
diff --git a/docs/superpowers/specs/2026-09-20-ingest-idempotency-design.md b/docs/superpowers/specs/2026-09-20-ingest-idempotency-design.md
index 9bd1e2a..ebf4454 100644
--- a/docs/superpowers/specs/2026-09-20-ingest-idempotency-design.md
+++ b/docs/superpowers/specs/2026-09-20-ingest-idempotency-design.md
@@ -118,9 +118,14 @@ source      varchar(32)  not null default ''
 source_url  varchar(512) not null default ''
 ```
 
-对应模型：`internal/model/runway_draft.go` 的 `BrandRunwayDraft`、`internal/model/street_snap_draft.go` 的 `StreetSnapDraft`。列由 `AutoMigrate` 托管，**模型上不加 `uniqueIndex` tag**（GORM tag 无法表达部分索引条件）。
+对应模型：`internal/model/runway_draft.go` 的 `BrandRunwayDraft`、`internal/model/street_snap_draft.go` 的 `StreetSnapDraft`。**模型上不加 `uniqueIndex` tag**（GORM tag 无法表达部分索引条件）。
 
-索引写在 `internal/database/postgres.go` 的 `EnsureDedupSchema` 中——该函数本就是「`AutoMigrate` 之外的索引补充」的既定位置，且全部 `IF NOT EXISTS` 幂等：
+> **落点已变更（2026-09-21）**：服务启动时的自动迁移（`AutoMigrate` / `EnsureDedupSchema`）已移除，
+> 全库结构改由 `cmd/dbtool` 的 dump 维护。加列 / 加索引现在走 `db/migrations/` 下的一次性脚本：
+> 对开发库执行 → 再 `dbtool dump -clean` 重新导出。本规格的列与索引已落在
+> `db/migrations/2026-09-21-03-ingest-source-idempotency.sql`（已应用）。
+
+索引定义（部分唯一索引——全量唯一索引会因存量大量 `('','')` 冲突而建索引失败）：
 
 ```sql
 CREATE UNIQUE INDEX IF NOT EXISTS uq_br_draft_source
diff --git a/docs/superpowers/specs/2026-09-21-duplicate-review-design.md b/docs/superpowers/specs/2026-09-21-duplicate-review-design.md
index 72608d8..f7f0eda 100644
--- a/docs/superpowers/specs/2026-09-21-duplicate-review-design.md
+++ b/docs/superpowers/specs/2026-09-21-duplicate-review-design.md
@@ -117,7 +117,9 @@ CREATE INDEX IF NOT EXISTS idx_image_dups_owner
 
 **不冗余存对手的标题**：读时按 `peer_owner_kind` join 对应表取（草稿 → `*_drafts.title_en` / `.title`；正式 → `brand_runways.title_en` / `street_snaps.title`）。避免标题被改后出现陈旧副本。
 
-建表放在 `internal/database/postgres.go` 的 `EnsureDedupSchema`（该函数本就是「`AutoMigrate` 之外的索引与表补充」的既定位置，且全部幂等）。
+> **落点已变更（2026-09-21）**：`AutoMigrate` / `EnsureDedupSchema` 已移除，结构改由 `cmd/dbtool` 的 dump 维护。
+> 本节的表与索引已落在 `db/migrations/2026-09-21-02-duplicate-review.sql`（已应用）。
+> 今后加表 / 加索引一律走 `db/migrations/` 的一次性脚本 → 对开发库执行 → `dbtool dump -clean` 重新导出。
 
 ### 3.2 写入时机与算法
 
@@ -226,7 +228,7 @@ CREATE UNIQUE INDEX IF NOT EXISTS uq_ss_source
 
 ```
 internal/model/image_duplicate.go            新增（模型）
-internal/database/postgres.go                EnsureDedupSchema 建表与索引
+db/migrations/2026-09-21-02-duplicate-review.sql  建表与索引（已应用）
 internal/repository/dup_repository.go        新增：写入 + 读取 + 回填
 internal/repository/ingest_repository.go     StreetSnapIDByEntity 改键
 internal/repository/review_repository.go     SaveStreetSnapFromDraft / streetApprovedSiblingImages 改键