feat: store 镜像层（全字段镜像+部门关系+生命周期+一次性 token）

新增镜像存储层并保留旧台账过渡：
- MirrorUser/MirrorDepartment/MirrorUserDepartment/ResignConfirmToken 模型
- ReplaceMirror 单事务整体替换：用户/部门/关系一致更新，失败回滚保留旧版
- 生命周期状态机：active→leave_candidate→pending_confirm→confirmed_leave→deleted，
  非法转移结构性报错；快照只覆盖飞书事实不清洗状态
- 一次性离职确认 token：crypto/rand 生成、一次使用、过期作废、可批量 revoke
- 单测：事务回滚、状态机转移、token 一次/过期/复用被拒 全部通过
- docs/migration-baseline.md 记录阶段0基线字段

docs/migration-baseline.md

@@ -0,0 +1,45 @@
+# 阶段 0：基线冻结记录
+
+## 基线验证
+- `make build`：通过（`bin/idsync` 编译成功）
+- `make test`：全绿（config/mapping/password/server/syncer 有测试；feishu/ldaplib/store/webui 无测试）
+
+## 迁移前 config 字段（`config.yml` / `config.example.yml`）
+
+### system
+`mode`(debug/release)、`data-dir`
+
+### server
+`listen`、`admin-user`、`admin-password`、`admin-password-hash`、`session-secret`、`secure-cookie`
+
+### feishu
+`app-id`、`app-secret`、`base-url`、`dept-list`、`qps`、`timeout-sec`
+
+### ldap
+`url`、`base-dn`、`admin-dn`、`admin-pass`、`user-ou`、`inactive-ou`、
+`group-root-name`、`group-object-class`、`group-member-attr`、`timeout-sec`、
+`start-tls`、`insecure-skip-verify`、`initial-password`
+
+### database
+`source`
+
+### sync
+`enable`、`schedule`、`default-dry-run`、`max-deactivate`、`max-deactivate-percent`
+
+## 迁移后应删除的项目（阶段 5）
+- `ldap.user-ou` / `ldap.inactive-ou` → 固定 `ou=people`
+- `ldap.group-root-name` / `ldap.group-object-class` / `ldap.group-member-attr` → LLDAP 形态，不再需要
+- `ldap.initial-password` → 密码 LLDAP 独占
+- `sync.*` 单套 → 拆为两套 schedule（snapshot / sync）
+
+## 迁移后应新增的项目（阶段 5）
+- `ldap` 写通道：`base-url`、`admin-user`、`admin-pass`（供 GraphQL login）
+- `feishu.webhook-url`（离职卡片自定义机器人）
+- `server.confirm-base-url`（一次性确认端点对外 URL）
+- 两套 `schedule.snapshot` / `schedule.sync`
+
+## 迁移状态（AGENTS.md「迁移状态」节引用的旧实现）
+- `internal/ldaplib/ops.go` 写路径（Add/Modify/ModifyDN）、`internal/password`（SSHA）、
+  旧 config 项 —— 迁移完成前不作目标行为
+- `internal/store` 现为轻量台账（Account/Group/SyncRun），待扩展为全字段镜像 + 部门关系
+- `internal/feishu` 尚无可卡发送能力，离职确认通道未落地

internal/store/mirror.go

