fix: 补全三处轮询覆盖缺口

问题一：protect 轮询任务从未被调度器初始化入队
PollingConfig 新增 protect_check_interval 字段（NULL=不参与），
调度器 initCardsBatch/initCardPolling/requeueCard 补全 protect 队列
初始化逻辑，IotCard 新增 last_protect_check_at 记录上次检查时间。
迁移文件：000102_add_polling_protect_fields

问题二：设备套餐流量耗尽时绑定卡未被停机
UsageService.checkAndTriggerSuspension 新增 carrier_type=device 分支，
通过 DeviceSimBindingStore.ListByDeviceID 查询绑定卡，对每张卡异步
触发 CheckAndStopCard，同步注入 Bootstrap 依赖。

问题三：主套餐过期后不立即停机，依赖下次轮询兜底
PackageActivationHandler.processExpiredPackage 在 updateCarrierSuspended
Status 后，若载体无后续生效套餐，立即异步调用 CheckAndStopCard（iot_card
类型直接触发，device 类型遍历绑定卡），消除停机延迟窗口。

Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>

internal/bootstrap/services.go

@@ -107,7 +107,7 @@ func initServices(s *stores, deps *Dependencies) *services {
 	iotCard := iotCardSvc.New(deps.DB, s.IotCard, s.Shop, s.AssetAllocationRecord, s.ShopPackageAllocation, s.ShopSeriesAllocation, s.PackageSeries, deps.GatewayClient, deps.Logger)
 	iotCard.SetPollingCallback(polling.NewAPICallback(deps.Redis, deps.Logger))
 	// 注入流量扣减回调，使手动刷新资产时能触发套餐流量扣减
-	usageService := packageSvc.NewUsageService(deps.DB, deps.Redis, s.PackageUsage, s.PackageUsageDailyRecord, deps.Logger)
+	usageService := packageSvc.NewUsageService(deps.DB, deps.Redis, s.PackageUsage, s.PackageUsageDailyRecord, s.DeviceSimBinding, deps.Logger)
 	iotCard.SetDataDeductor(usageService)
 
 	// 创建支付配置服务（Order 和 Recharge 依赖）

internal/bootstrap/worker_services.go

@@ -47,6 +47,7 @@ func initWorkerServices(stores *queue.WorkerStores, deps *WorkerDependencies) *q
 		deps.Redis,
 		stores.PackageUsage,
 		stores.PackageUsageDailyRecord,
+		stores.DeviceSimBinding,
 		deps.Logger,
 	)
 
@@ -116,6 +117,7 @@ func initWorkerServices(stores *queue.WorkerStores, deps *WorkerDependencies) *q
 		ResetService:          resetService,
 		AlertService:          alertService,
 		CleanupService:        cleanupService,
+		StopResumeService:     stopResumeService,
 		OrderExpirer:          orderService,
 	}
 }

internal/model/iot_card.go

