feat(导出时间筛选): AUG26-014 统一时间筛选与临期导出，归档并同步主 Spec 与证据链

统一时间筛选：新增共享严格解析器 pkg/utils/time_range.go，只接受带显式时区的 RFC3339 秒级时间（拒绝小数秒、无时区、date-only、空格分隔、±hhmm、未补零、非法日期与越界偏移），闭区间含两端、归一为 UTC 瞬时，创建期与执行期共用同一份实现。

端点改造（13 个入口）：IoT 卡导入任务、设备导入任务、导出任务列表、订单列表参数名不变仅收紧解析；换货、分配记录、代理充值、临期列表改名 start_time/end_time（旧参数名显式拒绝）；提现记录两处删除解析失败静默跳过，非法参数一律 1001；授权记录由起始闭结束开改为闭区间含两端；临期列表改按当前生效主套餐最终到期时刻比较，保留剩余天数上下限与既有粗放窗口。

临期导出新建：新场景 expiring_asset 与受控入口 POST /api/admin/expiring-assets/export，复用列表候选预筛与最终到期推算，一行一资产、加油包不单独成行，列序与 111 §18.1 逐列一致，店铺/业务员/用户组按执行时当前归属补充且不超出创建时冻结范围。

佣金明细导出新增按创建时间闭区间筛选（原佣金与回溯两条分支各自创建时间列），记录粒度、列定义与余额口径不变。

冻结与遗留任务：创建期把筛选与时间边界规范化为 UTC RFC3339 秒级串写入既有 query_json，无新列无迁移；执行期只按冻结值严格解析，非法冻结值在任何分片与文件动作前落任务失败并写安全摘要，不放行全量；重试沿用原快照。达量预警导出执行期同样纳入严格解析（其入口契约、列定义与触发快照口径不变）。

归档 add-export-time-filter-standards 并新建主 Spec openspec/specs/export-time-filter/spec.md，同步 requirement-evidence.json 与入口能力矩阵，README 导出场景清单更新为 11 个场景。

验证：junhong_cmp_test + 本地隔离 Redis（DB7，测试部署共享队列 DB6 未被占用）实跑 85 PASS / 0 FAIL（接受/拒绝集合、区间与顺序语义、列表与导出同筛选行集一致、代理 HTTP 全链路与范围冻结、遗留旧格式任务安全失败、列与余额口径回归、表头逐字），门禁 gofmt/go build/gendocs 两次一致/openspec validate/doctor/context-health 全绿；无 Schema 变更、无迁移、无运行时开关。

internal/exporter/agent_recharge_scene.go

