需求内容池 新排序、晋级

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/common/constant/SceneConstants.java

@@ -6,4 +6,5 @@ package com.tzld.longarticle.recommend.server.common.constant;
 public class SceneConstants {
     public static final String DEFAULT = "DEFAULT";
     public static final String FWH_COLD_START = "FWH_COLD_START";
+    public static final String DEMAND_POOL = "DEMAND_POOL";
 }

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/common/enums/recommend/ContentPoolEnum.java

@@ -13,6 +13,9 @@ public enum ContentPoolEnum {
     autoArticlePoolLevel3("autoArticlePoolLevel3", 3, "次条", 25),
     autoArticlePoolLevel4("autoArticlePoolLevel4", 4, "冷启层", 1),
 
+    accountDemandPoolLevelCold("accountDemandPoolLevelCold", 5, "需求冷启池", 1),
+    accountDemandPoolLevelUtilize("accountDemandPoolLevelUtilize", 6, "需求利用池", 100),
+
     ;
 
     private final String contentPool;

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/common/enums/recommend/RankStrategyEnum.java

@@ -34,6 +34,8 @@ public enum RankStrategyEnum {
     RANDOM_STRATEGY("ArticleRankRandom", "随机策略", "randomRankStrategy"),
     DEFAULT_STRATEGY("ArticleRankV1", "默认策略", "defaultRankStrategy"),
     FWH_STRATEGY("FwhStrategy", "服务号策略", "fwhColdStartRankStrategy"),
+
+    DEMAND_POOL_STRATEGY("DemandPoolStrategy", "需求匹配内容池策略", "demandPoolRankStrategy"),
     ;
 
     private final String strategy;

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/mapper/aigc/AigcBaseMapper.java

@@ -104,4 +104,6 @@ public interface AigcBaseMapper {
     void topContentDeprecate(String topProducePlanId);
 
     List<String> getAllBatchGroupSendAccount();
+
+    List<ProducePlanExeRecord> getProducePlanExeRecordByChannelContentIds(List<String> list);
 }

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/mapper/longArticle/LongArticleBaseMapper.java

@@ -7,6 +7,7 @@ import com.tzld.longarticle.recommend.server.model.param.ArticleVideoPoolSourceP
 import com.tzld.longarticle.recommend.server.model.vo.CategoryGroupFunnelExport;
 import com.tzld.longarticle.recommend.server.model.vo.DailyAuditProduceExport;
 import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
 
 import java.util.Date;
 import java.util.List;
@@ -87,7 +88,7 @@ public interface LongArticleBaseMapper {
 
     List<String> getMatchContentId(Date start, Date end);
 
-    void batchInsertLongArticleAuditDelete(List<LongArticleAuditDelete> deleteList);
+    void batchInsertLongArticleAuditDelete(List<LongArticleAuditDelete> list);
 
     List<String> getPassContentIds();
 
@@ -131,4 +132,16 @@ public interface LongArticleBaseMapper {
 
     List<DatastatSortStrategy> getByAccountAndOptionalParams(String accountName, String type, Integer position,
                                                              String dateStrStart, String dateStrEnd);
+
+    List<DemandSearchArticleRelationDTO> getDemandSearchArticleRelations();
+
+    void batchInsertIgnoreDemandProduceContentRelation(List<DemandSearchArticleRelationDTO> list);
+
+    List<DemandSearchArticleRelationDTO> getDemandExperimentIdByChannelContentIds(List<String> list);
+
+    List<DemandSearchArticleRelationDTO> getDemandPoolPromotionByLevel(String level, Integer status, Integer deleted);
+
+    List<DemandSearchArticleRelationDTO> getDemandExperimentIdByContentIds(@Param("contentIds") List<String> contentIds,
+                                                                           @Param("accountId") String accountId);
+
 }

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/model/dto/Content.java

@@ -30,6 +30,7 @@ public class Content {
     private String producePlanName;
     private String contentPoolType; // 内容池类别
     private String crawlerChannelContentId; // 抓取内容channelContentId
+    private String experimentId; // 需求匹配实验ID
     private List<String> category; // 品类
     private String crawlerLink;
     private String crawlerTitle;

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/model/dto/DemandSearchArticleRelationDTO.java

@@ -0,0 +1,21 @@
+package com.tzld.longarticle.recommend.server.model.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * 需求搜索文章关系 DTO
+ * 用于查询 demand_search_article_relation 和写入 demand_produce_content_relation
+ *
+ * @author dyp
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class DemandSearchArticleRelationDTO {
+    private String experimentId;
+    private String channelContentId;
+    private String contentId;
+    private String accountId;
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/model/entity/longArticle/DemandPoolPromotionSource.java

@@ -0,0 +1,62 @@
+package com.tzld.longarticle.recommend.server.model.entity.longArticle;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Table;
+
+/**
+ * 需求池晋级记录表
+ * 记录冷启池 → 利用池的晋级关系，与老晋级表 article_pool_promotion_source 分离
+ *
+ * @author dyp
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@Entity
+@Table(name = "demand_pool_promotion_source")
+public class DemandPoolPromotionSource {
+
+    @Id
+    @Column(name = "channel_content_id")
+    private String channelContentId;
+
+    @Column(name = "wx_sn")
+    private String wxSn;
+
+    @Column(name = "source_publish_content_id")
+    private String sourcePublishContentId;
+
+    @Column(name = "root_produce_content_id")
+    private String rootProduceContentId;
+
+    @Column(name = "title")
+    private String title;
+
+    @Column(name = "title_md5")
+    private String titleMd5;
+
+    @Column(name = "level")
+    private String level;
+
+    @Column(name = "account_id")
+    private String accountId;
+
+    @Column(name = "status")
+    private Integer status;
+
+    @Column(name = "deleted")
+    private Integer deleted;
+
+    @Column(name = "create_timestamp")
+    private Long createTimestamp;
+
+    @Column(name = "update_timestamp")
+    private Long updateTimestamp;
+
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/model/entity/longArticle/DemandProduceContentRelation.java

@@ -0,0 +1,45 @@
+package com.tzld.longarticle.recommend.server.model.entity.longArticle;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.*;
+import java.time.LocalDateTime;
+
+/**
+ * 需求搜索文章-生成内容对照关系表
+ * 记录 experiment_id → channel_content_id → plan_exe_id 的映射关系
+ *
+ * @author dyp
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@Entity
+@Table(name = "demand_produce_content_relation")
+public class DemandProduceContentRelation {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "account_id")
+    private String accountId;
+
+    @Column(name = "content_id")
+    private String contentId;
+
+    @Column(name = "channel_content_id")
+    private String channelContentId;
+
+    @Column(name = "experiment_id")
+    private String experimentId;
+
+    @Column(name = "created_at")
+    private LocalDateTime createdAt;
+
+    @Column(name = "updated_at")
+    private LocalDateTime updatedAt;
+
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/repository/longArticle/DemandPoolPromotionSourceRepository.java

@@ -0,0 +1,21 @@
+package com.tzld.longarticle.recommend.server.repository.longArticle;
+
+import com.tzld.longarticle.recommend.server.model.entity.longArticle.DemandPoolPromotionSource;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+/**
+ * 需求池晋级记录表 Repository
+ *
+ * @author dyp
+ */
+@Repository
+public interface DemandPoolPromotionSourceRepository extends JpaRepository<DemandPoolPromotionSource, String> {
+
+    DemandPoolPromotionSource getByChannelContentId(String channelContentId);
+
+    List<DemandPoolPromotionSource> getByStatusAndDeleted(Integer status, Integer deleted);
+
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/repository/longArticle/DemandProduceContentRelationRepository.java

@@ -0,0 +1,23 @@
+package com.tzld.longarticle.recommend.server.repository.longArticle;
+
+import com.tzld.longarticle.recommend.server.model.entity.longArticle.DemandProduceContentRelation;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+/**
+ * 需求搜索文章-生成内容对照关系表 Repository
+ *
+ * @author dyp
+ */
+@Repository
+public interface DemandProduceContentRelationRepository extends JpaRepository<DemandProduceContentRelation, Long> {
+
+    List<DemandProduceContentRelation> findByExperimentId(String experimentId);
+
+    List<DemandProduceContentRelation> findByChannelContentId(String channelContentId);
+
+    List<DemandProduceContentRelation> findByContentId(String contentId);
+
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/XxlJobService.java

@@ -14,6 +14,7 @@ import com.tzld.longarticle.recommend.server.common.constant.SceneConstants;
 import com.tzld.longarticle.recommend.server.common.enums.FieshuTableColumnDataTypeEnum;
 import com.tzld.longarticle.recommend.server.common.enums.aigc.ChannelEnum;
 import com.tzld.longarticle.recommend.server.common.enums.aigc.MiniprogramUseTypeEnum;
+import com.tzld.longarticle.recommend.server.common.enums.StatusEnum;
 import com.tzld.longarticle.recommend.server.common.enums.aigc.ProduceContentAuditStatusEnum;
 import com.tzld.longarticle.recommend.server.common.enums.aigc.PushTypeEnum;
 import com.tzld.longarticle.recommend.server.common.enums.longArticle.ArticleVideoAuditStatusEnum;
@@ -799,12 +800,6 @@ public class XxlJobService {
         return ReturnT.SUCCESS;
     }
 
-    @XxlJob("articlePromotionTraceability")
-    public ReturnT<String> articlePromotionTraceability(String channelContentId) {
-        articleService.articlePromotionTraceability(channelContentId);
-        return ReturnT.SUCCESS;
-    }
-
     @XxlJob("articleCategoryJob")
     public ReturnT<String> articleCategoryJob(String param) {
         articleCategoryService.articleCategory();
@@ -828,6 +823,12 @@ public class XxlJobService {
         return ReturnT.SUCCESS;
     }
 
+    @XxlJob("articlePromotionTraceability")
+    public ReturnT<String> articlePromotionTraceability(String channelContentId) {
+        articleService.articlePromotionTraceability(channelContentId);
+        return ReturnT.SUCCESS;
+    }
+
     @XxlJob("articleVideoPoolPromotion")
     public ReturnT<String> articleVideoPoolPromotion(String param) {
         articlePromotionService.articleVideoPoolPromotion(500, 1.1,
@@ -839,6 +840,19 @@ public class XxlJobService {
         return ReturnT.SUCCESS;
     }
 
+    @XxlJob("demandPoolPromotion")
+    public ReturnT<String> demandPoolPromotion(String param) {
+        articlePromotionService.demandPoolPromotion(500, 1.3,
+                Lists.newArrayList(3, 4, 5, 6, 7, 8));
+        return ReturnT.SUCCESS;
+    }
+
+    @XxlJob("demandPoolPromotionTraceability")
+    public ReturnT<String> demandPoolPromotionTraceability(String channelContentId) {
+        articleService.demandPoolPromotionTraceability(channelContentId);
+        return ReturnT.SUCCESS;
+    }
+
     @XxlJob("refreshArticleHisCache")
     public ReturnT<String> refreshArticleHisCache(String param) {
         // 刷新历史表现缓存
@@ -1344,4 +1358,228 @@ public class XxlJobService {
         return param.getStrategy();
     }
 
+    /**
+     * 同步需求搜索文章-生成内容对照关系
+     * <p>
+     * 从两个来源收集 (experiment_id, channel_content_id, plan_exe_id) 三元组，
+     * 写入 demand_produce_content_relation 表：
+     * <pre>
+     *   来源1: demand_search_article_relation — 搜索阶段直接建立的对照关系
+     *   来源2: demand_pool_promotion_source    — 冷启池晋级到利用池后，反向溯源 experiment_id
+     *
+     *   执行流程：
+     *     ① fetchSearchRelations()                     — 读取搜索阶段对照（含 experiment_id）
+     *     ② fetchPromotionRelations()                  — 读取晋级记录，回填 experiment_id
+     *     ③ fetchPlanExeIdByChannelContentIds()        — 跨库（aigc）查 produce_plan_exe_record
+     *     ④ buildInsertList()                          — 装配三元组，过滤无效记录
+     *     ⑤ batchInsertDemandRelation()                — INSERT IGNORE 批量写入
+     * </pre>
+     *
+     * @param param XXL-Job 参数（未使用）
+     */
+    @XxlJob("syncDemandProduceContentRelation")
+    public ReturnT<String> syncDemandProduceContentRelation(String param) {
+        String lockKey = "DemandProduceContentRelationLock";
+        String requestId = UUID.randomUUID().toString();
+        try {
+            if (!redisUtil.tryAcquireLock(lockKey, requestId, 600L)) {
+                log.info("syncDemandProduceContentRelation lock failed, skip");
+                return ReturnT.SUCCESS;
+            }
+            log.info("syncDemandProduceContentRelation start");
+
+            // ① 从 long_articles 库收集两种来源的原始数据
+            List<DemandSearchArticleRelationDTO> searchRelations = fetchSearchRelations();
+            List<DemandSearchArticleRelationDTO> promotionRelations = fetchPromotionRelations();
+
+            // 合并两个来源
+            List<DemandSearchArticleRelationDTO> allRelations = new ArrayList<>();
+            if (CollectionUtils.isNotEmpty(searchRelations)) {
+                allRelations.addAll(searchRelations);
+            }
+            if (CollectionUtils.isNotEmpty(promotionRelations)) {
+                allRelations.addAll(promotionRelations);
+            }
+            if (CollectionUtils.isEmpty(allRelations)) {
+                log.info("syncDemandProduceContentRelation no data from any source, skip");
+                return ReturnT.SUCCESS;
+            }
+            log.info("syncDemandProduceContentRelation total {} relations (search={}, promotion={})",
+                    allRelations.size(),
+                    searchRelations != null ? searchRelations.size() : 0,
+                    promotionRelations != null ? promotionRelations.size() : 0);
+
+            // ② 跨库（aigc）批量查询 produce_plan_exe_record 获取 plan_exe_id
+            Map<String, String> channelContentIdToPlanExeId = fetchPlanExeIdByChannelContentIds(allRelations);
+
+            // ③ 装配三元组 (content_id=plan_exe_id, channel_content_id, experiment_id)
+            List<DemandSearchArticleRelationDTO> insertList = buildInsertList(allRelations, channelContentIdToPlanExeId);
+
+            // ④ INSERT IGNORE 批量写入 demand_produce_content_relation
+            batchInsertDemandRelation(insertList);
+            log.info("syncDemandProduceContentRelation done, total={}, enriched={}",
+                    allRelations.size(), insertList.size());
+            return ReturnT.SUCCESS;
+        } catch (Exception e) {
+            log.error("syncDemandProduceContentRelation error", e);
+            return ReturnT.FAIL;
+        } finally {
+            redisUtil.releaseLock(lockKey, requestId);
+        }
+    }
+
+    /**
+     * 来源1：查询 demand_search_article_relation（status=2 拉取详情成功 + channel_content_id 非空）
+     * 直接返回 experiment_id + channel_content_id 对
+     */
+    private List<DemandSearchArticleRelationDTO> fetchSearchRelations() {
+        List<DemandSearchArticleRelationDTO> searchRelations = longArticleBaseMapper.getDemandSearchArticleRelations();
+        log.info("syncDemandProduceContentRelation source1(search) found {} relations",
+                searchRelations != null ? searchRelations.size() : 0);
+        return searchRelations;
+    }
+
+    /**
+     * 来源2：查询 demand_pool_promotion_source 中已完成的晋级记录（level=利用池, status=FINISH）
+     * 三步：逐表查晋级记录 → 逐 root_produce_content_id 查 experiment_id → 回填并过滤
+     * <p>
+     * 返回仅包含成功回填 experiment_id 的记录
+     */
+    private List<DemandSearchArticleRelationDTO> fetchPromotionRelations() {
+        // Step 1: 查晋级表 demand_pool_promotion_source（独立于老晋级表）
+        String utilizeLevel = ContentPoolEnum.accountDemandPoolLevelUtilize.getContentPool();
+        List<DemandSearchArticleRelationDTO> promotionRelations = longArticleBaseMapper
+                .getDemandPoolPromotionByLevel(utilizeLevel,
+                        ArticlePoolPromotionSourceStatusEnum.FINISH.getCode(), StatusEnum.ZERO.getCode());
+        log.info("syncDemandProduceContentRelation source2(promotion) found {} relations",
+                promotionRelations != null ? promotionRelations.size() : 0);
+
+        if (CollectionUtils.isEmpty(promotionRelations)) {
+            return new ArrayList<>();
+        }
+
+        // Step 2: 按 account_id 分组 root_produce_content_id，查 demand_produce_content_relation 获取 experiment_id
+        // account_id → Set<rootProduceContentId>
+        Map<String, Set<String>> accountContentIds = new HashMap<>();
+        for (DemandSearchArticleRelationDTO pr : promotionRelations) {
+            if (StringUtils.hasText(pr.getContentId()) && StringUtils.hasText(pr.getAccountId())) {
+                accountContentIds.computeIfAbsent(pr.getAccountId(), k -> new HashSet<>()).add(pr.getContentId());
+            }
+        }
+        Map<String, String> contentIdToExperimentId = fetchExperimentIdByContentIds(accountContentIds);
+        log.info("syncDemandProduceContentRelation source2 found {} experiment_id by rootProduceContentId",
+                contentIdToExperimentId.size());
+
+        // Step 3: 回填 experiment_id，仅保留有匹配的记录
+        List<DemandSearchArticleRelationDTO> enriched = new ArrayList<>();
+        for (DemandSearchArticleRelationDTO pr : promotionRelations) {
+            String expId = contentIdToExperimentId.get(pr.getContentId());
+            if (expId != null) {
+                pr.setExperimentId(expId);
+                enriched.add(pr);
+            }
+        }
+        return enriched;
+    }
+
+    /**
+     * 按账号粒度查询 demand_produce_content_relation 获取 experiment_id
+     * <p>
+     * 应用场景：晋级记录有 root_produce_content_id + account_id，反向查 experiment_id
+     *
+     * @param accountContentIds account_id → Set<content_id> 分组
+     */
+    private Map<String, String> fetchExperimentIdByContentIds(Map<String, Set<String>> accountContentIds) {
+        Map<String, String> result = new HashMap<>();
+        if (accountContentIds == null || accountContentIds.isEmpty()) {
+            return result;
+        }
+        for (Map.Entry<String, Set<String>> entry : accountContentIds.entrySet()) {
+            String accountId = entry.getKey();
+            List<String> contentIds = new ArrayList<>(entry.getValue());
+            for (List<String> partition : Lists.partition(contentIds, 500)) {
+                List<DemandSearchArticleRelationDTO> expMappings =
+                        longArticleBaseMapper.getDemandExperimentIdByContentIds(partition, accountId);
+                if (CollectionUtils.isNotEmpty(expMappings)) {
+                    for (DemandSearchArticleRelationDTO m : expMappings) {
+                        if (StringUtils.hasText(m.getContentId()) && StringUtils.hasText(m.getExperimentId())) {
+                            result.put(m.getContentId(), m.getExperimentId());
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    }
+
+    /**
+     * 跨库查询：去 aigc 数据库批量查 produce_plan_exe_record
+     * <p>
+     * 输入：所有来源中包含的 channel_content_id（去重）
+     * 输出：channel_content_id → plan_exe_id 映射
+     * 分批大小 1000，避免 IN 子句过长
+     */
+    private Map<String, String> fetchPlanExeIdByChannelContentIds(List<DemandSearchArticleRelationDTO> relations) {
+        // 提取并去重 channel_content_id
+        List<String> channelContentIds = relations.stream()
+                .map(DemandSearchArticleRelationDTO::getChannelContentId)
+                .filter(StringUtils::hasText)
+                .distinct()
+                .collect(Collectors.toList());
+
+        // 分批查询 produce_plan_exe_record（每次最多 1000 个）
+        Map<String, String> result = new HashMap<>();
+        for (List<String> partition : Lists.partition(channelContentIds, 1000)) {
+            List<ProducePlanExeRecord> records = aigcBaseMapper.getProducePlanExeRecordByChannelContentIds(partition);
+            if (CollectionUtils.isNotEmpty(records)) {
+                for (ProducePlanExeRecord record : records) {
+                    if (StringUtils.hasText(record.getChannelContentId())) {
+                        result.put(record.getChannelContentId(), record.getPlanExeId());
+                    }
+                }
+            }
+        }
+        log.info("syncDemandProduceContentRelation found {} plan_exe_id mappings from produce_plan_exe_record",
+                result.size());
+        return result;
+    }
+
+    /**
+     * 装配最终写入的三元组 (content_id=plan_exe_id, channel_content_id, experiment_id)
+     * <p>
+     * 过滤规则：
+     * - experiment_id 为空 → 跳过（来源2 中未匹配到 experiment_id 的晋级记录）
+     * - channel_content_id 在 aigc 库查不到 plan_exe_id → 跳过（抓取内容尚未生成）
+     */
+    private List<DemandSearchArticleRelationDTO> buildInsertList(List<DemandSearchArticleRelationDTO> relations,
+                                                                  Map<String, String> channelContentIdToPlanExeId) {
+        List<DemandSearchArticleRelationDTO> insertList = new ArrayList<>();
+        for (DemandSearchArticleRelationDTO relation : relations) {
+            // 必须有 experiment_id
+            if (!StringUtils.hasText(relation.getExperimentId())) {
+                continue;
+            }
+            // 必须在 aigc 库找到对应的 plan_exe_id
+            String planExeId = channelContentIdToPlanExeId.get(relation.getChannelContentId());
+            if (StringUtils.hasText(planExeId)) {
+                relation.setContentId(planExeId);
+                insertList.add(relation);
+            }
+        }
+        log.info("syncDemandProduceContentRelation enriched {} records to insert", insertList.size());
+        return insertList;
+    }
+
+    /**
+     * INSERT IGNORE 批量写入 demand_produce_content_relation
+     * <p>
+     * 唯一键 uk_exp_channel_content 保证幂等，重复记录自动跳过
+     * 分批 500 条，控制单次 SQL 大小
+     */
+    private void batchInsertDemandRelation(List<DemandSearchArticleRelationDTO> insertList) {
+        for (List<DemandSearchArticleRelationDTO> partition : Lists.partition(insertList, 500)) {
+            longArticleBaseMapper.batchInsertIgnoreDemandProduceContentRelation(partition);
+        }
+    }
+
 }

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/ArticleCategoryService.java

@@ -188,7 +188,8 @@ public class ArticleCategoryService {
         List<ProducePlan> producePlanList = producePlanRepository.findByIdIn(producePlanIds);
         producePlanIds = producePlanList.stream()
                 .filter(o -> StringUtils.hasText(o.getPlanTag())
-                        && o.getPlanTag().contains(ContentPoolEnum.autoArticlePoolLevel4.getContentPool()))
+                        && (o.getPlanTag().contains(ContentPoolEnum.autoArticlePoolLevel4.getContentPool())
+                        || o.getPlanTag().contains(ContentPoolEnum.accountDemandPoolLevelCold.getContentPool())))
                 .map(ProducePlan::getId).collect(Collectors.toList());
         List<ArticleCategory> saveList = addArticleCategoryByProducePlan(producePlanIds);
         if (CollectionUtils.isNotEmpty(saveList)) {
@@ -204,7 +205,8 @@ public class ArticleCategoryService {
                 .filter(o -> StringUtils.hasText(o.getPlanTag())
                         && (o.getPlanTag().contains(ContentPoolEnum.autoArticlePoolLevel1.getContentPool())
                         || o.getPlanTag().contains(ContentPoolEnum.autoArticlePoolLevel2.getContentPool())
-                        || o.getPlanTag().contains(ContentPoolEnum.autoArticlePoolLevel3.getContentPool())))
+                        || o.getPlanTag().contains(ContentPoolEnum.autoArticlePoolLevel3.getContentPool())
+                        || o.getPlanTag().contains(ContentPoolEnum.accountDemandPoolLevelUtilize.getContentPool())))
                 .map(ProducePlan::getId).collect(Collectors.toList());
 
         List<ArticleCategory> saveList = addArticleCategoryByProducePlan(articlePromotionProducePlanIds);

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/ArticlePromotionService.java

@@ -90,6 +90,8 @@ public class ArticlePromotionService {
     VideoTitleReWriteRepository videoTitleReWriteRepository;
     @Autowired
     ArticleUnsafeTitleRepository articleUnsafeTitleRepository;
+    @Autowired
+    DemandPoolPromotionSourceRepository demandPoolPromotionSourceRepository;
 
     @ApolloJsonValue("${articlePromotionProduceConfig:{}}")
     private Map<String, Map<String, Map<String, String>>> produceConfig;
@@ -175,6 +177,10 @@ public class ArticlePromotionService {
         // 获取内部表现
         List<DatastatSortStrategy> list;
         list = longArticleBaseMapper.getArticlePromotionCandidates(10000, dateStrFilter, positionFilter);
+        // 需求内容池晋级过滤
+        list = list.stream().filter(o -> !o.getProducePlanTag().contains(ContentPoolEnum.accountDemandPoolLevelCold.getContentPool())
+                        && !o.getProducePlanTag().contains(ContentPoolEnum.accountDemandPoolLevelUtilize.getContentPool()))
+                .collect(Collectors.toList());
         // 使用阅读均值倍数+阅读量晋级
         List<DatastatSortStrategy> listStrategyV1 = list.stream()
                 .filter(o -> o.getReadRate() >= viewCountRateFilter && o.getViewCount() >= viewCountFilter)
@@ -207,6 +213,58 @@ public class ArticlePromotionService {
         filterAndAdd2CrawlerPlan(listStrategyV2, "策略V2", accountNickName, tag, pos, way, today);
     }
 
+    /**
+     * 需求匹配内容池晋级：冷启池 → 利用池
+     * 从 datastat_sort_strategy 中筛选 produce_plan_tag 包含 accountDemandPoolLevelCold 的高表现内容，
+     * 晋级到 accountDemandPoolLevelUtilize
+     */
+    public void demandPoolPromotion(Integer viewCountFilter, Double viewCountRateFilter,
+                                     List<Integer> positionFilter) {
+        String dateStrFilter = DateUtils.getBeforeDaysDateStr("yyyyMMdd", 10);
+        List<DatastatSortStrategy> list = longArticleBaseMapper.getArticlePromotion(viewCountFilter, viewCountRateFilter,
+                10000, dateStrFilter, positionFilter);
+        // 仅保留需求冷启池内容
+        list = list.stream()
+                .filter(o -> o.getProducePlanTag() != null
+                        && o.getProducePlanTag().contains(ContentPoolEnum.accountDemandPoolLevelCold.getContentPool()))
+                .collect(Collectors.toList());
+        if (CollectionUtils.isEmpty(list)) {
+            log.info("demandPoolPromotion 需求冷启池无优质文章");
+            return;
+        }
+        list = filterEarlyContent(list, true);
+        log.info("demandPoolPromotion 需求冷启池优质文章数量: {}", list.size());
+        List<DatastatSortStrategy> distinct = filterSameTitle(list);
+        distinct.sort(Comparator.comparing(DatastatSortStrategy::getDateStr, Comparator.reverseOrder()));
+        log.info("demandPoolPromotion 需求冷启池优质文章数量(去重后): {}", distinct.size());
+
+        // 保存晋级记录：冷启池 → 利用池，写入新表 demand_pool_promotion_source（与老晋级表分离）
+        // 先批量查询 gh_id → account_id 映射
+        List<String> ghIds = distinct.stream()
+                .map(DatastatSortStrategy::getGhId)
+                .distinct()
+                .collect(Collectors.toList());
+        List<PublishAccount> publishAccounts = publishAccountRepository.getAllByGhIdIn(ghIds);
+        Map<String, String> ghIdToAccountId = publishAccounts.stream()
+                .collect(Collectors.toMap(PublishAccount::getGhId, PublishAccount::getId, (a, b) -> a));
+
+        int promotionNum = 0;
+        for (DatastatSortStrategy item : distinct) {
+            String wxSn = item.getWxSn();
+            String title = item.getTitle();
+            String accountId = ghIdToAccountId.get(item.getGhId());
+            String publishContentId = articleService.getPublishContentByWxSn(wxSn);
+            if (StringUtils.hasText(publishContentId)) {
+                saveDemandPoolPromotionSource(Md5Util.encoderByMd5(publishContentId), wxSn, title,
+                        ContentPoolEnum.accountDemandPoolLevelUtilize.getContentPool(), accountId);
+                promotionNum++;
+            }
+        }
+        log.info("demandPoolPromotion 晋级完成，晋级数量: {}", promotionNum);
+        FeishuMessageSender.sendWebHookMessage(FeishuRobotIdEnum.DAILY.getRobotId(),
+                "【需求内容池晋级任务完成】\n晋级数量：" + promotionNum);
+    }
+
     private void filterAndAdd2CrawlerPlan(List<DatastatSortStrategy> list, String promotionStrategy, String accountNickName, String tag, String pos, String way, String today) {
         list = filterEarlyContent(list, true);
         log.info("优质{}文章数量: {}", accountNickName, list.size());
@@ -289,25 +347,8 @@ public class ArticlePromotionService {
                 if (StringUtils.hasText(publishContentId)) {
                     publishContentIds.add(publishContentId);
                     saveArticlePoolPromotionSource(Md5Util.encoderByMd5(publishContentId), wxSn, title, level);
-//                } else {
-//                    filterUrlList.add(url);
-//                    // 调用爬虫 detail 接口并保存数据
-//                    WxContentDetailResponse detail = getArticleDetail(url);
-//                    if (detail != null && StringUtils.hasText(detail.getChannelContentId())) {
-//                        saveArticlePoolPromotionSource(detail.getChannelContentId(), wxSn, title, level);
-//                    }
                 }
             }
-//            if (CollectionUtils.isNotEmpty(filterUrlList)) {
-//                String planName = String.format("%d_%s_%s_%s【%s】_%s_%s", filterUrlList.size(), today, accountNickName, pos, way, today, promotionStrategy);
-//                log.info("url_len: " + list.size() + ", " + filterUrlList.size());
-//                IdNameVO<String> planInfo = aigcCrawlerPlanSaveService.createArticleUrlPlan(planName, filterUrlList, tag, CrawlerModeEnum.ContentIDs.getVal());
-//                if (StringUtils.hasText(produceId)) {
-//                    String inputSourceLabel = String.format("原始帖子-长文-微信公众号-内容添加计划-%s", planInfo.getName());
-//                    articleAddDependPlan(produceId, planInfo.getId(), inputSourceLabel, ProducePlanInputSourceTypeEnum.contentPlan.getVal());
-//                }
-//                log.info("{}, {}, produce plan not exist: {}, {}, {}", planInfo.getName(), planInfo.getId(), accountNickName, pos, way);
-//            }
             if (CollectionUtils.isNotEmpty(publishContentIds)) {
                 String planName = String.format("%d_%s_%s_%s【%s】_%s_%s", publishContentIds.size(), today, accountNickName, pos, way, today, promotionStrategy);
                 IdNameVO<String> planInfo = aigcCrawlerPlanSaveService.createArticleUrlPlan(planName, publishContentIds, tag, CrawlerModeEnum.PublishContentIds.getVal());
@@ -329,11 +370,10 @@ public class ArticlePromotionService {
 
     private void sendFeishuJobFinishMessage(String accountNickName, Integer urlListSize, Integer contentListSize, String promotionStrategy) {
         log.info("articlePromotion finish: 晋级任务:{}, id晋级数量：{}, url晋级数量：{}", accountNickName, contentListSize, urlListSize);
-        FeishuMessageSender.sendWebHookMessage(FeishuRobotIdEnum.DAILY.getRobotId(),
+        FeishuMessageSender.sendWebHookMessage(FeishuRobotIdEnum.RECOMMEND.getRobotId(),
                 "【文章晋级job完成】\n" +
                         "晋级任务：" + accountNickName + "\n" +
                         "id晋级数量：" + contentListSize + "\n" +
-//                        "url晋级数量：" + urlListSize + "\n" +
                         "晋级策略: " + promotionStrategy + "\n");
     }
 
@@ -468,6 +508,28 @@ public class ArticlePromotionService {
         articlePoolPromotionSourceRepository.save(articlePromotion);
     }
 
+    /**
+     * 保存需求池晋级记录到独立表 demand_pool_promotion_source
+     */
+    private void saveDemandPoolPromotionSource(String channelContentId, String wxSn, String title,
+                                                String level, String accountId) {
+        DemandPoolPromotionSource source = demandPoolPromotionSourceRepository.getByChannelContentId(channelContentId);
+        if (Objects.isNull(source)) {
+            source = new DemandPoolPromotionSource();
+            source.setChannelContentId(channelContentId);
+            source.setTitle(title);
+            source.setTitleMd5(Md5Util.encoderByMd5(title));
+            source.setCreateTimestamp(System.currentTimeMillis());
+            source.setStatus(ArticlePoolPromotionSourceStatusEnum.WAITING.getCode());
+            source.setDeleted(StatusEnum.ZERO.getCode());
+        }
+        source.setWxSn(wxSn);
+        source.setLevel(level);
+        source.setAccountId(accountId);
+        source.setUpdateTimestamp(System.currentTimeMillis());
+        demandPoolPromotionSourceRepository.save(source);
+    }
+
     private void articleAddDependPlan(String produceId, String inputSourceValue, String inputSourceLabel, Integer inputSourceType) {
         try {
             // 获取生产计划的详细信息

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/ArticleService.java

@@ -17,6 +17,7 @@ import com.tzld.longarticle.recommend.server.model.entity.aigc.PublishContent;
 import com.tzld.longarticle.recommend.server.model.entity.aigc.PublishContentOutput;
 import com.tzld.longarticle.recommend.server.model.entity.crawler.Article;
 import com.tzld.longarticle.recommend.server.model.entity.longArticle.ArticlePoolPromotionSource;
+import com.tzld.longarticle.recommend.server.model.entity.longArticle.DemandPoolPromotionSource;
 import com.tzld.longarticle.recommend.server.model.entity.longArticle.LongArticlesRootSourceId;
 import com.tzld.longarticle.recommend.server.model.param.ArticleFindSourceParam;
 import com.tzld.longarticle.recommend.server.model.vo.RootPublishContentVO;
@@ -24,6 +25,7 @@ import com.tzld.longarticle.recommend.server.repository.aigc.PublishAccountRepos
 import com.tzld.longarticle.recommend.server.repository.aigc.PublishContentOutputRepository;
 import com.tzld.longarticle.recommend.server.repository.crawler.ArticleRepository;
 import com.tzld.longarticle.recommend.server.repository.longArticle.ArticlePoolPromotionSourceRepository;
+import com.tzld.longarticle.recommend.server.repository.longArticle.DemandPoolPromotionSourceRepository;
 import com.tzld.longarticle.recommend.server.repository.longArticle.LongArticlesRootSourceIdRepository;
 import com.tzld.longarticle.recommend.server.util.DateUtils;
 import com.tzld.longarticle.recommend.server.util.TitleSimilarCheckUtil;
@@ -67,6 +69,8 @@ public class ArticleService {
     @Autowired
     ArticlePoolPromotionSourceRepository articlePoolPromotionSourceRepository;
     @Autowired
+    DemandPoolPromotionSourceRepository demandPoolPromotionSourceRepository;
+    @Autowired
     LongArticlesRootSourceIdRepository longArticlesRootSourceIdRepository;
 
     private final static ExecutorService pool = new CommonThreadPoolExecutor(
@@ -355,6 +359,66 @@ public class ArticleService {
         }
     }
 
+    /**
+     * 需求池晋级溯源：处理 demand_pool_promotion_source 中待溯源的记录
+     * 与 articlePromotionTraceability 逻辑相同，但操作独立晋级表
+     */
+    public void demandPoolPromotionTraceability(String channelContentId) {
+        List<DemandPoolPromotionSource> tasks = new ArrayList<>();
+        if (StringUtils.hasText(channelContentId)) {
+            DemandPoolPromotionSource item = demandPoolPromotionSourceRepository.getByChannelContentId(channelContentId);
+            tasks.add(item);
+        } else {
+            tasks = demandPoolPromotionSourceRepository.getByStatusAndDeleted(0, 0);
+        }
+        long now = System.currentTimeMillis();
+        for (DemandPoolPromotionSource task : tasks) {
+            try {
+                // 判断文章是否被抓回来
+                CrawlerContent crawlerContent = aigcBaseMapper.getCrawlerContentByChannelContentId(task.getChannelContentId());
+                if (Objects.isNull(crawlerContent)) {
+                    continue;
+                }
+                // 溯源
+                Article article = articleRepository.getByWxSn(task.getWxSn());
+                if (Objects.isNull(article)) {
+                    task.setDeleted(StatusEnum.ONE.getCode());
+                    demandPoolPromotionSourceRepository.save(task);
+                    continue;
+                }
+                PublishAccount publishAccount = publishAccountRepository.getByGhId(article.getGhId());
+                if (Objects.isNull(publishAccount)) {
+                    continue;
+                }
+                long publishTimestamp = article.getPublishTimestamp() > 0 ? article.getPublishTimestamp() * 1000 : article.getUpdateTime() * 1000;
+                List<PublishContent> publishContentList = publishContentMapper.getNearestPublishContent(publishAccount.getId(), publishTimestamp, 100);
+                PublishContent publishContent = findPublishContent(publishContentList, task.getTitle(), publishTimestamp);
+                if (Objects.isNull(publishContent)) {
+                    publishContentList = publishContentMapper.getLateNearestPublishContent(publishAccount.getId(), publishTimestamp);
+                    publishContent = findPublishContent(publishContentList, task.getTitle(), publishTimestamp);
+                    if (Objects.isNull(publishContent)) {
+                        task.setDeleted(StatusEnum.ONE.getCode());
+                        demandPoolPromotionSourceRepository.save(task);
+                        continue;
+                    }
+                }
+                RootPublishContentVO source = getRootPublishContent(publishContent.getCrawlerChannelContentId(), null, publishContent.getId(), publishContent.getSourceId(), 0);
+                if (StringUtils.hasText(source.getRootProduceContentId())) {
+                    task.setStatus(ArticlePoolPromotionSourceStatusEnum.FINISH.getCode());
+                    task.setSourcePublishContentId(source.getSourcePublishContentId());
+                    task.setRootProduceContentId(source.getRootProduceContentId());
+                    task.setUpdateTimestamp(now);
+                    demandPoolPromotionSourceRepository.save(task);
+                } else {
+                    task.setDeleted(StatusEnum.ONE.getCode());
+                    demandPoolPromotionSourceRepository.save(task);
+                }
+            } catch (Exception e) {
+                log.error("demandPoolPromotionTraceability error channelContentId:{}", task.getChannelContentId(), e);
+            }
+        }
+    }
+
     public String getPublishContentByWxSn(String wxSn) {
         Article article = articleRepository.getByWxSn(wxSn);
         PublishAccount publishAccount = publishAccountRepository.getByGhId(article.getGhId());

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/ArticleVideoAuditService.java

@@ -374,7 +374,8 @@ public class ArticleVideoAuditService {
         int index = random.nextInt(auditUser.size());
         String auditAccount = auditUser.get(index);
         int status = ArticleVideoAuditStatusEnum.WAITING.getCode();
-        if (!Objects.equals(param.getFlowPoolLevel(), ContentPoolEnum.autoArticlePoolLevel4.getContentPool())) {
+        if (!Objects.equals(param.getFlowPoolLevel(), ContentPoolEnum.autoArticlePoolLevel4.getContentPool())
+                && !Objects.equals(param.getFlowPoolLevel(), ContentPoolEnum.accountDemandPoolLevelCold.getContentPool())) {
             if (Objects.nonNull(exeRecord)) {
                 String channelContentId = exeRecord.getChannelContentId();
                 ArticlePoolPromotionSource source = articlePoolPromotionSourceRepository.getByChannelContentId(channelContentId);

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/DataDashboardService.java

@@ -2600,7 +2600,8 @@ public class DataDashboardService {
         }
         Map<String, ContentPoolTypeDTO> poolTypeMap = poolTypeDTOS.stream().collect(Collectors.toMap(ContentPoolTypeDTO::getContentId, o -> o));
         Map<String, VideoAuditExport> map = new HashMap<>();
-        ContentPoolEnum[] poolEnums = {ContentPoolEnum.autoArticlePoolLevel1, ContentPoolEnum.autoArticlePoolLevel3, ContentPoolEnum.autoArticlePoolLevel4};
+        ContentPoolEnum[] poolEnums = {ContentPoolEnum.autoArticlePoolLevel1, ContentPoolEnum.autoArticlePoolLevel3, ContentPoolEnum.autoArticlePoolLevel4,
+                ContentPoolEnum.accountDemandPoolLevelCold, ContentPoolEnum.accountDemandPoolLevelUtilize};
         for (ContentPoolEnum contentPool : poolEnums) {
             VideoAuditExport videoAuditExport = new VideoAuditExport();
             videoAuditExport.setDateStr(dateStr);

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/PublishContentFilterService.java

@@ -35,7 +35,8 @@ public class PublishContentFilterService {
                 continue;
             }
             boolean isDuplicate = false;
-            if (ContentPoolEnum.autoArticlePoolLevel4.getContentPool().equals(contentItem.getPoolLevel())) {
+            if (ContentPoolEnum.autoArticlePoolLevel4.getContentPool().equals(contentItem.getPoolLevel())
+                    || ContentPoolEnum.accountDemandPoolLevelCold.getContentPool().equals(contentItem.getPoolLevel())) {
                 isDuplicate = TitleSimilarCheckUtil.isDuplicateContentByCache(contentItem.getTitle(),
                         firstSecondTitleCache, TitleSimilarCheckUtil.SIMILARITY_THRESHOLD);
             }

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/RankContentScoreService.java

@@ -147,10 +147,12 @@ public class RankContentScoreService {
     private List<Content> filterHeadContents(List<Content> contents) {
         List<Content> result = new ArrayList<>();
         String coldStartPool = ContentPoolEnum.autoArticlePoolLevel4.getContentPool();
+        String demandColdStartPool = ContentPoolEnum.accountDemandPoolLevelCold.getContentPool();
 
         for (Content content : contents) {
             // 跳过冷启池内容
-            if (coldStartPool.equals(content.getContentPoolType())) {
+            if (coldStartPool.equals(content.getContentPoolType())
+                    || demandColdStartPool.equals(content.getContentPoolType())) {
                 continue;
             }
             result.add(content);

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/RecommendService.java

@@ -17,6 +17,7 @@ import com.tzld.longarticle.recommend.server.mapper.longArticle.LongArticleBaseM
 import com.tzld.longarticle.recommend.server.model.cgi.VideoArticleMatchRecord;
 import com.tzld.longarticle.recommend.server.model.cgi.VideoArticleMatchResponse;
 import com.tzld.longarticle.recommend.server.model.dto.Content;
+import com.tzld.longarticle.recommend.server.model.dto.DemandSearchArticleRelationDTO;
 import com.tzld.longarticle.recommend.server.model.dto.UserGroupCountDTO;
 import com.tzld.longarticle.recommend.server.model.entity.crawler.AccountAvgInfo;
 import com.tzld.longarticle.recommend.server.model.entity.crawler.PublishSortLog;
@@ -42,6 +43,7 @@ import com.tzld.longarticle.recommend.server.util.CommonCollectionUtils;
 import com.tzld.longarticle.recommend.server.util.DateUtils;
 import com.tzld.longarticle.recommend.server.util.JSONUtils;
 import com.tzld.longarticle.recommend.server.util.RedisUtil;
+import com.tzld.longarticle.recommend.server.util.TitleSimilarCheckUtil;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.collections4.CollectionUtils;
 import org.springframework.beans.BeanUtils;
@@ -58,6 +60,7 @@ import java.util.*;
 import java.util.concurrent.CompletableFuture;
 import java.util.stream.Collectors;
 
+import static com.tzld.longarticle.recommend.server.common.constant.SceneConstants.DEMAND_POOL;
 import static com.tzld.longarticle.recommend.server.common.constant.SceneConstants.FWH_COLD_START;
 
 /**
@@ -340,6 +343,339 @@ public class RecommendService {
                 new RecommendWithUserGroupResponse.RecommendWithUserGroupData(rankList, filterList));
     }
 
+    public RecommendResponse recommendDemandPool(RecommendRequest request) {
+        long start = System.currentTimeMillis();
+
+        RecommendParam param = genRecommendParam(request, DEMAND_POOL);
+        param.setStrategy(RankStrategyEnum.DEMAND_POOL_STRATEGY.getStrategy());
+        log.info("recommendDemandPool genRecommendParam {}", JSONUtils.toJson(param));
+
+        RecallResult recallResult = recallService.recall(convertToRecallParam(param));
+
+        if (CollectionUtils.isEmpty(recallResult.getData())) {
+            RecommendResponse response = new RecommendResponse();
+            response.setCode(0);
+            response.setMsg("success");
+            return response;
+        }
+        long t2 = System.currentTimeMillis();
+        CostMonitor.logCost("RecommendDemandPool", "Recall", t2 - start);
+
+        // 召回后检查内容池是否为空
+        String utilizePool = ContentPoolEnum.accountDemandPoolLevelUtilize.getContentPool();
+        String coldPool = ContentPoolEnum.accountDemandPoolLevelCold.getContentPool();
+        boolean hasUtilize = false;
+        boolean hasCold = false;
+        for (RecallResult.RecallData rd : recallResult.getData()) {
+            if (CollectionUtils.isNotEmpty(rd.getContents())) {
+                for (Content c : rd.getContents()) {
+                    if (utilizePool.equals(c.getContentPoolType())) {
+                        hasUtilize = true;
+                    } else if (coldPool.equals(c.getContentPoolType())) {
+                        hasCold = true;
+                    }
+                    if (hasUtilize && hasCold) {
+                        break;
+                    }
+                }
+            }
+        }
+        boolean needsFallback = !hasUtilize || !hasCold;
+
+        // 回填 experiment_id：需求池内容通过 account_id + sourceId 查 demand_produce_content_relation
+        enrichDemandExperimentId(recallResult, request.getAccountId());
+
+        if (needsFallback) {
+            log.info("recommendDemandPool pool empty utilize:{} cold:{}, running new rank and old recall+rank in parallel. accountName:{}",
+                    hasUtilize, hasCold, request.getAccountName());
+
+            // 并行：新排序 + 老召排
+            CompletableFuture<RankResult> newRankFuture = CompletableFuture.supplyAsync(() -> {
+                long ft1 = System.currentTimeMillis();
+                RankResult result = rankService.rank(convertToRankParam(param, recallResult));
+                long ft2 = System.currentTimeMillis();
+                CostMonitor.logCost("RecommendDemandPool", "NewRank", ft2 - ft1);
+                return result;
+            });
+
+            CompletableFuture<OldRecallRankResult> fallbackFuture = CompletableFuture.supplyAsync(() -> {
+                long ft1 = System.currentTimeMillis();
+                RecommendParam fallbackParam = genRecommendParam(request, SceneConstants.DEFAULT);
+                setStrategy(request, fallbackParam);
+                RecallResult fallbackRecallResult = recallService.recall(convertToRecallParam(fallbackParam));
+                long ft2 = System.currentTimeMillis();
+                CostMonitor.logCost("RecommendDemandPool", "FallbackRecall", ft2 - ft1);
+                if (CollectionUtils.isEmpty(fallbackRecallResult.getData())) {
+                    return null;
+                }
+                RankResult fallbackRankResult = rankService.rank(convertToRankParam(fallbackParam, fallbackRecallResult));
+                long ft3 = System.currentTimeMillis();
+                CostMonitor.logCost("RecommendDemandPool", "FallbackRank", ft3 - ft2);
+                return new OldRecallRankResult(fallbackRecallResult, fallbackRankResult);
+            });
+
+            RankResult newRankResult = newRankFuture.join();
+            OldRecallRankResult fallbackResult = fallbackFuture.join();
+
+            // 合并：非空池用新结果，空池用老结果兜底
+            List<Content> merged = mergeResults(newRankResult.getContents(),
+                    fallbackResult != null ? fallbackResult.rankResult.getContents() : null,
+                    hasUtilize, hasCold, utilizePool, coldPool, param.getPublishNum());
+
+            // 合并 filterContents
+            List<Content> mergedFilterContents = new ArrayList<>();
+            addFilterContents(mergedFilterContents, recallResult);
+            addFilterContents(mergedFilterContents, fallbackResult != null ? fallbackResult.recallResult : null);
+
+            RankResult mergedRankResult = new RankResult(merged);
+            excludeArticleIndex(mergedRankResult, request.getExcludeContentIndex());
+            saveSortLog(param, mergedRankResult);
+
+            // 构建响应时使用合并后的 filterContents
+            RecommendResponse response = buildRecommendResponseWithFilters(mergedRankResult, mergedFilterContents, param.getPublishNum());
+            long t4 = System.currentTimeMillis();
+            log.info("recommendDemandPool merged resultSize:{} total:{}", merged.size(), t4 - start);
+            CostMonitor.logCost("RecommendDemandPool", "Total", t4 - start);
+            return response;
+        }
+
+        // 池子都非空，正常新排序
+        RankResult rankResult = rankService.rank(convertToRankParam(param, recallResult));
+        long t3 = System.currentTimeMillis();
+        CostMonitor.logCost("RecommendDemandPool", "Rank", t3 - t2);
+
+        excludeArticleIndex(rankResult, request.getExcludeContentIndex());
+        saveSortLog(param, rankResult);
+
+        RecommendResponse response = buildRecommendResponse(recallResult, rankResult, param.getPublishNum());
+        long t4 = System.currentTimeMillis();
+        log.info("recommendDemandPool cost param:{} total:{} recall:{} rank:{}",
+                JSONObject.toJSONString(request), t4 - start, t2 - start, t3 - t2);
+        CostMonitor.logCost("RecommendDemandPool", "Total", t4 - start);
+        return response;
+    }
+
+    /**
+     * 合并新排序结果和老排序结果，空池位置用老结果兜底
+     */
+    private List<Content> mergeResults(List<Content> newContents, List<Content> oldContents,
+                                        boolean hasUtilize, boolean hasCold,
+                                        String utilizePool, String coldPool, int size) {
+        List<Content> merged = new ArrayList<>();
+        List<String> usedTitles = new ArrayList<>();
+
+        // 拆分新结果
+        List<Content> newUtilize = new ArrayList<>();
+        List<Content> newCold = new ArrayList<>();
+        if (CollectionUtils.isNotEmpty(newContents)) {
+            for (Content c : newContents) {
+                if (utilizePool.equals(c.getContentPoolType())) {
+                    newUtilize.add(c);
+                } else if (coldPool.equals(c.getContentPoolType())) {
+                    newCold.add(c);
+                }
+            }
+        }
+
+        List<Content> oldList = oldContents != null ? oldContents : new ArrayList<>();
+
+        // 位置 1-2：利用池内容
+        if (hasUtilize) {
+            for (Content c : newUtilize) {
+                if (merged.size() >= 2) break;
+                if (!TitleSimilarCheckUtil.isDuplicateContent(c.getTitle(), usedTitles, TitleSimilarCheckUtil.SIMILARITY_THRESHOLD)) {
+                    merged.add(c);
+                    usedTitles.add(c.getTitle());
+                }
+            }
+        }
+        // 利用池为空，从老结果取兜底
+        if (!hasUtilize) {
+            for (Content c : oldList) {
+                if (merged.size() >= 2) break;
+                if (!TitleSimilarCheckUtil.isDuplicateContent(c.getTitle(), usedTitles, TitleSimilarCheckUtil.SIMILARITY_THRESHOLD)) {
+                    merged.add(c);
+                    usedTitles.add(c.getTitle());
+                }
+            }
+        }
+
+        // 位置 3-8：冷启池内容
+        if (hasCold) {
+            for (Content c : newCold) {
+                if (merged.size() >= size) break;
+                if (!TitleSimilarCheckUtil.isDuplicateContent(c.getTitle(), usedTitles, TitleSimilarCheckUtil.SIMILARITY_THRESHOLD)) {
+                    merged.add(c);
+                    usedTitles.add(c.getTitle());
+                }
+            }
+        }
+        // 冷启池为空，从老结果取兜底
+        if (!hasCold) {
+            for (Content c : oldList) {
+                if (merged.size() >= size) break;
+                if (!TitleSimilarCheckUtil.isDuplicateContent(c.getTitle(), usedTitles, TitleSimilarCheckUtil.SIMILARITY_THRESHOLD)) {
+                    // 跳过已经被利用池使用的
+                    boolean alreadyUsed = false;
+                    for (Content existing : merged) {
+                        if (Objects.equals(existing.getId(), c.getId())) {
+                            alreadyUsed = true;
+                            break;
+                        }
+                    }
+                    if (!alreadyUsed) {
+                        if (!TitleSimilarCheckUtil.isDuplicateContent(c.getTitle(), usedTitles, TitleSimilarCheckUtil.SIMILARITY_THRESHOLD)) {
+                            merged.add(c);
+                            usedTitles.add(c.getTitle());
+                        }
+                    }
+                }
+            }
+        }
+
+        return merged;
+    }
+
+    private void addFilterContents(List<Content> target, RecallResult recallResult) {
+        if (recallResult == null || CollectionUtils.isEmpty(recallResult.getData())) {
+            return;
+        }
+        for (RecallResult.RecallData data : recallResult.getData()) {
+            if (CollectionUtils.isNotEmpty(data.getFilterContents())) {
+                target.addAll(data.getFilterContents());
+            }
+        }
+    }
+
+    private RecommendResponse buildRecommendResponseWithFilters(RankResult rankResult,
+                                                                  List<Content> filterContents, Integer publishNum) {
+        List<Content> contentList = rankResult.getContents();
+        List<ArticleSortResponseDataItem> rankList = new ArrayList<>();
+        List<ArticleSortResponseDataItem> filterContentList = new ArrayList<>();
+        if (CollectionUtils.isNotEmpty(filterContents)) {
+            for (Content filterContent : filterContents) {
+                ArticleSortResponseDataItem item = new ArticleSortResponseDataItem();
+                BeanUtils.copyProperties(filterContent, item);
+                filterContentList.add(item);
+            }
+        }
+        ArticleSortResponseData data = new ArticleSortResponseData();
+        if (CollectionUtils.isNotEmpty(contentList)) {
+            for (Content content : contentList) {
+                ArticleSortResponseDataItem item = new ArticleSortResponseDataItem();
+                BeanUtils.copyProperties(content, item);
+                rankList.add(item);
+            }
+        }
+        data.setRank_list(rankList.subList(0, Math.min(rankList.size(), publishNum)));
+        data.setFilter_list(filterContentList);
+
+        CompletableFuture.runAsync(() -> updateWaitingContentFilter(filterContentList));
+
+        RecommendResponse response = new RecommendResponse();
+        response.setCode(0);
+        response.setMsg("success");
+        response.setData(data);
+        return response;
+    }
+
+    private static class OldRecallRankResult {
+        final RecallResult recallResult;
+        final RankResult rankResult;
+
+        OldRecallRankResult(RecallResult recallResult, RankResult rankResult) {
+            this.recallResult = recallResult;
+            this.rankResult = rankResult;
+        }
+    }
+
+    /**
+     * 从 demand_search_article_relation 表回填 experiment_id 到召回结果
+     */
+    /**
+     * 回填 experiment_id 到召回结果
+     * - accountDemandPoolLevelCold / accountDemandPoolLevelUtilize → demand_produce_content_relation (by account_id + sourceId)
+     * - 其他内容 → demand_search_article_relation (by channel_content_id)
+     */
+    private void enrichDemandExperimentId(RecallResult recallResult, String accountId) {
+        if (recallResult == null || CollectionUtils.isEmpty(recallResult.getData())) {
+            return;
+        }
+        String coldPool = ContentPoolEnum.accountDemandPoolLevelCold.getContentPool();
+        String utilizePool = ContentPoolEnum.accountDemandPoolLevelUtilize.getContentPool();
+        Set<String> demandPoolSourceIds = new HashSet<>();
+        Set<String> otherChannelContentIds = new HashSet<>();
+
+        for (RecallResult.RecallData rd : recallResult.getData()) {
+            if (CollectionUtils.isNotEmpty(rd.getContents())) {
+                for (Content c : rd.getContents()) {
+                    if (coldPool.equals(c.getContentPoolType()) || utilizePool.equals(c.getContentPoolType())) {
+                        if (StringUtils.hasText(c.getSourceId())) {
+                            demandPoolSourceIds.add(c.getSourceId());
+                        }
+                    } else {
+                        if (StringUtils.hasText(c.getCrawlerChannelContentId())) {
+                            otherChannelContentIds.add(c.getCrawlerChannelContentId());
+                        }
+                    }
+                }
+            }
+        }
+
+        Map<String, String> contentIdToExperimentId = new HashMap<>();
+
+        // 需求池：通过 account_id + sourceId(=content_id) 查 demand_produce_content_relation
+        if (!demandPoolSourceIds.isEmpty() && StringUtils.hasText(accountId)) {
+            List<DemandSearchArticleRelationDTO> mappings = longArticleBaseMapper
+                    .getDemandExperimentIdByContentIds(new ArrayList<>(demandPoolSourceIds), accountId);
+            if (CollectionUtils.isNotEmpty(mappings)) {
+                for (DemandSearchArticleRelationDTO m : mappings) {
+                    if (StringUtils.hasText(m.getContentId()) && StringUtils.hasText(m.getExperimentId())) {
+                        contentIdToExperimentId.put(m.getContentId(), m.getExperimentId());
+                    }
+                }
+            }
+        }
+
+        // 其他内容：查 demand_search_article_relation
+        if (!otherChannelContentIds.isEmpty()) {
+            List<DemandSearchArticleRelationDTO> mappings = longArticleBaseMapper
+                    .getDemandExperimentIdByChannelContentIds(new ArrayList<>(otherChannelContentIds));
+            if (CollectionUtils.isNotEmpty(mappings)) {
+                for (DemandSearchArticleRelationDTO m : mappings) {
+                    if (StringUtils.hasText(m.getChannelContentId()) && StringUtils.hasText(m.getExperimentId())) {
+                        contentIdToExperimentId.put(m.getChannelContentId(), m.getExperimentId());
+                    }
+                }
+            }
+        }
+
+        if (contentIdToExperimentId.isEmpty()) {
+            return;
+        }
+
+        // 回填到 Content：需求池按 sourceId 匹配，其他按 crawlerChannelContentId
+        for (RecallResult.RecallData rd : recallResult.getData()) {
+            if (CollectionUtils.isNotEmpty(rd.getContents())) {
+                for (Content c : rd.getContents()) {
+                    if (coldPool.equals(c.getContentPoolType()) || utilizePool.equals(c.getContentPoolType())) {
+                        String expId = contentIdToExperimentId.get(c.getSourceId());
+                        if (expId != null) {
+                            c.setExperimentId(expId);
+                        }
+                    } else {
+                        String expId = contentIdToExperimentId.get(c.getCrawlerChannelContentId());
+                        if (expId != null) {
+                            c.setExperimentId(expId);
+                        }
+                    }
+                }
+            }
+        }
+        log.info("enrichDemandExperimentId enriched {} experimentIds (demandPool={}, other={})",
+                contentIdToExperimentId.size(), demandPoolSourceIds.size(), otherChannelContentIds.size());
+    }
+
     private RecommendResponse buildRecommendResponse(RecallResult recallResult, RankResult rankResult, Integer publishNum) {
         List<Content> contentList = rankResult.getContents();
         List<ArticleSortResponseDataItem> rankList = new ArrayList<>();

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/filter/FilterService.java

@@ -26,6 +26,7 @@ import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
 
+import static com.tzld.longarticle.recommend.server.common.constant.SceneConstants.DEMAND_POOL;
 import static com.tzld.longarticle.recommend.server.common.constant.SceneConstants.FWH_COLD_START;
 
 @Slf4j
@@ -132,6 +133,17 @@ public class FilterService {
 
     private List<FilterStrategy> getAllStrategies(FilterParam param) {
         List<FilterStrategy> strategies = new ArrayList<>();
+        if (param.getScene().equals(DEMAND_POOL)) {
+            strategies.add(ServiceBeanFactory.getBean(BadStrategy.class));
+            strategies.add(ServiceBeanFactory.getBean(SensitiveStrategy.class));
+            strategies.add(ServiceBeanFactory.getBean(DeDuplicationStrategy.class));
+            strategies.add(ServiceBeanFactory.getBean(KeywordStrategy.class));
+            strategies.add(ServiceBeanFactory.getBean(DemandPoolPromotionStrategy.class));
+            strategies.add(ServiceBeanFactory.getBean(TodayPublishStrategy.class));
+            strategies.add(ServiceBeanFactory.getBean(CategoryFilterStrategy.class));
+            strategies.add(ServiceBeanFactory.getBean(HistoryTitleStrategy.class));
+            return strategies;
+        }
         strategies.add(ServiceBeanFactory.getBean(BadStrategy.class));
         strategies.add(ServiceBeanFactory.getBean(SensitiveStrategy.class));
         strategies.add(ServiceBeanFactory.getBean(DeDuplicationStrategy.class));
@@ -157,6 +169,16 @@ public class FilterService {
 
     private List<FilterStrategy> getPreFilterStrategies(FilterParam param) {
         List<FilterStrategy> strategies = new ArrayList<>();
+        if (param.getScene().equals(DEMAND_POOL)) {
+            strategies.add(ServiceBeanFactory.getBean(BadStrategy.class));
+            strategies.add(ServiceBeanFactory.getBean(SensitiveStrategy.class));
+            strategies.add(ServiceBeanFactory.getBean(DeDuplicationStrategy.class));
+            strategies.add(ServiceBeanFactory.getBean(KeywordStrategy.class));
+            strategies.add(ServiceBeanFactory.getBean(DemandPoolPromotionStrategy.class));
+            strategies.add(ServiceBeanFactory.getBean(CategoryFilterStrategy.class));
+            strategies.add(ServiceBeanFactory.getBean(HistoryTitleStrategy.class));
+            return strategies;
+        }
         strategies.add(ServiceBeanFactory.getBean(BadStrategy.class));
         strategies.add(ServiceBeanFactory.getBean(SensitiveStrategy.class));
         strategies.add(ServiceBeanFactory.getBean(DeDuplicationStrategy.class));
@@ -179,6 +201,11 @@ public class FilterService {
 
     private List<FilterStrategy> getUnPreFilterStrategies(FilterParam param) {
         List<FilterStrategy> strategies = new ArrayList<>();
+        if (param.getScene().equals(DEMAND_POOL)) {
+            strategies.add(ServiceBeanFactory.getBean(TodayPublishStrategy.class));
+            strategies.add(ServiceBeanFactory.getBean(CategoryFilterStrategy.class));
+            return strategies;
+        }
         strategies.add(ServiceBeanFactory.getBean(TodayPublishStrategy.class));
         strategies.add(ServiceBeanFactory.getBean(CategoryFilterStrategy.class));
         if (!param.getScene().equals(FWH_COLD_START)

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/filter/strategy/DemandPoolPromotionStrategy.java

@@ -0,0 +1,62 @@
+package com.tzld.longarticle.recommend.server.service.recommend.filter.strategy;
+
+import com.tzld.longarticle.recommend.server.model.dto.Content;
+import com.tzld.longarticle.recommend.server.model.entity.longArticle.DemandPoolPromotionSource;
+import com.tzld.longarticle.recommend.server.repository.longArticle.DemandPoolPromotionSourceRepository;
+import com.tzld.longarticle.recommend.server.service.recommend.filter.FilterParam;
+import com.tzld.longarticle.recommend.server.service.recommend.filter.FilterResult;
+import com.tzld.longarticle.recommend.server.service.recommend.filter.FilterStrategy;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.springframework.util.StringUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * 需求匹配内容池晋级过滤
+ * 过滤已从冷启池晋级到利用池的内容（独立晋级表 demand_pool_promotion_source）
+ *
+ * @author dyp
+ */
+@Component
+@Slf4j
+public class DemandPoolPromotionStrategy implements FilterStrategy {
+
+    @Autowired
+    DemandPoolPromotionSourceRepository repository;
+
+    @Override
+    public FilterResult filter(FilterParam param) {
+        FilterResult filterResult = new FilterResult();
+        List<String> result = new ArrayList<>();
+        List<Content> contents = param.getContents();
+        List<Content> filterContents = new ArrayList<>();
+
+        List<DemandPoolPromotionSource> promotionSourceList = repository.getByStatusAndDeleted(1, 0);
+        Map<String, DemandPoolPromotionSource> promotionSourceMap = promotionSourceList.stream()
+                .collect(Collectors.toMap(DemandPoolPromotionSource::getChannelContentId, a -> a, (a, b) -> a));
+
+        for (Content content : contents) {
+            if (promotionSourceMap.containsKey(content.getCrawlerChannelContentId())) {
+                DemandPoolPromotionSource promotionSource = promotionSourceMap.get(content.getCrawlerChannelContentId());
+                if (!promotionSource.getLevel().equals(content.getContentPoolType())) {
+                    content.setFilterReason("内容已晋级过滤");
+                    filterContents.add(content);
+                    continue;
+                }
+            }
+            if (!StringUtils.hasText(content.getFilterReason())) {
+                result.add(content.getId());
+            }
+        }
+
+        filterResult.setContentIds(result);
+        filterResult.setFilterContent(filterContents);
+        return filterResult;
+    }
+
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/rank/RankService.java

@@ -16,6 +16,7 @@ import com.tzld.longarticle.recommend.server.model.dto.Content;
 import com.tzld.longarticle.recommend.server.model.entity.aigc.PublishContent;
 import com.tzld.longarticle.recommend.server.repository.aigc.PublishContentRepository;
 import com.tzld.longarticle.recommend.server.service.ServiceBeanFactory;
+import com.tzld.longarticle.recommend.server.service.recommend.rank.strategy.DemandPoolRankStrategy;
 import com.tzld.longarticle.recommend.server.service.recommend.rank.strategy.FwhColdStartRankStrategy;
 import com.tzld.longarticle.recommend.server.service.recommend.score.AccountIndexReplacePoolConfig;
 import com.tzld.longarticle.recommend.server.util.TitleSimilarCheckUtil;
@@ -32,6 +33,7 @@ import java.util.Map;
 import java.util.Objects;
 import java.util.stream.Collectors;
 
+import static com.tzld.longarticle.recommend.server.common.constant.SceneConstants.DEMAND_POOL;
 import static com.tzld.longarticle.recommend.server.common.constant.SceneConstants.FWH_COLD_START;
 
 /**
@@ -101,6 +103,8 @@ public class RankService implements InitializingBean {
         switch (param.getScene()) {
             case FWH_COLD_START:
                 return ServiceBeanFactory.getBean(FwhColdStartRankStrategy.class);
+            case DEMAND_POOL:
+                return ServiceBeanFactory.getBean(DemandPoolRankStrategy.class);
             default:
                 RankStrategyEnum rankStrategyEnum = RankStrategyEnum.from(param.getStrategy());
                 return (RankStrategy) ServiceBeanFactory.getBeanByName(rankStrategyEnum.getTaskExecutorName());

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/rank/strategy/DemandPoolRankStrategy.java

@@ -0,0 +1,100 @@
+package com.tzld.longarticle.recommend.server.service.recommend.rank.strategy;
+
+import com.tzld.longarticle.recommend.server.common.enums.recommend.ContentPoolEnum;
+import com.tzld.longarticle.recommend.server.common.enums.recommend.ScoreStrategyEnum;
+import com.tzld.longarticle.recommend.server.model.dto.Content;
+import com.tzld.longarticle.recommend.server.service.recommend.rank.*;
+import com.tzld.longarticle.recommend.server.service.recommend.score.ScoreResult;
+import com.tzld.longarticle.recommend.server.service.recommend.score.ScoreService;
+import com.tzld.longarticle.recommend.server.util.CommonCollectionUtils;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.collections4.CollectionUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+
+/**
+ * 需求匹配内容池排序策略
+ * <p>
+ * 内容池划分：
+ * - 利用池 (accountDemandPoolLevelUtilize): 头次，发 1-2 位
+ * - 冷启池 (accountDemandPoolLevelCold): 冷启，发 3-8 位
+ * <p>
+ * 排序使用历史表现阅读分 + 品类分，安全分降权
+ *
+ * @author dyp
+ */
+@Service
+@Slf4j
+public class DemandPoolRankStrategy implements RankStrategy {
+
+    @Autowired
+    private ScoreService scoreService;
+
+    @Override
+    public RankResult rank(RankParam param) {
+
+        ScoreResult scoreResult = scoreService.score(RankStrategy.convertToScoreParam(param));
+        Map<String, Map<String, Double>> scoreMap = scoreResult.getScoreMap();
+
+        String utilizePool = ContentPoolEnum.accountDemandPoolLevelUtilize.getContentPool();
+        String coldPool = ContentPoolEnum.accountDemandPoolLevelCold.getContentPool();
+
+        // 按内容池划分
+        List<RankItem> utilizeItems = new ArrayList<>();
+        List<RankItem> coldItems = new ArrayList<>();
+
+        for (Content c : param.getContents()) {
+            RankItem item = new RankItem();
+            c.setHisPublishArticleList(null);
+            item.setContent(c);
+            item.setScoreMap(scoreMap.get(c.getId()));
+
+            double score = item.getScore(ScoreStrategyEnum.VIEW_COUNT.value())
+                    + item.getScore(ScoreStrategyEnum.VIEW_COUNT_RATE.value())
+                    + item.getScore(ScoreStrategyEnum.CATEGORY.value())
+                    + item.getScore(ScoreStrategyEnum.FLOW_CTL_DECREASE.value());
+            item.setScore(score);
+
+            if (utilizePool.equals(c.getContentPoolType())) {
+                utilizeItems.add(item);
+            } else if (coldPool.equals(c.getContentPoolType())) {
+                coldItems.add(item);
+            }
+        }
+
+        // 安全分降权
+        RankService.safeScoreDecrease(utilizeItems);
+        RankService.safeScoreDecrease(coldItems);
+
+        // 各池按分数降序排序
+        utilizeItems.sort((o1, o2) -> -Double.compare(o1.getScore(), o2.getScore()));
+        coldItems.sort((o1, o2) -> -Double.compare(o1.getScore(), o2.getScore()));
+
+        // 相似去重
+        List<Content> utilizeContents = CommonCollectionUtils.toList(utilizeItems, RankItem::getContent);
+        List<Content> coldContents = CommonCollectionUtils.toList(coldItems, RankItem::getContent);
+
+        // 异步保存排序内容分数
+        List<RankItem> allItems = new ArrayList<>();
+        allItems.addAll(utilizeItems);
+        allItems.addAll(coldItems);
+        RankStrategy.asyncSaveRankContentScore(param, allItems);
+
+        // 组装结果：利用池取前2发头次，冷启池取前6发3-8位
+        List<Content> result = new ArrayList<>();
+        int utilizeCount = Math.min(utilizeContents.size(), 2);
+        result.addAll(utilizeContents.subList(0, utilizeCount));
+
+        int remaining = param.getSize() - result.size();
+        if (remaining > 0 && CollectionUtils.isNotEmpty(coldContents)) {
+            int coldCount = Math.min(coldContents.size(), remaining);
+            result.addAll(coldContents.subList(0, coldCount));
+        }
+
+        RankResult rankResult = new RankResult(result);
+        return rankResult;
+    }
+
+}

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/service/recommend/score/ScoreService.java

@@ -105,6 +105,15 @@ public class ScoreService implements ApplicationContextAware {
         if (StringUtils.equals(param.getStrategy(), RankStrategyEnum.RANDOM_STRATEGY.getStrategy())) {
             return strategies;
         }
+        if (StringUtils.equals(param.getStrategy(), RankStrategyEnum.DEMAND_POOL_STRATEGY.getStrategy())) {
+            strategies.add(strategyMap.get(ScoreStrategyEnum.VIEW_COUNT.value()));
+            strategies.add(strategyMap.get(ScoreStrategyEnum.VIEW_COUNT_RATE.value()));
+            strategies.add(strategyMap.get(ScoreStrategyEnum.VIEW_COUNT_RATE_V2.value()));
+            strategies.add(strategyMap.get(ScoreStrategyEnum.CATEGORY.value()));
+            strategies.add(strategyMap.get(ScoreStrategyEnum.ACCOUNT_USER_CATEGORY.value()));
+            strategies.add(strategyMap.get(ScoreStrategyEnum.FLOW_CTL_DECREASE.value()));
+            return strategies;
+        }
         strategies.add(strategyMap.get(ScoreStrategyEnum.CRAWLER_DAYS_DECREASE_STRATEGY.value()));
         strategies.add(strategyMap.get(ScoreStrategyEnum.CRAWLER_DAYS_DECREASE_V2_STRATEGY.value()));
         if (!similarityStopStrategies.contains(param.getStrategy())

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/web/XxlJobController.java

@@ -72,14 +72,24 @@ public class XxlJobController {
         service.articlePromotion(null);
     }
 
+    @GetMapping("/articlePromotionTraceability")
+    public void articlePromotionTraceability(String channelContentId) {
+        service.articlePromotionTraceability(channelContentId);
+    }
+
     @GetMapping("/articleVideoPoolPromotion")
     public void articleVideoPoolPromotion() {
         service.articleVideoPoolPromotion(null);
     }
 
-    @GetMapping("/articlePromotionTraceability")
-    public void articlePromotionTraceability(String channelContentId) {
-        service.articlePromotionTraceability(channelContentId);
+    @GetMapping("/demandPoolPromotion")
+    public void demandPoolPromotion() {
+        service.demandPoolPromotion(null);
+    }
+
+    @GetMapping("/demandPoolPromotionTraceability")
+    public void demandPoolPromotionTraceability(String channelContentId) {
+        service.demandPoolPromotionTraceability(channelContentId);
     }
 
     @GetMapping("/articleCategoryJob")

long-article-recommend-service/src/main/java/com/tzld/longarticle/recommend/server/web/recommend/RecommendController.java

@@ -1,5 +1,6 @@
 package com.tzld.longarticle.recommend.server.web.recommend;
 
+import com.ctrip.framework.apollo.spring.annotation.ApolloJsonValue;
 import com.tzld.longarticle.recommend.server.common.response.CommonResponse;
 import com.tzld.longarticle.recommend.server.model.param.RecommendRequest;
 import com.tzld.longarticle.recommend.server.model.vo.RecommendResponse;
@@ -13,27 +14,40 @@ import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 
+import java.util.List;
+
 /**
  * @author dyp
  */
 @RestController
 @Slf4j
 public class RecommendController {
+
     @Autowired
     private RecommendService recommendService;
 
+    @ApolloJsonValue("${recommendDemandPool.accounts:[]}")
+    private List<String> recommendDemandPoolAccounts;
+
     @RequestMapping("/recommend")
     public RecommendResponse recommend(@RequestBody RecommendRequest httpRequest) {
-
+        if (StringUtils.hasText(httpRequest.getAccountId())
+                && recommendDemandPoolAccounts.contains(httpRequest.getAccountId())) {
+            return recommendService.recommendDemandPool(httpRequest);
+        }
         return recommendService.recommend(httpRequest);
     }
 
     @RequestMapping("/recommend4FwhColdStart")
     public RecommendWithUserGroupResponse recommend4FwhColdStart(@RequestBody RecommendRequest httpRequest) {
-
         return recommendService.recommend4FwhColdStart(httpRequest);
     }
 
+    @RequestMapping("/recommendDemandPool")
+    public RecommendResponse recommendDemandPool(@RequestBody RecommendRequest httpRequest) {
+        return recommendService.recommendDemandPool(httpRequest);
+    }
+
     @RequestMapping("/deleteGzhWaiting")
     public CommonResponse<Void> deleteGzhWaiting(@RequestParam String planId,
                                                  @RequestParam String publishAccountId) {

long-article-recommend-service/src/main/resources/mapper/aigc/AigcBaseMapper.xml

@@ -493,4 +493,14 @@
           and ppa.publish_open_flag = 1 and pps.push_type = 5
     </select>
 
+    <select id="getProducePlanExeRecordByChannelContentIds"
+            resultType="com.tzld.longarticle.recommend.server.model.entity.aigc.ProducePlanExeRecord">
+        select plan_exe_id, channel_content_id
+        from produce_plan_exe_record
+        where channel_content_id in
+        <foreach collection="list" item="item" open="(" close=")" separator=",">
+            #{item}
+        </foreach>
+    </select>
+
 </mapper>

long-article-recommend-service/src/main/resources/mapper/longArticle/LongArticleBaseMapper.xml

@@ -555,4 +555,59 @@
         </if>
     </select>
 
+    <select id="getDemandSearchArticleRelations"
+            resultType="com.tzld.longarticle.recommend.server.model.dto.DemandSearchArticleRelationDTO">
+        select experiment_id   as experimentId,
+               channel_content_id as channelContentId
+        from demand_search_article_relation
+        where status = 2
+          and channel_content_id is not null
+    </select>
+
+    <insert id="batchInsertIgnoreDemandProduceContentRelation">
+        insert ignore into demand_produce_content_relation (content_id, channel_content_id, experiment_id, account_id)
+        values
+        <foreach collection="list" item="item" separator=",">
+            (#{item.contentId}, #{item.channelContentId}, #{item.experimentId}, #{item.accountId})
+        </foreach>
+    </insert>
+
+    <select id="getDemandExperimentIdByChannelContentIds"
+            resultType="com.tzld.longarticle.recommend.server.model.dto.DemandSearchArticleRelationDTO">
+        select channel_content_id as channelContentId,
+               experiment_id     as experimentId
+        from demand_search_article_relation
+        where status = 2
+          and channel_content_id in
+        <foreach collection="list" item="item" open="(" close=")" separator=",">
+            #{item}
+        </foreach>
+    </select>
+
+    <select id="getDemandPoolPromotionByLevel"
+            resultType="com.tzld.longarticle.recommend.server.model.dto.DemandSearchArticleRelationDTO">
+        select channel_content_id      as channelContentId,
+               root_produce_content_id as contentId,
+               account_id              as accountId
+        from demand_pool_promotion_source
+        where level = #{level}
+          and status = #{status}
+          and deleted = #{deleted}
+    </select>
+
+    <select id="getDemandExperimentIdByContentIds"
+            resultType="com.tzld.longarticle.recommend.server.model.dto.DemandSearchArticleRelationDTO">
+        select content_id       as contentId,
+               experiment_id    as experimentId
+        from demand_produce_content_relation
+        where content_id in
+        <foreach collection="contentIds" item="item" open="(" close=")" separator=",">
+            #{item}
+        </foreach>
+        <if test="accountId != null and accountId != ''">
+          and (account_id = #{accountId} or account_id is null)
+        </if>
+    </select>
+
+
 </mapper>