@@ -36,6 +36,7 @@ type IotCard struct {
 	EnablePolling                      bool       `gorm:"column:enable_polling;type:boolean;default:true;comment:是否参与轮询 true-参与 false-不参与" json:"enable_polling"`
 	LastDataCheckAt                    *time.Time `gorm:"column:last_data_check_at;comment:最后一次流量检查时间" json:"last_data_check_at"`
 	LastRealNameCheckAt                *time.Time `gorm:"column:last_real_name_check_at;comment:最后一次实名检查时间" json:"last_real_name_check_at"`
+	LastProtectCheckAt                 *time.Time `gorm:"column:last_protect_check_at;comment:上次保护期一致性检查时间" json:"last_protect_check_at"`
 	LastSyncTime                       *time.Time `gorm:"column:last_sync_time;comment:最后一次与Gateway同步时间" json:"last_sync_time"`
 	SeriesID                           *uint      `gorm:"column:series_id;index;comment:套餐系列ID(关联PackageSeries)" json:"series_id,omitempty"`
 	FirstCommissionPaid                bool       `gorm:"column:first_commission_paid;type:boolean;default:false;comment:一次性佣金是否已发放(废弃,使用按系列追踪)" json:"first_commission_paid"`

internal/model/polling.go

@@ -15,6 +15,7 @@ type PollingConfig struct {
 	RealnameCheckInterval *int      `gorm:"column:realname_check_interval;comment:实名检查间隔（秒），NULL表示不检查" json:"realname_check_interval"`
 	CarddataCheckInterval *int      `gorm:"column:carddata_check_interval;comment:流量检查间隔（秒），NULL表示不检查" json:"carddata_check_interval"`
 	PackageCheckInterval  *int      `gorm:"column:package_check_interval;comment:套餐检查间隔（秒），NULL表示不检查" json:"package_check_interval"`
+	ProtectCheckInterval  *int      `gorm:"column:protect_check_interval;comment:保护期一致性检查间隔（秒），NULL=不参与" json:"protect_check_interval"`
 	Status                int16     `gorm:"column:status;type:smallint;not null;default:1;comment:状态：0-禁用，1-启用" json:"status"`
 	Description           string    `gorm:"column:description;type:text;comment:配置说明" json:"description"`
 	CreatedAt             time.Time `gorm:"column:created_at;not null;default:CURRENT_TIMESTAMP;comment:创建时间" json:"created_at"`

internal/polling/package_activation_handler.go

@@ -19,12 +19,14 @@ import (
 // PackageActivationHandler 套餐激活检查处理器
 // 任务 19: 处理主套餐过期、加油包级联失效、待生效主套餐激活
 type PackageActivationHandler struct {
-	db                *gorm.DB
-	redis             *redis.Client
-	queueClient       *asynq.Client
-	packageUsageStore *postgres.PackageUsageStore
-	activationService *packagepkg.ActivationService
-	logger            *zap.Logger
+	db                 *gorm.DB
+	redis              *redis.Client
+	queueClient        *asynq.Client
+	packageUsageStore  *postgres.PackageUsageStore
+	deviceSimBinding   *postgres.DeviceSimBindingStore
+	activationService  *packagepkg.ActivationService
+	stopResumeCallback packagepkg.StopResumeCallback // 停复机回调，用于套餐过期后主动停机
+	logger             *zap.Logger
 }
 
 // PackageActivationPayload 套餐激活任务载荷
@@ -42,15 +44,18 @@ func NewPackageActivationHandler(
 	redis *redis.Client,
 	queueClient *asynq.Client,
 	activationService *packagepkg.ActivationService,
+	stopResumeCallback packagepkg.StopResumeCallback,
 	logger *zap.Logger,
 ) *PackageActivationHandler {
 	return &PackageActivationHandler{
-		db:                db,
-		redis:             redis,
-		queueClient:       queueClient,
-		packageUsageStore: postgres.NewPackageUsageStore(db, redis),
-		activationService: activationService,
-		logger:            logger,
+		db:                 db,
+		redis:              redis,
+		queueClient:        queueClient,
+		packageUsageStore:  postgres.NewPackageUsageStore(db, redis),
+		deviceSimBinding:   postgres.NewDeviceSimBindingStore(db, redis),
+		activationService:  activationService,
+		stopResumeCallback: stopResumeCallback,
+		logger:             logger,
 	}
 }
 
@@ -135,7 +140,6 @@ func (h *PackageActivationHandler) processExpiredPackage(ctx context.Context, pk
 					zap.String("carrier_type", carrierType),
 					zap.Uint("carrier_id", carrierID),
 					zap.Error(err))
-				// 不返回错误，继续处理
 			}
 
 			if err := h.updateCarrierSuspendedStatus(ctx, tx, carrierType, carrierID); err != nil {
@@ -144,6 +148,9 @@ func (h *PackageActivationHandler) processExpiredPackage(ctx context.Context, pk
 					zap.Uint("carrier_id", carrierID),
 					zap.Error(err))
 			}
+
+			// 套餐过期后主动触发停机，消除依赖 carddata 轮询兜底的 60s 延迟窗口
+			h.triggerStopAfterExpiry(ctx, carrierType, carrierID)
 		}
 
 		return nil
@@ -299,6 +306,45 @@ func (h *PackageActivationHandler) activateNextPackage(ctx context.Context, tx *
 	return h.enqueueActivationTask(ctx, nextPkg.ID, carrierType, carrierID, "queue")
 }
 
+// triggerStopAfterExpiry 套餐过期后异步触发停机检查
+// 仅在确认无后续生效套餐时有效；CheckAndStopCard 内部有幂等保护，重复调用安全
+func (h *PackageActivationHandler) triggerStopAfterExpiry(ctx context.Context, carrierType string, carrierID uint) {
+	if h.stopResumeCallback == nil {
+		return
+	}
+
+	if carrierType == "iot_card" {
+		go func() {
+			if err := h.stopResumeCallback.CheckAndStopCard(context.Background(), carrierID); err != nil {
+				h.logger.Error("套餐过期后停机失败",
+					zap.Uint("card_id", carrierID),
+					zap.Error(err))
+			}
+		}()
+		return
+	}
+
+	if carrierType == "device" {
+		bindings, err := h.deviceSimBinding.ListByDeviceID(ctx, carrierID)
+		if err != nil {
+			h.logger.Error("查询设备绑定卡失败",
+				zap.Uint("device_id", carrierID),
+				zap.Error(err))
+			return
+		}
+		for _, b := range bindings {
+			cardID := b.IotCardID
+			go func(cID uint) {
+				if err := h.stopResumeCallback.CheckAndStopCard(context.Background(), cID); err != nil {
+					h.logger.Error("套餐过期后停机失败",
+						zap.Uint("card_id", cID),
+						zap.Error(err))
+				}
+			}(cardID)
+		}
+	}
+}
+
 // enqueueActivationTask 提交套餐激活任务到 Asynq
 func (h *PackageActivationHandler) enqueueActivationTask(ctx context.Context, packageUsageID uint, carrierType string, carrierID uint, activationType string) error {
 	payload := PackageActivationPayload{

internal/polling/scheduler.go

@@ -13,6 +13,7 @@ import (
 	"gorm.io/gorm"
 
 	"github.com/break/junhong_cmp_fiber/internal/model"
+	packagepkg "github.com/break/junhong_cmp_fiber/internal/service/package"
 	"github.com/break/junhong_cmp_fiber/internal/store/postgres"
 	"github.com/break/junhong_cmp_fiber/pkg/constants"
 )
@@ -99,7 +100,7 @@ func NewScheduler(
 		configStore:              postgres.NewPollingConfigStore(db),
 		iotCardStore:             postgres.NewIotCardStore(db, redisClient),
 		concurrencyStore:         postgres.NewPollingConcurrencyConfigStore(db),
-		packageActivationHandler: NewPackageActivationHandler(db, redisClient, queueClient, nil, logger),
+		packageActivationHandler: NewPackageActivationHandler(db, redisClient, queueClient, nil, nil, logger),
 		dataResetHandler:         NewDataResetHandler(nil, logger), // ResetService 需要通过 SetResetService 注入
 		initProgress: &InitProgress{
 			Status: "pending",
@@ -529,6 +530,14 @@ func (s *Scheduler) initCardsBatch(ctx context.Context, cards []*model.IotCard)
 			})
 		}
 
+		if cfg.ProtectCheckInterval != nil && *cfg.ProtectCheckInterval > 0 {
+			nextCheck := s.calculateNextCheckTime(card.LastProtectCheckAt, *cfg.ProtectCheckInterval)
+			pipe.ZAdd(ctx, constants.RedisPollingQueueProtectKey(), redis.Z{
+				Score:  float64(nextCheck.Unix()),
+				Member: card.ID,
+			})
+		}
+
 		// 缓存卡信息到 Redis
 		cacheKey := constants.RedisPollingCardInfoKey(card.ID)
 		cacheData := map[string]interface{}{
@@ -583,6 +592,13 @@ func (s *Scheduler) initCardPolling(ctx context.Context, card *model.IotCard) er
 		}
 	}
 
+	if config.ProtectCheckInterval != nil && *config.ProtectCheckInterval > 0 {
+		nextCheck := s.calculateNextCheckTime(card.LastProtectCheckAt, *config.ProtectCheckInterval)
+		if err := s.addToQueue(ctx, constants.RedisPollingQueueProtectKey(), card.ID, nextCheck); err != nil {
+			return err
+		}
+	}
+
 	// 缓存卡信息到 Redis
 	return s.cacheCardInfo(ctx, card, now)
 }