@@ -27,7 +27,10 @@ func (s *AgentRechargeDataSource) Scene() string {
 // Count 统计代理充值导出行数。
 func (s *AgentRechargeDataSource) Count(ctx context.Context, params ExportParams) (int, error) {
 	var total int64
-	query := s.applyFilters(s.baseQuery(ctx), params)
+	query, err := s.applyFilters(s.baseQuery(ctx), params)
+	if err != nil {
+		return 0, err
+	}
 	if err := query.Count(&total).Error; err != nil {
 		return 0, err
 	}
@@ -49,7 +52,11 @@ func (s *AgentRechargeDataSource) Fetch(ctx context.Context, params ExportParams
 	}
 
 	var items []agentRechargeExportRow
-	query := s.applyFilters(s.baseQuery(ctx), params).
+	filtered, err := s.applyFilters(s.baseQuery(ctx), params)
+	if err != nil {
+		return nil, err
+	}
+	query := filtered.
 		Select(`
 			r.recharge_no,
 			r.amount,
@@ -121,7 +128,7 @@ func (s *AgentRechargeDataSource) baseQuery(ctx context.Context) *gorm.DB {
 	return s.db.WithContext(ctx).Table("tb_agent_recharge_record AS r").Where("r.deleted_at IS NULL")
 }
 
-func (s *AgentRechargeDataSource) applyFilters(query *gorm.DB, params ExportParams) *gorm.DB {
+func (s *AgentRechargeDataSource) applyFilters(query *gorm.DB, params ExportParams) (*gorm.DB, error) {
 	query = applyExportShopScope(query, params, "r.shop_id")
 	if shopID, ok := filterUint(params.Filters, "shop_id"); ok {
 		query = query.Where("r.shop_id = ?", shopID)
@@ -129,13 +136,17 @@ func (s *AgentRechargeDataSource) applyFilters(query *gorm.DB, params ExportPara
 	if status, ok := filterInt(params.Filters, "status"); ok {
 		query = query.Where("r.status = ?", status)
 	}
-	if start, ok := filterTime(params.Filters, "start_date"); ok {
-		query = query.Where("r.created_at >= ?", start)
+	start, end, err := strictTimeRange(params.Filters)
+	if err != nil {
+		return nil, err
 	}
-	if end, ok := filterEndDate(params.Filters, "end_date"); ok {
-		query = query.Where("r.created_at <= ?", end)
+	if start != nil {
+		query = query.Where("r.created_at >= ?", *start)
 	}
-	return query
+	if end != nil {
+		query = query.Where("r.created_at <= ?", *end)
+	}
+	return query, nil
 }
 
 type agentRechargeExportRow struct {

internal/exporter/commission_record_scene.go

@@ -30,12 +30,20 @@ func (s *CommissionRecordDataSource) Scene() string {
 
 // Count 统计原佣金与回溯明细的合并行数。
 func (s *CommissionRecordDataSource) Count(ctx context.Context, params ExportParams) (int, error) {
+	original, err := s.originalBranch(ctx, params)
+	if err != nil {
+		return 0, err
+	}
 	var originalTotal int64
-	if err := s.originalBranch(ctx, params).Count(&originalTotal).Error; err != nil {
+	if err := original.Count(&originalTotal).Error; err != nil {
+		return 0, err
+	}
+	clawback, err := s.clawbackBranch(ctx, params)
+	if err != nil {
 		return 0, err
 	}
 	var clawbackTotal int64
-	if err := s.clawbackBranch(ctx, params).Count(&clawbackTotal).Error; err != nil {
+	if err := clawback.Count(&clawbackTotal).Error; err != nil {
 		return 0, err
 	}
 	return int(originalTotal + clawbackTotal), nil
@@ -56,9 +64,17 @@ func (s *CommissionRecordDataSource) Fetch(ctx context.Context, params ExportPar
 		return [][]string{}, nil
 	}
 
+	original, err := s.originalBranch(ctx, params)
+	if err != nil {
+		return nil, err
+	}
+	clawback, err := s.clawbackBranch(ctx, params)
+	if err != nil {
+		return nil, err
+	}
 	union := s.db.WithContext(ctx).
 		Raw("SELECT * FROM (?) AS ledger_original UNION ALL SELECT * FROM (?) AS ledger_clawback",
-			s.originalBranch(ctx, params), s.clawbackBranch(ctx, params))
+			original, clawback)
 	var items []commissionRecordExportRow
 	query := s.db.WithContext(ctx).Table("(?) AS ledger", union).
 		Select(`
@@ -108,7 +124,7 @@ func (s *CommissionRecordDataSource) Fetch(ctx context.Context, params ExportPar
 }
 
 // originalBranch 构造原佣金导出分支：自带场景筛选与数据范围。
-func (s *CommissionRecordDataSource) originalBranch(ctx context.Context, params ExportParams) *gorm.DB {
+func (s *CommissionRecordDataSource) originalBranch(ctx context.Context, params ExportParams) (*gorm.DB, error) {
 	query := s.db.WithContext(ctx).Table("tb_commission_record AS c").
 		Where("c.deleted_at IS NULL").
 		Joins("LEFT JOIN tb_order o ON c.order_id = o.id AND o.deleted_at IS NULL").
@@ -119,11 +135,11 @@ func (s *CommissionRecordDataSource) originalBranch(ctx context.Context, params
 			`c.released_at, c.created_at, NULL::bigint AS original_commission_id, ''::varchar AS refund_no, ` +
 			`NULL::boolean AS withdrawable`)
 	query = applyExportShopScope(query, params, "c.shop_id")
-	return applyCommissionExportFilters(query, params, "c.shop_id", "c.commission_source", "c.status", "o.order_no")
+	return applyCommissionExportFilters(query, params, "c.shop_id", "c.commission_source", "c.created_at", "c.status", "o.order_no")
 }
 
 // clawbackBranch 构造回溯明细导出分支：资产维度取原佣金关联的卡或设备，保持与原佣金同一口径。
-func (s *CommissionRecordDataSource) clawbackBranch(ctx context.Context, params ExportParams) *gorm.DB {
+func (s *CommissionRecordDataSource) clawbackBranch(ctx context.Context, params ExportParams) (*gorm.DB, error) {
 	query := s.db.WithContext(ctx).Table("tb_commission_clawback_record AS g").
 		Joins("LEFT JOIN tb_commission_record oc ON oc.id = g.original_commission_id").
 		Joins("LEFT JOIN tb_order o ON g.order_id = o.id AND o.deleted_at IS NULL").
@@ -134,7 +150,7 @@ func (s *CommissionRecordDataSource) clawbackBranch(ctx context.Context, params
 			`g.commission_source, g.amount, g.balance_after, g.status, ` +
 			`NULL::timestamp AS released_at, g.created_at, g.original_commission_id, g.refund_no, g.withdrawable`)
 	query = applyExportShopScope(query, params, "g.shop_id")
-	return applyCommissionExportFilters(query, params, "g.shop_id", "g.commission_source", "g.status", "g.order_no")
+	return applyCommissionExportFilters(query, params, "g.shop_id", "g.commission_source", "g.created_at", "g.status", "g.order_no")
 }
 
 // 导出分支来源标识与后台列表保持一致，便于导出结果与列表逐行核对。
@@ -144,7 +160,8 @@ const (
 )
 
 // applyCommissionExportFilters 把佣金明细导出的筛选条件应用到单个分支。
-func applyCommissionExportFilters(query *gorm.DB, params ExportParams, shopColumn, sourceColumn, statusColumn, orderNoColumn string) *gorm.DB {
+// 时间范围按各分支自身的创建时间列做闭区间比较，覆盖原佣金与回溯明细两条分支。
+func applyCommissionExportFilters(query *gorm.DB, params ExportParams, shopColumn, sourceColumn, timeColumn, statusColumn, orderNoColumn string) (*gorm.DB, error) {
 	if shopID, ok := filterUint(params.Filters, "shop_id"); ok {
 		query = query.Where(shopColumn+" = ?", shopID)
 	}
@@ -157,7 +174,17 @@ func applyCommissionExportFilters(query *gorm.DB, params ExportParams, shopColum
 	if orderNo, ok := filterString(params.Filters, "order_no"); ok {
 		query = query.Where(orderNoColumn+" = ?", orderNo)
 	}
-	return query
+	start, end, err := strictTimeRange(params.Filters)
+	if err != nil {
+		return nil, err
+	}
+	if start != nil {
+		query = query.Where(timeColumn+" >= ?", *start)
+	}
+	if end != nil {
+		query = query.Where(timeColumn+" <= ?", *end)
+	}
+	return query, nil
 }
 
 // commissionRecordExportRow 是佣金明细导出的合并行投影，金额一律保持分。

internal/exporter/exchange_scene.go

@@ -27,7 +27,10 @@ func (s *ExchangeDataSource) Scene() string {
 // Count 统计换货记录导出行数。
 func (s *ExchangeDataSource) Count(ctx context.Context, params ExportParams) (int, error) {
 	var total int64
-	query := s.applyFilters(s.baseQuery(ctx), params)
+	query, err := s.applyFilters(s.baseQuery(ctx), params)
+	if err != nil {
+		return 0, err
+	}
 	if err := query.Count(&total).Error; err != nil {
 		return 0, err
 	}
@@ -49,7 +52,11 @@ func (s *ExchangeDataSource) Fetch(ctx context.Context, params ExportParams, off
 	}
 
 	var items []exchangeExportRow
-	query := s.applyFilters(s.baseQuery(ctx), params).
+	filtered, err := s.applyFilters(s.baseQuery(ctx), params)
+	if err != nil {
+		return nil, err
+	}
+	query := filtered.
 		Select(`
 			e.exchange_no,
 			e.flow_type,
@@ -104,7 +111,7 @@ func (s *ExchangeDataSource) baseQuery(ctx context.Context) *gorm.DB {
 	return s.db.WithContext(ctx).Table("tb_exchange_order AS e").Where("e.deleted_at IS NULL")
 }
 
-func (s *ExchangeDataSource) applyFilters(query *gorm.DB, params ExportParams) *gorm.DB {
+func (s *ExchangeDataSource) applyFilters(query *gorm.DB, params ExportParams) (*gorm.DB, error) {
 	query = applyExportShopScope(query, params, "e.shop_id")
 	if status, ok := filterInt(params.Filters, "status"); ok {
 		query = query.Where("e.status = ?", status)
@@ -114,13 +121,17 @@ func (s *ExchangeDataSource) applyFilters(query *gorm.DB, params ExportParams) *
 	}
 	query = applyExchangeAssetKeyword(query, "old", filterValue(params.Filters, "old_asset_keyword"))
 	query = applyExchangeAssetKeyword(query, "new", filterValue(params.Filters, "new_asset_keyword"))
-	if start, ok := filterTime(params.Filters, "created_at_start"); ok {
-		query = query.Where("e.created_at >= ?", start)
+	start, end, err := strictTimeRange(params.Filters)
+	if err != nil {
+		return nil, err
 	}
-	if end, ok := filterTime(params.Filters, "created_at_end"); ok {
-		query = query.Where("e.created_at <= ?", end)
+	if start != nil {
+		query = query.Where("e.created_at >= ?", *start)
 	}
-	return query
+	if end != nil {
+		query = query.Where("e.created_at <= ?", *end)
+	}
+	return query, nil
 }
 
 func applyExchangeAssetKeyword(query *gorm.DB, side, keyword string) *gorm.DB {

internal/exporter/expiring_asset_scene.go

@@ -0,0 +1,229 @@
+package exporter
+
+import (
+	"context"
+	"strconv"
+
+	"gorm.io/gorm"
+
+	"github.com/break/junhong_cmp_fiber/internal/model/dto"
+	packageexpiryquery "github.com/break/junhong_cmp_fiber/internal/query/packageexpiry"
+	"github.com/break/junhong_cmp_fiber/pkg/constants"
+	"github.com/break/junhong_cmp_fiber/pkg/errors"
+)
+
+// ExpiringAssetDataSource 临期资产导出数据源。
+//
+// 粒度为一行对应一项资产，取该资产当前生效主套餐的最终到期时间与剩余天数，加油包不单独成行。
+// 候选预筛、最终到期推算与行序全部复用 internal/query/packageexpiry 的列表实现，不另写第二套到期口径。
+// 店铺、业务员与用户组按导出执行时的当前归属补充，结果仍受任务创建时冻结的可见店铺范围约束。
+type ExpiringAssetDataSource struct {
+	db      *gorm.DB
+	expiryQ *packageexpiryquery.Query
+}
+
+// NewExpiringAssetDataSource 创建临期资产导出数据源。
+func NewExpiringAssetDataSource(db *gorm.DB) *ExpiringAssetDataSource {
+	return &ExpiringAssetDataSource{db: db, expiryQ: packageexpiryquery.NewQuery(db)}
+}
+
+// Scene 返回导出场景编码。
+func (s *ExpiringAssetDataSource) Scene() string {
+	return constants.ExportTaskSceneExpiringAsset
+}
+
+// Count 统计临期资产导出行数，与列表同一筛选下的行集合一致。
+func (s *ExpiringAssetDataSource) Count(ctx context.Context, params ExportParams) (int, error) {
+	items, err := s.items(ctx, params)
+	if err != nil {
+		return 0, err
+	}
+	return len(items), nil
+}
+
+// Headers 返回临期资产导出表头，列序与 111.md §18.1 逐列一致。
+func (s *ExpiringAssetDataSource) Headers(context.Context, ExportParams) ([]string, error) {
+	return []string{
+		"店铺", "业务员", "用户组", "资产类型", "设备类型", "设备型号", "资产标识", "当前套餐", "到期时间", "剩余天数",
+	}, nil
+}
+
+// Fetch 按 offset/limit 查询临期资产导出数据。
+func (s *ExpiringAssetDataSource) Fetch(ctx context.Context, params ExportParams, offset, limit int) ([][]string, error) {
+	if limit <= 0 {
+		return [][]string{}, nil
+	}
+	items, err := s.items(ctx, params)
+	if err != nil {
+		return nil, err
+	}
+	if offset >= len(items) {
+		return [][]string{}, nil
+	}
+	end := offset + limit
+	if end > len(items) {
+		end = len(items)
+	}
+	page := items[offset:end]
+
+	shopIDs := make([]uint, 0, len(page))
+	deviceIDs := make([]uint, 0, len(page))
+	for _, item := range page {
+		if item.ShopID != nil {
+			shopIDs = append(shopIDs, *item.ShopID)
+		}
+		if item.AssetType == constants.AssetTypeDevice {
+			deviceIDs = append(deviceIDs, item.AssetID)
+		}
+	}
+	shops, err := s.loadShopOwners(ctx, normalizeUintSlice(shopIDs))
+	if err != nil {
+		return nil, err
+	}
+	ownerIDs := make([]uint, 0, len(shops))
+	for _, shop := range shops {
+		if shop.BusinessOwnerAccountID != nil {
+			ownerIDs = append(ownerIDs, *shop.BusinessOwnerAccountID)
+		}
+	}
+	ownerIDs = normalizeUintSlice(ownerIDs)
+	ownerNames, err := loadAccountNames(ctx, s.db, ownerIDs)
+	if err != nil {
+		return nil, err
+	}
+	groupNames, err := businessUserGroupNames(ctx, s.db, ownerIDs)
+	if err != nil {
+		return nil, err
+	}
+	devices, err := s.loadDeviceAttributes(ctx, normalizeUintSlice(deviceIDs))
+	if err != nil {
+		return nil, err
+	}
+
+	rows := make([][]string, 0, len(page))
+	for _, item := range page {
+		var shopName, ownerName, groupName string
+		if item.ShopID != nil {
+			shop := shops[*item.ShopID]
+			shopName = shop.ShopName
+			if shop.BusinessOwnerAccountID != nil {
+				ownerName = ownerNames[*shop.BusinessOwnerAccountID]
+				groupName = currentOwnerGroupName(groupNames, shop.BusinessOwnerAccountID)
+			}
+		}
+		var deviceType, deviceModel string
+		if item.AssetType == constants.AssetTypeDevice {
+			device := devices[item.AssetID]
+			deviceType, deviceModel = device.DeviceType, device.DeviceModel
+		}
+		rows = append(rows, []string{
+			shopName,
+			ownerName,
+			groupName,
+			assetTypeName(item.AssetType),
+			deviceType,
+			deviceModel,
+			item.Identifier,
+			item.PackageName,
+			formatOptionalTime(item.EstimatedFinalExpiresAt),
+			formatRemainingDaysValue(item.DaysUntilFinalExpiry),
+		})
+	}
+	return rows, nil
+}
+
+// items 复用列表同一候选预筛与最终到期推算，数据范围来自任务创建时冻结的可见店铺范围。
+func (s *ExpiringAssetDataSource) items(ctx context.Context, params ExportParams) ([]dto.ExpiringAssetItem, error) {
+	filter, err := s.listFilter(params)
+	if err != nil {
+		return nil, err
+	}
+	scope := func(query *gorm.DB) *gorm.DB {
+		return applyExportShopScope(query, params, "shop_id")
+	}
+	return s.expiryQ.ListAllWithScope(ctx, scope, filter)
+}
+
+// listFilter 把任务冻结的筛选快照转换为列表同一口径的筛选条件。
+func (s *ExpiringAssetDataSource) listFilter(params ExportParams) (packageexpiryquery.ListFilter, error) {
+	filter := packageexpiryquery.ListFilter{
+		AssetType: filterValue(params.Filters, "asset_type"),
+		Keyword:   filterValue(params.Filters, "keyword"),
+	}
+	if shopID, ok := filterUint(params.Filters, "shop_id"); ok {
+		filter.ShopID = &shopID
+	}
+	if packageID, ok := filterUint(params.Filters, "package_id"); ok {
+		filter.PackageID = &packageID
+	}
+	if daysMin, ok := filterInt(params.Filters, "days_min"); ok {
+		filter.DaysMin = &daysMin
+	}
+	if daysMax, ok := filterInt(params.Filters, "days_max"); ok {
+		filter.DaysMax = &daysMax
+	}
+	start, end, err := strictTimeRange(params.Filters)
+	if err != nil {
+		return packageexpiryquery.ListFilter{}, err
+	}
+	filter.StartTime, filter.EndTime = start, end
+	return filter, nil
+}
+
+func (s *ExpiringAssetDataSource) loadShopOwners(ctx context.Context, shopIDs []uint) (map[uint]expiringAssetShop, error) {
+	result := make(map[uint]expiringAssetShop, len(shopIDs))
+	if len(shopIDs) == 0 {
+		return result, nil
+	}
+	var rows []expiringAssetShop
+	if err := s.db.WithContext(ctx).Table("tb_shop").
+		Select("id, shop_name, business_owner_account_id").
+		Where("id IN ? AND deleted_at IS NULL", shopIDs).
+		Scan(&rows).Error; err != nil {
+		return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询临期导出店铺当前归属失败")
+	}
+	for _, row := range rows {
+		result[row.ID] = row
+	}
+	return result, nil
+}
+
+func (s *ExpiringAssetDataSource) loadDeviceAttributes(ctx context.Context, deviceIDs []uint) (map[uint]expiringAssetDevice, error) {
+	result := make(map[uint]expiringAssetDevice, len(deviceIDs))
+	if len(deviceIDs) == 0 {
+		return result, nil
+	}
+	var rows []expiringAssetDevice
+	if err := s.db.WithContext(ctx).Table("tb_device").
+		Select("id, device_type, device_model").
+		Where("id IN ?", deviceIDs).
+		Scan(&rows).Error; err != nil {
+		return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询临期导出设备类型与型号失败")
+	}
+	for _, row := range rows {
+		result[row.ID] = row
+	}
+	return result, nil
+}
+
+// expiringAssetShop 是执行时当前店铺归属投影。
+type expiringAssetShop struct {
+	ID                     uint   `gorm:"column:id"`
+	ShopName               string `gorm:"column:shop_name"`
+	BusinessOwnerAccountID *uint  `gorm:"column:business_owner_account_id"`
+}
+
+// expiringAssetDevice 是执行时当前设备类型与型号投影。
+type expiringAssetDevice struct {
+	ID          uint   `gorm:"column:id"`
+	DeviceType  string `gorm:"column:device_type"`
+	DeviceModel string `gorm:"column:device_model"`
+}
+
+// formatRemainingDaysValue 输出列表同一最终到期推算给出的剩余上海自然日天数；无法精确推算时为空。
+func formatRemainingDaysValue(days *int) string {
+	if days == nil {
+		return ""
+	}
+	return strconv.Itoa(*days)
+}

internal/exporter/order_scene.go

@@ -148,11 +148,15 @@ func (s *OrderDataSource) applyFilters(ctx context.Context, query *gorm.DB, para
 	if sellerShopID, ok := filterUint(params.Filters, "seller_shop_id"); ok {
 		query = query.Where("o.seller_shop_id = ?", sellerShopID)
 	}
-	if start, ok := filterTime(params.Filters, "start_time"); ok {
-		query = query.Where("o.created_at >= ?", start)
+	start, end, err := strictTimeRange(params.Filters)
+	if err != nil {
+		return nil, err
 	}
-	if end, ok := filterTime(params.Filters, "end_time"); ok {
-		query = query.Where("o.created_at <= ?", end)
+	if start != nil {
+		query = query.Where("o.created_at >= ?", *start)
+	}
+	if end != nil {
+		query = query.Where("o.created_at <= ?", *end)
 	}
 	if buyerPhone, ok := filterString(params.Filters, "buyer_phone"); ok {
 		query = query.Where("o.buyer_phone = ?", buyerPhone)

internal/exporter/ownership_columns.go

@@ -0,0 +1,60 @@
+package exporter
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+
+	"github.com/break/junhong_cmp_fiber/pkg/errors"
+)
+
+// businessUserGroupNames 按执行时当前业务员账号批量推导业务用户组名称。
+// 用户组不落在店铺库表上，按既有实时推导读取，多个组按排序拼接；达量预警与临期导出共用同一口径。
+func businessUserGroupNames(ctx context.Context, db *gorm.DB, ownerIDs []uint) (map[uint]string, error) {
+	result := make(map[uint]string, len(ownerIDs))
+	if len(ownerIDs) == 0 {
+		return result, nil
+	}
+	var rows []struct {
+		AccountID uint   `gorm:"column:account_id"`
+		GroupName string `gorm:"column:group_name"`
+	}
+	if err := db.WithContext(ctx).Table("tb_business_user_group_member AS m").
+		Select("m.account_id, g.name AS group_name").
+		Joins("JOIN tb_business_user_group AS g ON g.id = m.business_user_group_id AND g.deleted_at IS NULL").
+		Where("m.account_id IN ? AND m.deleted_at IS NULL", ownerIDs).
+		Order("m.account_id ASC, g.sort_order ASC, g.id ASC").
+		Scan(&rows).Error; err != nil {
+		return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询业务员业务用户组失败")
+	}
+	for _, row := range rows {
+		if existing := result[row.AccountID]; existing != "" {
+			result[row.AccountID] = existing + "、" + row.GroupName
+			continue
+		}
+		result[row.AccountID] = row.GroupName
+	}
+	return result, nil
+}
+
+// loadAccountNames 按账号 ID 批量读取账号名称，供导出侧执行时当前归属补充。
+func loadAccountNames(ctx context.Context, db *gorm.DB, accountIDs []uint) (map[uint]string, error) {
+	result := make(map[uint]string, len(accountIDs))
+	if len(accountIDs) == 0 {
+		return result, nil
+	}
+	var rows []struct {
+		ID       uint   `gorm:"column:id"`
+		Username string `gorm:"column:username"`
+	}
+	if err := db.WithContext(ctx).Table("tb_account").
+		Select("id, username").
+		Where("id IN ? AND deleted_at IS NULL", accountIDs).
+		Scan(&rows).Error; err != nil {
+		return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询账号名称失败")
+	}
+	for _, row := range rows {
+		result[row.ID] = row.Username
+	}
+	return result, nil
+}

internal/exporter/package_traffic_alert_scene.go

@@ -39,7 +39,11 @@ func (s *PackageTrafficAlertDataSource) Count(ctx context.Context, params Export
 		return 0, err
 	}
 	var total int64
-	if err := s.applyFilters(s.baseQuery(ctx, params), params).Count(&total).Error; err != nil {
+	query, err := s.applyFilters(s.baseQuery(ctx, params), params)
+	if err != nil {
+		return 0, err
+	}
+	if err := query.Count(&total).Error; err != nil {
 		return 0, err
 	}
 	return int(total), nil
@@ -64,7 +68,11 @@ func (s *PackageTrafficAlertDataSource) Fetch(ctx context.Context, params Export
 		return nil, err
 	}
 	var items []packageTrafficAlertExportRow
-	query := s.applyFilters(s.baseQuery(ctx, params), params).
+	filtered, err := s.applyFilters(s.baseQuery(ctx, params), params)
+	if err != nil {
+		return nil, err
+	}
+	query := filtered.
 		Select(`
 			a.asset_type,
 			a.asset_identifier_snapshot,
@@ -144,8 +152,9 @@ func (s *PackageTrafficAlertDataSource) baseQuery(ctx context.Context, params Ex
 }
 
 // applyFilters 应用导出筛选快照。
-// 筛选口径与列表一致，都作用在触发快照列上；时间范围按触发时间的闭区间解析。
-func (s *PackageTrafficAlertDataSource) applyFilters(query *gorm.DB, params ExportParams) *gorm.DB {
+// 筛选口径与列表一致，都作用在触发快照列上；时间范围按触发时间闭区间解析，
+// 冻结值一律按统一严格解析器解析，非法值返回错误由调用方落任务失败。
+func (s *PackageTrafficAlertDataSource) applyFilters(query *gorm.DB, params ExportParams) (*gorm.DB, error) {
 	if packageID, ok := filterUint(params.Filters, "package_id"); ok {
 		query = query.Where("a.package_id = ?", packageID)
 	}
@@ -167,16 +176,20 @@ func (s *PackageTrafficAlertDataSource) applyFilters(query *gorm.DB, params Expo
 		query = query.Where("a.threshold_percent_snapshot = ?",
 			packagetrafficalert.NormalizeThresholdPercent(threshold))
 	}
-	if startTime, ok := filterTime(params.Filters, "start_time"); ok {
-		query = query.Where("a.triggered_at >= ?", startTime.UTC())
+	startTime, endTime, err := strictTimeRange(params.Filters)
+	if err != nil {
+		return nil, err
 	}
-	if endTime, ok := filterTime(params.Filters, "end_time"); ok {
-		query = query.Where("a.triggered_at <= ?", endTime.UTC())
+	if startTime != nil {
+		query = query.Where("a.triggered_at >= ?", *startTime)
+	}
+	if endTime != nil {
+		query = query.Where("a.triggered_at <= ?", *endTime)
 	}
 	if status, ok := filterInt(params.Filters, "notification_status"); ok {
 		query = applyAlertNotificationStatusFilter(query, status)
 	}
-	return query
+	return query, nil
 }
 
 // applyAlertNotificationStatusFilter 按通知投递结果筛选，口径与读侧列表一致。
@@ -206,7 +219,6 @@ func applyAlertNotificationStatusFilter(query *gorm.DB, status int) *gorm.DB {
 // 用户组不落在店铺库表上，按既有实时推导读取，多个组按排序拼接。
 func (s *PackageTrafficAlertDataSource) loadBusinessUserGroupNames(ctx context.Context,
 	items []packageTrafficAlertExportRow) (map[uint]string, error) {
-	result := make(map[uint]string)
 	ownerIDs := make([]uint, 0, len(items))
 	seen := make(map[uint]struct{}, len(items))
 	for _, item := range items {
@@ -219,29 +231,7 @@ func (s *PackageTrafficAlertDataSource) loadBusinessUserGroupNames(ctx context.C
 		seen[*item.CurrentOwnerID] = struct{}{}
 		ownerIDs = append(ownerIDs, *item.CurrentOwnerID)
 	}
-	if len(ownerIDs) == 0 {
-		return result, nil
-	}
-	var rows []struct {
-		AccountID uint   `gorm:"column:account_id"`
-		GroupName string `gorm:"column:group_name"`
-	}
-	if err := s.db.WithContext(ctx).Table("tb_business_user_group_member AS m").
-		Select("m.account_id, g.name AS group_name").
-		Joins("JOIN tb_business_user_group AS g ON g.id = m.business_user_group_id AND g.deleted_at IS NULL").
-		Where("m.account_id IN ? AND m.deleted_at IS NULL", ownerIDs).
-		Order("m.account_id ASC, g.sort_order ASC, g.id ASC").
-		Scan(&rows).Error; err != nil {
-		return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询业务员业务用户组失败")
-	}
-	for _, row := range rows {
-		if existing := result[row.AccountID]; existing != "" {
-			result[row.AccountID] = existing + "、" + row.GroupName
-			continue
-		}
-		result[row.AccountID] = row.GroupName
-	}
-	return result, nil
+	return businessUserGroupNames(ctx, s.db, ownerIDs)
 }
 
 // packageTrafficAlertExportRow 是预警导出的一行原始投影。

internal/exporter/registry.go

@@ -38,6 +38,7 @@ func NewDefaultRegistry(db *gorm.DB) *Registry {
 		NewExchangeDataSource(db),
 		NewCommissionRecordDataSource(db),
 		NewPackageTrafficAlertDataSource(db),
+		NewExpiringAssetDataSource(db),
 	)
 }
 
@@ -75,7 +76,8 @@ func IsSupportedScene(scene string) bool {
 		constants.ExportTaskSceneRefund,
 		constants.ExportTaskSceneExchange,
 		constants.ExportTaskSceneCommissionRecord,
-		constants.ExportTaskScenePackageTrafficAlert:
+		constants.ExportTaskScenePackageTrafficAlert,
+		constants.ExportTaskSceneExpiringAsset:
 		return true
 	default:
 		return false

internal/exporter/time_filters.go

@@ -0,0 +1,122 @@
+package exporter
+
+import (
+	"time"
+
+	"github.com/break/junhong_cmp_fiber/pkg/constants"
+	"github.com/break/junhong_cmp_fiber/pkg/errors"
+	"github.com/break/junhong_cmp_fiber/pkg/utils"
+)
+
+// 受影响导出场景统一使用的冻结时间筛选键。
+const (
+	exportTimeFilterStartKey = "start_time"
+	exportTimeFilterEndKey   = "end_time"
+)
+
+// timeFilterScenes 是纳入统一时间筛选契约的导出场景。
+// 未列入的场景保持既有宽松解析，见设计文档「已知差异登记」。
+// 达量预警的列表与创建入口仍接受全局宽松时间格式并由创建期归一为 UTC RFC3339 秒级串，
+// 但执行期同样只按冻结值严格解析，冻结值非法时任务落失败。
+var timeFilterScenes = map[string]struct{}{
+	constants.ExportTaskSceneExchange:            {},
+	constants.ExportTaskSceneAgentRecharge:       {},
+	constants.ExportTaskSceneOrder:               {},
+	constants.ExportTaskSceneCommissionRecord:    {},
+	constants.ExportTaskSceneExpiringAsset:       {},
+	constants.ExportTaskScenePackageTrafficAlert: {},
+}
+
+// legacyTimeFilterKeys 是受影响场景必须拒绝的旧时间筛选键。
+// 键存在且非空时一律拒绝，避免旧前端静默丢条件后导出全量数据。
+var legacyTimeFilterKeys = map[string][]string{
+	constants.ExportTaskSceneExchange:      {"created_at_start", "created_at_end"},
+	constants.ExportTaskSceneAgentRecharge: {"start_date", "end_date"},
+}
+
+// NormalizeTaskTimeFilters 在创建导出任务时按场景校验并规范化时间边界。
+// 规范化结果为 UTC RFC3339 秒级字符串，随筛选快照一并冻结；
+// 非法格式、旧参数键与开始晚于结束一律在创建期拒绝。
+func NormalizeTaskTimeFilters(scene string, query map[string]interface{}) error {
+	if !isTimeFilterScene(scene) {
+		return nil
+	}
+	filters, ok := query["filters"].(map[string]interface{})
+	if !ok {
+		return nil
+	}
+	if err := rejectLegacyTimeFilterKeys(scene, filters); err != nil {
+		return err
+	}
+	start, end, err := parseFrozenTimeRange(filters)
+	if err != nil {
+		return err
+	}
+	if start != nil {
+		filters[exportTimeFilterStartKey] = utils.FormatTimeFilterValue(*start)
+	}
+	if end != nil {
+		filters[exportTimeFilterEndKey] = utils.FormatTimeFilterValue(*end)
+	}
+	return nil
+}
+
+// ValidateTaskTimeFilters 校验导出任务筛选快照中的时间边界，创建期与执行期共用。
+// 非法值（含变更前遗留任务的旧格式冻结值）返回错误，由调用方把任务落为失败并写安全失败摘要，
+// 不得忽略该条件后放行全量数据。
+func ValidateTaskTimeFilters(scene string, filters map[string]any) error {
+	if !isTimeFilterScene(scene) {
+		return nil
+	}
+	if err := rejectLegacyTimeFilterKeys(scene, filters); err != nil {
+		return err
+	}
+	_, _, err := parseFrozenTimeRange(filters)
+	return err
+}
+
+// strictTimeRange 解析任务冻结的 start_time/end_time 闭区间，供受影响场景构造执行期筛选。
+// 冻结值必须是创建期规范化后的带时区 RFC3339 秒级字符串，任一端缺省表示该端不限。
+func strictTimeRange(filters map[string]any) (*time.Time, *time.Time, error) {
+	return parseFrozenTimeRange(filters)
+}
+
+func isTimeFilterScene(scene string) bool {
+	_, ok := timeFilterScenes[scene]
+	return ok
+}
+
+func parseFrozenTimeRange(filters map[string]any) (*time.Time, *time.Time, error) {
+	start, err := frozenTimeFilterValue(filters, exportTimeFilterStartKey)
+	if err != nil {
+		return nil, nil, err
+	}
+	end, err := frozenTimeFilterValue(filters, exportTimeFilterEndKey)
+	if err != nil {
+		return nil, nil, err
+	}
+	return utils.ParseTimeRange(start, end)
+}
+
+func frozenTimeFilterValue(filters map[string]any, key string) (string, error) {
+	value, ok := filters[key]
+	if !ok || value == nil {
+		return "", nil
+	}
+	text, ok := value.(string)
+	if !ok {
+		return "", utils.TimeFilterFormatError(key)
+	}
+	return text, nil
+}
+
+func rejectLegacyTimeFilterKeys(scene string, filters map[string]any) error {
+	for _, key := range legacyTimeFilterKeys[scene] {
+		text, exists := filters[key].(string)
+		if !exists || text == "" {
+			continue
+		}
+		return errors.New(errors.CodeInvalidParam, key+" 已废弃，请改用 start_time 与 end_time")
+	}
+	return nil
+}