@@ -0,0 +1,453 @@
+package store
+
+// 镜像存储层：全字段用户镜像 + 部门关系 + 生命周期状态 + 一次性离职确认 token。
+//
+// 设计要点（与 AGENTS.md 硬约束对应）：
+//   - 飞书是唯一真相，本层只做「从飞书快照写入」与「生命周期状态转移」，绝不发明业务字段。
+//   - 快照整体刷新在单个事务内完成，失败回滚保留上一版镜像，绝不留下「半新半旧」。
+//   - 删除（confirmed_leave → deleted → 物化删除）只由生命周期状态驱动，不在此层直接删用户。
+//   - token 由 crypto/rand 生成、一次性使用、带过期时间；确认必须落在程序自己的端点。
+//
+// 注意：本层仍与旧实现（Account/Group 台账，见 repo.go）共存，直到 runner/server 迁移完成。
+
+import (
+	"crypto/rand"
+	"encoding/base64"
+	"fmt"
+	"time"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+)
+
+// 用户生命周期状态。只有 active 用户会出现在物化期望状态里，
+// 其余状态都是在「离职双确认」流程中流转的中间/终态。
+const (
+	StateActive         = "active"          // 在职：物化的期望来源
+	StateLeaveCandidate = "leave_candidate" // 飞书缺席且机器确认离职，等待发卡片
+	StatePendingConfirm = "pending_confirm" // 已发离职确认卡片，等待人工点击一次性端点
+	StateConfirmedLeave = "confirmed_leave" // 人工确认离职，等待下一轮物化物理删除
+	StateDeleted        = "deleted"         // 已从 LLDAP 删除，仅作历史痕迹保留
+)
+
+// 一次性离职确认 token 的流转状态。
+const (
+	TokenPending = "pending" // 已生成、可被消费
+	TokenUsed    = "used"    // 已被确认端点消费（一次使用）
+	TokenRevoked = "revoked" // 用户重新可见时作废
+)
+
+// MirrorUser 是 镜像 + 台账 合一的全字段用户记录。
+//
+// uid 是登录名（企业邮箱 @ 前缀）同时为主键；union_id 唯一，用于重新入职判别
+// 与离职回查。skipped 为纯展示信息：缺少企业邮箱的用户没有 uid，这里以 union_id
+// 作为 uid 落一条记录，WebUI 据此列出「谁没被同步」，避免静默丢失。
+type MirrorUser struct {
+	UID              string    `gorm:"primaryKey;size:190"`
+	UnionID          string    `gorm:"size:190;uniqueIndex;not null"`
+	UserID           string    `gorm:"size:190"`
+	Email            string    `gorm:"size:255"`  // 企业邮箱
+	DisplayName      string    `gorm:"size:255"`  // 优先中文名
+	GivenName        string    `gorm:"size:255"`  // 优先英文名
+	SN               string    `gorm:"size:255"`  // 姓氏姓名，sn 为空会违 inetOrgPerson
+	Mobile           string    `gorm:"size:64"`
+	EmployeeNumber   string    `gorm:"size:64"`
+	DepartmentNumber string    `gorm:"size:255"` // 职位
+	PostalAddress    string    `gorm:"size:255"` // 工位
+	BusinessCategory string    `gorm:"size:512"` // 所属部门名（逗号分隔）
+	EmployeeType     string    `gorm:"size:32"`
+	Description      string    `gorm:"size:512"`
+	// DepartmentIDs 仅快照构建期间用于重建关系表，不落库（关联存放在
+	// mirror_user_departments）。
+	DepartmentIDs []string `gorm:"-"`
+	State         string    `gorm:"size:32;not null;default:active;index"`
+	// AttrsHash 是上一次写入 LLDAP 的属性内容指纹；快照刷新不得覆盖它。
+	AttrsHash     string `gorm:"size:64"`
+	Skipped       bool   `gorm:"not null;default:false"`
+	SkipReason    string `gorm:"size:512"`
+	LastSyncedAt  time.Time
+	CreatedAt     time.Time
+	UpdatedAt     time.Time
+}
+
+// MirrorDepartment 是部门镜像。
+type MirrorDepartment struct {
+	DeptID       string    `gorm:"primaryKey;size:190"`
+	Name         string    `gorm:"check:name <> ''"`
+	PinyinName   string    `gorm:"size:255"`
+	DN           string    `gorm:"size:512"`
+	ParentID     string    `gorm:"size:190;index"`
+	Level        int
+	State        string    `gorm:"size:32;not null;default:active;index"`
+	LastSyncedAt time.Time
+	CreatedAt    time.Time
+	UpdatedAt    time.Time
+}
+
+// MirrorUserDepartment 是用户 ↔ 部门 的关联表，用于按部门查人的索引。
+type MirrorUserDepartment struct {
+	UID    string `gorm:"primaryKey;size:190"`
+	DeptID string `gorm:"primaryKey;size:190;index"`
+}
+
+// ResignConfirmToken 是一次性离职确认 token。
+type ResignConfirmToken struct {
+	Token     string     `gorm:"primaryKey;size:64"`
+	UID       string     `gorm:"size:190;index;not null"`
+	Status    string     `gorm:"size:16;not null;default:pending"`
+	ExpiresAt time.Time
+	CreatedAt time.Time
+	UsedAt    *time.Time
+}
+
+// MirrorSnapshot 是一次快照整体替换的输入来源。它只携带「飞书当前有什么」，
+// 由调用方（快照 runner）从飞书拉取后交给 ReplaceMirror 落库。
+type MirrorSnapshot struct {
+	Users       []*MirrorUser // 有企业邮箱、可生成 uid 的用户（在飞书可见）
+	Departments []*MirrorDepartment
+	// Skipped 是缺少企业邮箱而被跳过的用户，以 union_id 作为 uid 落库供 WebUI 展示。
+	Skipped []*MirrorUser
+}
+
+// ReplaceMirror 在单个事务内整体替换镜像的用户、部门，并重建用户-部门关系表。
+//
+// 事务保证：任何一步失败都回滚，SQLite 停留在上一版完整镜像，绝不出现半新半旧。
+// 快照只覆盖「飞书事实」列；生命周期状态（state）与 attrs_hash 在 upsert 冲突时
+// 刻意不覆盖——否则会把正在走离职流程的用户重置回 active，违反镜像业务。
+//
+// 用户的生命周期状态由独立的 reconcile 步骤驱动（见 syncer），此处不做任何决策。
+func (s *Store) ReplaceMirror(snap *MirrorSnapshot) error {
+	return s.db.Transaction(func(tx *gorm.DB) error {
+		now := time.Now()
+
+		// 部门整体替换：快照里的都 upsert；快照之外的一律清除，保证镜像 = 飞书当前有的部门。
+		// 部门是两个「整体替换」之一，用户因受离职生命周期约束不在本层删。
+		if err := tx.Session(&gorm.Session{AllowGlobalUpdate: true}).
+			Delete(&MirrorDepartment{}).Error; err != nil {
+			return fmt.Errorf("清空部门镜像失败: %w", err)
+		}
+		for _, d := range snap.Departments {
+			d.State = StateActive
+			d.LastSyncedAt = now
+			if err := tx.Clauses(clause.OnConflict{
+				Columns: []clause.Column{{Name: "dept_id"}},
+				DoUpdates: clause.AssignmentColumns([]string{
+					"name", "pinyin_name", "dn", "parent_id", "level", "state", "last_synced_at",
+				}),
+			}).Create(d).Error; err != nil {
+				return fmt.Errorf("写入部门镜像 %s(%s) 失败: %w", d.Name, d.DeptID, err)
+			}
+		}
+
+		// 用户整体替换：upsert 有账者，不轮询删除缺席者（其生命周期由 reconcile 处理）。
+		for _, u := range snap.Users {
+			u.State = StateActive
+			u.Skipped = false
+			u.SkipReason = ""
+			u.LastSyncedAt = now
+			if err := tx.Clauses(clause.OnConflict{
+				Columns: []clause.Column{{Name: "uid"}},
+				// 只更新飞书事实列；state / attrs_hash / created_at 保留。
+				DoUpdates: clause.AssignmentColumns([]string{
+					"union_id", "user_id", "email", "display_name", "given_name", "sn",
+					"mobile", "employee_number", "department_number", "postal_address",
+					"business_category", "employee_type", "description",
+					"skipped", "skip_reason", "last_synced_at",
+				}),
+			}).Create(u).Error; err != nil {
+				return fmt.Errorf("写入用户镜像 %s(%s) 失败: %w", u.UID, u.DisplayName, err)
+			}
+		}
+
+		// 被跳过的用户也落库，但标记 skipped=true，不进入 any 物化视图。
+		for _, u := range snap.Skipped {
+			u.Skipped = true
+			u.SkipReason = "缺少企业邮箱，无法推导登录名"
+			u.LastSyncedAt = now
+			if err := tx.Clauses(clause.OnConflict{
+				Columns: []clause.Column{{Name: "uid"}},
+				DoUpdates: clause.AssignmentColumns([]string{
+					"union_id", "user_id", "email", "display_name", "given_name", "sn",
+					"mobile", "employee_number", "department_number", "postal_address",
+					"business_category", "employee_type", "description",
+					"state", "skipped", "skip_reason", "last_synced_at",
+				}),
+			}).Create(u).Error; err != nil {
+				return fmt.Errorf("写入跳过用户镜像 %s(%s) 失败: %w", u.UID, u.DisplayName, err)
+			}
+		}
+
+		// 重建用户-部门关系表：整体删除后按本次快照重新插入。
+		if err := tx.Session(&gorm.Session{AllowGlobalUpdate: true}).
+			Delete(&MirrorUserDepartment{}).Error; err != nil {
+			return fmt.Errorf("清空用户-部门关系失败: %w", err)
+		}
+		var rels []MirrorUserDepartment
+		for _, u := range snap.Users {
+			for _, deptID := range u.DepartmentIDs {
+				rels = append(rels, MirrorUserDepartment{UID: u.UID, DeptID: deptID})
+			}
+		}
+		if len(rels) > 0 {
+			// ChunkSize 分批插入，避免一条 SQL 过长。
+			if err := tx.CreateInBatches(&rels, 500).Error; err != nil {
+				return fmt.Errorf("重建用户-部门关系失败: %w", err)
+			}
+		}
+		return nil
+	})
+}
+
+// --- 生命周期状态机 ---
+
+// transition 做一次受校验的状态转移：仅当当前状态为 from 时才置为 to。
+// 放在事务里执行，避免并发下读到半路状态。转移失败说明状态机被绕过了，
+// 直接报错——「未确认的离职候选绝不入计划」就是靠这一步结构性地拦住的。
+func (s *Store) transition(uid, from, to string) error {
+	return s.db.Transaction(func(tx *gorm.DB) error {
+		res := tx.Model(&MirrorUser{}).
+			Where("uid = ? AND state = ?", uid, from).
+			Update("state", to)
+		if res.Error != nil {
+			return res.Error
+		}
+		if res.RowsAffected != 1 {
+			return fmt.Errorf("状态转移 uid=%s %s→%s 失败：当前状态不允许该转移", uid, from, to)
+		}
+		return nil
+	})
+}
+
+// ToLeaveCandidate 飞书缺席 + 机器确认离职：active → leave_candidate。
+func (s *Store) ToLeaveCandidate(uid string) error {
+	return s.transition(uid, StateActive, StateLeaveCandidate)
+}
+
+// ToPendingConfirm 已对用户发送离职确认卡片：leave_candidate → pending_confirm。
+func (s *Store) ToPendingConfirm(uid string) error {
+	return s.transition(uid, StateLeaveCandidate, StatePendingConfirm)
+}
+
+// ConfirmLeave 人工在一次性端点上确认离职：pending_confirm → confirmed_leave。
+func (s *Store) ConfirmLeave(uid string) error {
+	return s.transition(uid, StatePendingConfirm, StateConfirmedLeave)
+}
+
+// MarkDeleted 该用户已从 LLDAP 物理删除：confirmed_leave → deleted。
+func (s *Store) MarkDeleted(uid string) error {
+	return s.transition(uid, StateConfirmedLeave, StateDeleted)
+}
+
+// RevertToActive 用户重新在飞书可见：撤销离职流程回 active。
+//
+// 只有真正进入删除（deleted）后的用户不能回退——他已经从 LLDAP 删了，
+// 下一轮物化会以「重建」处理。还在双确认流程内的都可回退。
+func (s *Store) RevertToActive(uid string) error {
+	return s.db.Model(&MirrorUser{}).
+		Where("uid = ? AND state IN ?", uid,
+			[]string{StateLeaveCandidate, StatePendingConfirm, StateConfirmedLeave}).
+		Update("state", StateActive).Error
+}
+
+// --- 查询视图 ---
+
+// ActiveUsers 返回在职视图：state=active 且未跳过。这是物化期望状态的唯一来源。
+func (s *Store) ActiveUsers() ([]*MirrorUser, error) {
+	var out []*MirrorUser
+	if err := s.db.Where("state = ? AND skipped = ?", StateActive, false).
+		Order("uid").Find(&out).Error; err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// UsersByState 返回指定生命周期状态的全部用户。
+func (s *Store) UsersByState(state string) ([]*MirrorUser, error) {
+	var out []*MirrorUser
+	if err := s.db.Where("state = ?", state).Order("uid").Find(&out).Error; err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// PendingConfirm 返回待人工确认的离职候选。
+func (s *Store) PendingConfirm() ([]*MirrorUser, error) {
+	return s.UsersByState(StatePendingConfirm)
+}
+
+// ConfirmedLeave 返回已确认离职、等待物化删除的列表。
+func (s *Store) ConfirmedLeave() ([]*MirrorUser, error) {
+	return s.UsersByState(StateConfirmedLeave)
+}
+
+// LeaveCandidates 返回已机器确认、尚未发卡片的候选。
+func (s *Store) LeaveCandidates() ([]*MirrorUser, error) {
+	return s.UsersByState(StateLeaveCandidate)
+}
+
+// SkippedUsers 返回被跳过的用户记录（无企业邮箱），供 WebUI 展示。
+func (s *Store) SkippedUsers() ([]*MirrorUser, error) {
+	var out []*MirrorUser
+	if err := s.db.Where("skipped = ?", true).Order("uid").Find(&out).Error; err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// AllMirrorUsers 返回全部镜像用户（含所有状态），用于测试与全量展示。
+func (s *Store) AllMirrorUsers() ([]*MirrorUser, error) {
+	var out []*MirrorUser
+	if err := s.db.Order("uid").Find(&out).Error; err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// MapUsersByUID 返回 uid → 镜像用户 映射。
+func (s *Store) MapUsersByUID() (map[string]*MirrorUser, error) {
+	list, err := s.AllMirrorUsers()
+	if err != nil {
+		return nil, err
+	}
+	out := make(map[string]*MirrorUser, len(list))
+	for _, u := range list {
+		out[u.UID] = u
+	}
+	return out, nil
+}
+
+// ActiveDepartments 返回在职视图下的部门镜像。
+func (s *Store) ActiveDepartments() ([]*MirrorDepartment, error) {
+	var out []*MirrorDepartment
+	if err := s.db.Where("state = ?", StateActive).Order("dept_id").Find(&out).Error; err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// AllDepartments 返回全部部门镜像。
+func (s *Store) AllDepartments() ([]*MirrorDepartment, error) {
+	var out []*MirrorDepartment
+	if err := s.db.Order("dept_id").Find(&out).Error; err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// MapDepartmentsByID 返回 dept_id → 部门镜像 映射。
+func (s *Store) MapDepartmentsByID() (map[string]*MirrorDepartment, error) {
+	list, err := s.AllDepartments()
+	if err != nil {
+		return nil, err
+	}
+	out := make(map[string]*MirrorDepartment, len(list))
+	for _, d := range list {
+		out[d.DeptID] = d
+	}
+	return out, nil
+}
+
+// UserDeptIDs 返回某用户所属的部门 ID 列表。
+func (s *Store) UserDeptIDs(uid string) ([]string, error) {
+	var rels []MirrorUserDepartment
+	if err := s.db.Where("uid = ?", uid).Find(&rels).Error; err != nil {
+		return nil, err
+	}
+	out := make([]string, 0, len(rels))
+	for _, r := range rels {
+		out = append(out, r.DeptID)
+	}
+	return out, nil
+}
+
+// DeptUserIDs 返回某部门下的用户 uid 列表（按部门查人的索引）。
+func (s *Store) DeptUserIDs(deptID string) ([]string, error) {
+	var rels []MirrorUserDepartment
+	if err := s.db.Where("dept_id = ?", deptID).Find(&rels).Error; err != nil {
+		return nil, err
+	}
+	out := make([]string, 0, len(rels))
+	for _, r := range rels {
+		out = append(out, r.UID)
+	}
+	return out, nil
+}
+
+// --- 一次性离职确认 token ---
+
+// CreateToken 为 uid 生成一个新的一次性离职确认 token。
+//
+// 用 crypto/rand 生成，不依赖时间/内存地址等可预测来源；token 本身即凭证，
+// 确认端点拿到它就可以把用户置为 confirmed_leave，因此必须唯一不可猜测。
+func (s *Store) CreateToken(uid string, ttl time.Duration) (*ResignConfirmToken, error) {
+	b := make([]byte, 32)
+	if _, err := rand.Read(b); err != nil {
+		return nil, fmt.Errorf("生成 token 失败: %w", err)
+	}
+	rec := &ResignConfirmToken{
+		Token:     base64.RawURLEncoding.EncodeToString(b),
+		UID:       uid,
+		Status:    TokenPending,
+		ExpiresAt: time.Now().Add(ttl),
+	}
+	if err := s.db.Create(rec).Error; err != nil {
+		return nil, fmt.Errorf("保存 token 失败: %w", err)
+	}
+	return rec, nil
+}
+
+// ConsumeToken 消费一个一次性 token：校验存在、未用、未过期后置为 used。
+//
+// 放在事务里，保证并发下同一 token 只会被消费一次（二次使用被拒）。
+// 消费成功后返回 token 记录（含 uid），供确认端点回写 confirmed_leave。
+func (s *Store) ConsumeToken(token string) (*ResignConfirmToken, error) {
+	var rec ResignConfirmToken
+	err := s.db.Transaction(func(tx *gorm.DB) error {
+		if err := tx.Where("token = ?", token).First(&rec).Error; err != nil {
+			return fmt.Errorf("token 不存在或无效")
+		}
+		if rec.Status != TokenPending {
+			return fmt.Errorf("token 已被使用或已作废")
+		}
+		if time.Now().After(rec.ExpiresAt) {
+			return fmt.Errorf("确认链接已过期，请向管理员重新发起离职确认")
+		}
+		usedAt := time.Now()
+		rec.Status = TokenUsed
+		rec.UsedAt = &usedAt
+		if err := tx.Model(&rec).Updates(map[string]any{
+			"status": TokenUsed, "used_at": usedAt,
+		}).Error; err != nil {
+			return err
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	return &rec, nil
+}
+
+// RevokeTokensForUser 作废某用户全部未使用的 token。
+//
+// 用户在飞书重新可见而撤销离职流程时调用：未用 token 若留着，点开仍能把人
+// 误标成离职，因此必须一次性作废。
+func (s *Store) RevokeTokensForUser(uid string) error {
+	return s.db.Model(&ResignConfirmToken{}).
+		Where("uid = ? AND status = ?", uid, TokenPending).
+		Update("status", TokenRevoked).Error
+}
+
+// LastPendingToken 返回某用户最近一条未使用的 token（用于离职提醒节流判断）。
+func (s *Store) LastPendingToken(uid string) (*ResignConfirmToken, error) {
+	var rec ResignConfirmToken
+	err := s.db.Where("uid = ? AND status = ?", uid, TokenPending).
+		Order("created_at desc").First(&rec).Error
+	if err == gorm.ErrRecordNotFound {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	return &rec, nil
+}

internal/store/mirror_test.go

@@ -0,0 +1,260 @@
+package store
+
+import (
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+// mu 构造一个镜像用户，DepartmentIDs 用于驱动关系表重建。
+func mu(uid, email, name string, deptIDs ...string) *MirrorUser {
+	return &MirrorUser{
+		UID:             uid,
+		UnionID:         "u-" + uid,
+		Email:           email,
+		DisplayName:     name,
+		SN:              name,
+		GivenName:       name,
+		EmployeeType:    "Active",
+		DepartmentIDs:   deptIDs,
+		State:           StateActive,
+	}
+}
+
+// md 构造一个部门镜像。
+func md(id, parent, name string) *MirrorDepartment {
+	return &MirrorDepartment{DeptID: id, ParentID: parent, Name: name}
+}
+
+// openStore 打开一个临时文件库，保证多事务测试有真实磁盘语义。
+func openStore(t *testing.T) *Store {
+	t.Helper()
+	path := filepath.Join(t.TempDir(), "idsync-test.db")
+	st, err := Open(path)
+	if err != nil {
+		t.Fatalf("打开 store 失败: %v", err)
+	}
+	t.Cleanup(func() { _ = st.Close() })
+	return st
+}
+
+// TestReplaceMirrorTransactionalRollback 验证快照整体替换的事务性：
+// 中途失败时必须回滚到上一版完整镜像，绝不留下半新半旧。
+func TestReplaceMirrorTransactionalRollback(t *testing.T) {
+	st := openStore(t)
+
+	// 先写入一版正常镜像。
+	good := &MirrorSnapshot{
+		Departments: []*MirrorDepartment{md("od-root", "", "Acme")},
+		Users: []*MirrorUser{
+			mu("alice", "alice@example.com", "Alice", "od-root"),
+		},
+	}
+	if err := st.ReplaceMirror(good); err != nil {
+		t.Fatalf("初始镜像写入失败: %v", err)
+	}
+
+	// 第二版镜像故意带一个空部门名，触发 CHECK 约束失败，中断事务。
+	bad := &MirrorSnapshot{
+		Departments: []*MirrorDepartment{{DeptID: "od-bad", ParentID: "", Name: ""}},
+		Users: []*MirrorUser{
+			mu("bob", "bob@example.com", "Bob", "od-bad"),
+		},
+	}
+	if err := st.ReplaceMirror(bad); err == nil {
+		t.Fatalf("含非法部门名的镜像应当写失败，却成功了")
+	}
+
+	// 回滚后镜像必须仍是第一版：alice 还在、od-root 还在、bob 与 od-bad 都不在。
+	users, err := st.MapUsersByUID()
+	if err != nil {
+		t.Fatalf("读取用户镜像失败: %v", err)
+	}
+	if _, ok := users["alice"]; !ok {
+		t.Errorf("回滚后 alice 丢失，镜像被污染")
+	}
+	if _, ok := users["bob"]; ok {
+		t.Errorf("回滚后 bob 残留，镜像被污染")
+	}
+
+	depts, err := st.MapDepartmentsByID()
+	if err != nil {
+		t.Fatalf("读取部门镜像失败: %v", err)
+	}
+	if _, ok := depts["od-root"]; !ok {
+		t.Errorf("回滚后 od-root 丢失（清空操作也被回滚）")
+	}
+	if _, ok := depts["od-bad"]; ok {
+		t.Errorf("回滚后 od-bad 残留")
+	}
+}
+
+// TestReplaceMirrorPreservesLifecycleState 验证：快照刷新只覆盖飞书事实，
+// 不清洗生命周期状态——正在走离职流程的用户不会被快照重置回 active。
+func TestReplaceMirrorPreservesLifecycleState(t *testing.T) {
+	st := openStore(t)
+	snap := &MirrorSnapshot{
+		Departments: []*MirrorDepartment{md("od-root", "", "Acme")},
+		Users:       []*MirrorUser{mu("alice", "alice@example.com", "Alice", "od-root")},
+	}
+	if err := st.ReplaceMirror(snap); err != nil {
+		t.Fatalf("初始写入失败: %v", err)
+	}
+	if err := st.ToLeaveCandidate("alice"); err != nil {
+		t.Fatalf("转入 leave_candidate 失败: %v", err)
+	}
+
+	// 用户仍可见于飞书，快照再次刷新。
+	if err := st.ReplaceMirror(snap); err != nil {
+		t.Fatalf("再次刷新失败: %v", err)
+	}
+	users, _ := st.MapUsersByUID()
+	if users["alice"].State != StateLeaveCandidate {
+		t.Errorf("快照刷新后 state = %q, 期望仍为 %q（生命周期不应被快照覆盖）",
+			users["alice"].State, StateLeaveCandidate)
+	}
+	// 关系表应重建无误。
+	ids, err := st.UserDeptIDs("alice")
+	if err != nil || len(ids) != 1 || ids[0] != "od-root" {
+		t.Errorf("关系表重建异常: %v -> %v", err, ids)
+	}
+}
+
+// TestRejectAbsentDepartmentsCleared 验证部门整体替换：快照之外的历史部门被清除，
+// 保证镜像 = 飞书当前有的部门，不会残留幽灵组。
+func TestRejectAbsentDepartmentsCleared(t *testing.T) {
+	st := openStore(t)
+	if err := st.ReplaceMirror(&MirrorSnapshot{
+		Departments: []*MirrorDepartment{md("od-old", "", "Old")},
+	}); err != nil {
+		t.Fatalf("初始写入失败: %v", err)
+	}
+	if err := st.ReplaceMirror(&MirrorSnapshot{
+		Departments: []*MirrorDepartment{md("od-new", "", "New")},
+	}); err != nil {
+		t.Fatalf("刷新失败: %v", err)
+	}
+	depts, _ := st.MapDepartmentsByID()
+	if _, ok := depts["od-new"]; !ok {
+		t.Errorf("新部门未写入")
+	}
+	if _, ok := depts["od-old"]; ok {
+		t.Errorf("快照之外的旧部门 od-old 仍残留在部门镜像中")
+	}
+}
+
+// TestStateMachine 验证生命周期状态机的合法转移与非法拦截。
+func TestStateMachine(t *testing.T) {
+	st := openStore(t)
+	if err := st.ReplaceMirror(&MirrorSnapshot{
+		Users: []*MirrorUser{mu("alice", "alice@example.com", "Alice")},
+	}); err != nil {
+		t.Fatalf("初始写入失败: %v", err)
+	}
+
+	// 合法链：active → leave_candidate → pending_confirm → confirmed_leave → deleted
+	checks := []struct {
+		name    string
+		apply   func() error
+		want    string
+	}{
+		{"机器确认离职", func() error { return st.ToLeaveCandidate("alice") }, StateLeaveCandidate},
+		{"发卡片待确认", func() error { return st.ToPendingConfirm("alice") }, StatePendingConfirm},
+		{"人工确认离职", func() error { return st.ConfirmLeave("alice") }, StateConfirmedLeave},
+		{"物化删除", func() error { return st.MarkDeleted("alice") }, StateDeleted},
+	}
+	for _, c := range checks {
+		if err := c.apply(); err != nil {
+			t.Fatalf("%s 失败: %v", c.name, err)
+		}
+		assertState(t, st, "alice", c.want)
+	}
+
+	// 非法转移：deleted 状态不能转 pending_confirm（状态机被绕过必须报错）。
+	if err := st.ToPendingConfirm("alice"); err == nil {
+		t.Errorf("deleted 状态的用户应无法转 pending_confirm，却成功了")
+	}
+	// deleted 后 revert 不应生效（已物理删除，不能回退，交给「重建」处理）。
+	if err := st.RevertToActive("alice"); err != nil {
+		t.Fatalf("RevertToActive 不应报错: %v", err)
+	}
+	assertState(t, st, "alice", StateDeleted)
+
+	// 双确认流程内可回退（重新入职）。
+	if err := st.ReplaceMirror(&MirrorSnapshot{
+		Users: []*MirrorUser{mu("bob", "bob@example.com", "Bob")},
+	}); err != nil {
+		t.Fatalf("写入 bob 失败: %v", err)
+	}
+	if err := st.ToLeaveCandidate("bob"); err != nil {
+		t.Fatalf("bob 转 leave_candidate 失败: %v", err)
+	}
+	if err := st.RevertToActive("bob"); err != nil {
+		t.Fatalf("bob revert 失败: %v", err)
+	}
+	assertState(t, st, "bob", StateActive)
+}
+
+// TestTokenOneTimeExpiryRevoke 验证一次性 token：试用即废、过期失效、作废后拒绝。
+func TestTokenOneTimeExpiryRevoke(t *testing.T) {
+	st := openStore(t)
+	if err := st.ReplaceMirror(&MirrorSnapshot{
+		Users: []*MirrorUser{mu("alice", "alice@example.com", "Alice")},
+	}); err != nil {
+		t.Fatalf("初始写入失败: %v", err)
+	}
+
+	// 正常 token：消费成功，返回 uid。
+	tok, err := st.CreateToken("alice", time.Hour)
+	if err != nil {
+		t.Fatalf("创建 token 失败: %v", err)
+	}
+	consumed, err := st.ConsumeToken(tok.Token)
+	if err != nil {
+		t.Fatalf("消费 token 失败: %v", err)
+	}
+	if consumed.UID != "alice" {
+		t.Errorf("消费返回 uid = %q, 期望 alice", consumed.UID)
+	}
+	// 再次使用同一 token 必须被拒（一次使用）。
+	if _, err := st.ConsumeToken(tok.Token); err == nil {
+		t.Errorf("已使用的 token 应被拒绝复用")
+	}
+
+	// 过期的 token：负 TTL 使 ExpiresAt 落在过去。
+	expired, err := st.CreateToken("alice", -time.Minute)
+	if err != nil {
+		t.Fatalf("创建过期 token 失败: %v", err)
+	}
+	if _, err := st.ConsumeToken(expired.Token); err == nil || !strings.Contains(err.Error(), "过期") {
+		t.Errorf("过期 token 应报过期错误，实际: %v", err)
+	}
+
+	// 作废的 token：用户重新可见后 revoke，未用 token 拒绝消费。
+	pending, err := st.CreateToken("alice", time.Hour)
+	if err != nil {
+		t.Fatalf("创建 token 失败: %v", err)
+	}
+	if err := st.RevokeTokensForUser("alice"); err != nil {
+		t.Fatalf("作废 token 失败: %v", err)
+	}
+	if _, err := st.ConsumeToken(pending.Token); err == nil {
+		t.Errorf("已作废的 token 应被拒绝消费")
+	}
+}
+
+func assertState(t *testing.T, st *Store, uid, want string) {
+	t.Helper()
+	users, err := st.MapUsersByUID()
+	if err != nil {
+		t.Fatalf("读取用户失败: %v", err)
+	}
+	u, ok := users[uid]
+	if !ok {
+		t.Fatalf("用户 %s 不存在", uid)
+	}
+	if u.State != want {
+		t.Errorf("用户 %s state = %q, 期望 %q", uid, u.State, want)
+	}
+}

internal/store/store.go

@@ -87,7 +87,8 @@ func Open(path string) (*Store, error) {
 	}
 	sqlDB.SetMaxOpenConns(1)
 
-	if err := db.AutoMigrate(&Account{}, &Group{}, &SyncRun{}); err != nil {
+	if err := db.AutoMigrate(&MirrorUser{}, &MirrorDepartment{}, &MirrorUserDepartment{},
+		&ResignConfirmToken{}, &SyncRun{}, &Account{}, &Group{}); err != nil {
 		return nil, fmt.Errorf("建表失败: %w", err)
 	}
 	return &Store{db: db}, nil