@@ -631,20 +647,13 @@ func (s *Scheduler) matchConfigConditions(cfg *model.PollingConfig, card *model.
 
 // getCardCondition 获取卡的状态条件
 func (s *Scheduler) getCardCondition(card *model.IotCard) string {
-	// 根据卡的实名状态和激活状态确定条件
 	if card.RealNameStatus != constants.RealNameStatusVerified {
-		return "not_real_name" // 未实名
+		return "not_real_name"
 	}
-	if card.RealNameStatus == constants.RealNameStatusVerified {
-		if card.NetworkStatus == 1 {
-			return "activated" // 已激活
-		}
-		return "real_name" // 已实名但未激活
+	if card.NetworkStatus == 1 {
+		return "activated"
 	}
-	if card.NetworkStatus == 0 {
-		return "suspended" // 已停用
-	}
-	return ""
+	return "real_name"
 }
 
 // calculateNextCheckTime 计算下次检查时间
@@ -746,3 +755,10 @@ func (s *Scheduler) SetResetService(resetService interface{}) {
 func (s *Scheduler) SetActivationService(activationHandler *PackageActivationHandler) {
 	s.packageActivationHandler = activationHandler
 }
+
+// SetStopResumeCallback 注入停复机回调（用于套餐过期后主动触发停机）
+func (s *Scheduler) SetStopResumeCallback(callback packagepkg.StopResumeCallback) {
+	if s.packageActivationHandler != nil {
+		s.packageActivationHandler.stopResumeCallback = callback
+	}
+}

internal/service/package/usage_service.go

@@ -25,6 +25,7 @@ type UsageService struct {
 	redis                   *redis.Client
 	packageUsageStore       *postgres.PackageUsageStore
 	packageUsageDailyRecord *postgres.PackageUsageDailyRecordStore
+	deviceSimBindingStore   *postgres.DeviceSimBindingStore
 	logger                  *zap.Logger
 	stopResumeCallback      StopResumeCallback // 停复机回调，可选
 }
@@ -34,6 +35,7 @@ func NewUsageService(
 	redis *redis.Client,
 	packageUsageStore *postgres.PackageUsageStore,
 	packageUsageDailyRecord *postgres.PackageUsageDailyRecordStore,
+	deviceSimBindingStore *postgres.DeviceSimBindingStore,
 	logger *zap.Logger,
 ) *UsageService {
 	return &UsageService{
@@ -41,6 +43,7 @@ func NewUsageService(
 		redis:                   redis,
 		packageUsageStore:       packageUsageStore,
 		packageUsageDailyRecord: packageUsageDailyRecord,
+		deviceSimBindingStore:   deviceSimBindingStore,
 		logger:                  logger,
 	}
 }
@@ -220,17 +223,44 @@ func (s *UsageService) checkAndTriggerSuspension(ctx context.Context, tx *gorm.D
 			zap.String("carrier_type", carrierType),
 			zap.Uint("carrier_id", carrierID))
 
-		// 任务 24.6: 调用停复机服务执行停机
-		if s.stopResumeCallback != nil && carrierType == "iot_card" {
-			// 在事务外异步执行停机，避免长事务
-			go func() {
-				stopCtx := context.Background()
-				if err := s.stopResumeCallback.CheckAndStopCard(stopCtx, carrierID); err != nil {
-					s.logger.Error("调用停机服务失败",
-						zap.Uint("card_id", carrierID),
+		if carrierType == "iot_card" {
+			if s.stopResumeCallback != nil {
+				go func() {
+					stopCtx := context.Background()
+					if err := s.stopResumeCallback.CheckAndStopCard(stopCtx, carrierID); err != nil {
+						s.logger.Error("调用停机服务失败",
+							zap.Uint("card_id", carrierID),
+							zap.Error(err))
+					}
+				}()
+			}
+		} else if carrierType == "device" {
+			if s.stopResumeCallback == nil {
+				s.logger.Warn("停复机回调未注入，跳过设备绑定卡停机",
+					zap.Uint("device_id", carrierID))
+			} else {
+				bindings, err := s.deviceSimBindingStore.ListByDeviceID(context.Background(), carrierID)
+				if err != nil {
+					s.logger.Error("查询设备绑定卡失败",
+						zap.Uint("device_id", carrierID),
 						zap.Error(err))
+				} else if len(bindings) == 0 {
+					s.logger.Debug("设备无绑定卡，跳过停机",
+						zap.Uint("device_id", carrierID))
+				} else {
+					for _, b := range bindings {
+						cardID := b.IotCardID
+						go func(cID uint) {
+							stopCtx := context.Background()
+							if err := s.stopResumeCallback.CheckAndStopCard(stopCtx, cID); err != nil {
+								s.logger.Error("调用停机服务失败",
+									zap.Uint("card_id", cID),
+									zap.Error(err))
+							}
+						}(cardID)
+					}
 				}
-			}()
+			}
 		}
 	}
 

internal/task/polling_handler.go

@@ -231,6 +231,9 @@ func (h *PollingHandler) HandleCarddataCheck(ctx context.Context, t *asynq.Task)
 		return h.requeueCard(ctx, uint(cardID), constants.TaskTypePollingCarddata)
 	}
 
+	// 必须在 gateway 查询前执行：gateway 报错会提前 return，checkStopResume 放在后面时无套餐在线卡无法被自动停机
+	h.checkStopResume(ctx, card)
+
 	// 调用 Gateway API 查询流量
 	var gatewayFlowMB float64
 	if h.gatewayClient != nil {
@@ -293,9 +296,6 @@ func (h *PollingHandler) HandleCarddataCheck(ctx context.Context, t *asynq.Task)
 		}
 	}
 
-	// 独立停机/复机检查（不依赖流量增量，每次轮询都执行）
-	h.checkStopResume(ctx, card)
-
 	// 更新监控统计
 	h.updateStats(ctx, constants.TaskTypePollingCarddata, true, time.Since(startTime))
 
@@ -911,10 +911,20 @@ func (h *PollingHandler) requeueCard(ctx context.Context, cardID uint, taskType
 	}
 
 	nextCheck := time.Now().Add(time.Duration(intervalSeconds) * time.Second)
-	return h.redis.ZAdd(ctx, queueKey, redis.Z{
+	if err := h.redis.ZAdd(ctx, queueKey, redis.Z{
 		Score:  float64(nextCheck.Unix()),
 		Member: strconv.FormatUint(uint64(cardID), 10),
-	}).Err()
+	}).Err(); err != nil {
+		return err
+	}
+
+	// protect 任务重新入队时更新检查时间，供下次初始化计算队列延迟
+	if taskType == constants.TaskTypePollingProtect {
+		now := time.Now()
+		h.db.Model(&model.IotCard{}).Where("id = ?", cardID).Update("last_protect_check_at", now)
+	}
+
+	return nil
 }
 
 // getMatchedPollingInterval 读取该卡匹配的 PollingConfig，返回指定任务类型的间隔秒数
@@ -952,9 +962,8 @@ func (h *PollingHandler) getMatchedPollingInterval(ctx context.Context, cardID u
 				return *cfg.PackageCheckInterval, nil
 			}
 		case constants.TaskTypePollingProtect:
-			// protect 任务暂无专用间隔字段，使用 realname 间隔兜底
-			if cfg.RealnameCheckInterval != nil && *cfg.RealnameCheckInterval > 0 {
-				return *cfg.RealnameCheckInterval, nil
+			if cfg.ProtectCheckInterval != nil && *cfg.ProtectCheckInterval > 0 {
+				return *cfg.ProtectCheckInterval, nil
 			}
 		}
 		// 匹配到配置但该任务类型间隔为 NULL，说明此卡不需要此类轮询
@@ -1202,18 +1211,18 @@ func (h *PollingHandler) HandleProtectConsistencyCheck(ctx context.Context, t *a
 
 	// 未绑设备（独立卡），跳过
 	if card.IsStandalone {
-		return nil
+		return h.requeueCard(ctx, card.ID, constants.TaskTypePollingProtect)
 	}
 
 	// 未实名，跳过
 	if card.RealNameStatus != constants.RealNameStatusVerified {
-		return nil
+		return h.requeueCard(ctx, card.ID, constants.TaskTypePollingProtect)
 	}
 
 	// 查绑定设备
 	binding, err := h.deviceSimBindingStore.GetActiveBindingByCardID(ctx, card.ID)
 	if err != nil || binding == nil {
-		return nil
+		return h.requeueCard(ctx, card.ID, constants.TaskTypePollingProtect)
 	}
 	deviceID := binding.DeviceID
 
@@ -1234,7 +1243,7 @@ func (h *PollingHandler) HandleProtectConsistencyCheck(ctx context.Context, t *a
 					zap.Uint("card_id", card.ID),
 					zap.String("iccid", card.ICCID),
 					zap.Error(err))
-				return nil
+				return h.requeueCard(ctx, card.ID, constants.TaskTypePollingProtect)
 			}
 			h.logger.Info("网关停机成功（保护期）",
 				zap.Uint("card_id", card.ID),
@@ -1247,7 +1256,7 @@ func (h *PollingHandler) HandleProtectConsistencyCheck(ctx context.Context, t *a
 			"stop_reason":    constants.StopReasonProtectPeriod,
 		})
 		h.updateCardCache(ctx, card.ID, map[string]any{"network_status": constants.NetworkStatusOffline})
-		return nil
+		return h.requeueCard(ctx, card.ID, constants.TaskTypePollingProtect)
 	}
 
 	// 检查 start 保护期：设备处于复机保护期，但卡是停机状态 → 需要复机
@@ -1267,7 +1276,7 @@ func (h *PollingHandler) HandleProtectConsistencyCheck(ctx context.Context, t *a
 					zap.Uint("card_id", card.ID),
 					zap.String("iccid", card.ICCID),
 					zap.Error(err))
-				return nil
+				return h.requeueCard(ctx, card.ID, constants.TaskTypePollingProtect)
 			}
 			h.logger.Info("网关复机成功（保护期）",
 				zap.Uint("card_id", card.ID),
@@ -1282,7 +1291,7 @@ func (h *PollingHandler) HandleProtectConsistencyCheck(ctx context.Context, t *a
 		h.updateCardCache(ctx, card.ID, map[string]any{"network_status": constants.NetworkStatusOnline})
 	}
 
-	return nil
+	return h.requeueCard(ctx, card.ID, constants.TaskTypePollingProtect)
 }
 
 // triggerFirstRealnameActivation 任务 21.3-21.4: 首次实名后触发套餐激活