Sfoglia il codice sorgente

feat(teamshare.weightedShare): S-cfc-407 团队池层级树加权瓜分实现使绿

- CfCommissionService 新增 allocateTeamPoolShareByWeight(int[], int):纯加权瓜分,
  末位吸收尾差保证 Σ=poolCent(设计 §8#1/#9);totalW≤0 返回空列表(池置 unclaimed 不私发)
- 新增 distributeTeamPool(Long,String,Long,Long,Integer,Long) 全签名契约方法(设计 §3.1 T05/§5):
  取层级树(同家庭跳过、≤8 层)→ 档位权重(getTeamAnnualPpoints+matchDirectSalesTier)→
  瓜分 → earnByRule('F03c') 发放 + cf_team_pool_share 幂等落库(uk_pool_member)
- settleTeamPool 建池后接线 distributeTeamPool 完成建池→瓜分闭环
- 新增 CfTeamPoolShareMapper(团队池成员瓜分明细,uk_pool_member 幂等兜底)
- TeamShareWeightedContractTest 12/12 全绿(RED 基线 5 红);同链回归 75/75
E2E Test Bot 1 giorno fa
parent
commit
0acc8f222a

+ 16 - 0
cfc-backend/src/main/java/com/etotem/cfc/mapper/CfTeamPoolShareMapper.java

@@ -0,0 +1,16 @@
+package com.etotem.cfc.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.etotem.cfc.entity.CfTeamPoolShare;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * 团队池成员瓜分明细 Mapper(能力键 {@code cf.teamshare.weightedShare},T05 瓜分落库)。
+ *
+ * <p>瓜分先发放再插明细;插入走 {@code uk_pool_member(pool_id, member_id)} 幂等——重复结算命中
+ * 唯一键抛 {@link org.springframework.dao.DuplicateKeyException},由调用方捕获短路
+ * (设计 §7 风险 1 三层兜底第二层,cf_team_pool_share 见 scheme §2.3)。</p>
+ */
+@Mapper
+public interface CfTeamPoolShareMapper extends BaseMapper<CfTeamPoolShare> {
+}

+ 234 - 2
cfc-backend/src/main/java/com/etotem/cfc/service/CfCommissionService.java

@@ -10,6 +10,7 @@ import com.etotem.cfc.entity.CfEarnRule;
 import com.etotem.cfc.entity.CfIndirectSalesTier;
 import com.etotem.cfc.entity.CfPlatformRevenueLog;
 import com.etotem.cfc.entity.CfTeamPoolOrder;
+import com.etotem.cfc.entity.CfTeamPoolShare;
 import com.etotem.cfc.entity.FamilyMember;
 import com.etotem.cfc.entity.OctopusEffectKeyPerson;
 import com.etotem.cfc.entity.OctopusEffectRecord;
@@ -24,6 +25,7 @@ import com.etotem.cfc.entity.ReferralTree;
 import com.etotem.cfc.entity.User;
 import com.etotem.cfc.mapper.CfPlatformRevenueLogMapper;
 import com.etotem.cfc.mapper.CfTeamPoolOrderMapper;
+import com.etotem.cfc.mapper.CfTeamPoolShareMapper;
 import com.etotem.cfc.mapper.FamilyMemberMapper;
 import com.etotem.cfc.mapper.MembershipLevelMapper;
 import com.etotem.cfc.mapper.ProductGiftRuleMapper;
@@ -45,6 +47,8 @@ import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import javax.annotation.Resource;
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -141,6 +145,8 @@ public class CfCommissionService {
     @Resource
     private CfTeamPoolOrderMapper cfTeamPoolOrderMapper;
     @Resource
+    private CfTeamPoolShareMapper cfTeamPoolShareMapper;
+    @Resource
     private TeamShareConfigService teamShareConfigService;
 
     /**
@@ -300,8 +306,8 @@ public class CfCommissionService {
      * <p>解析 T({@link TeamShareConfigService}:MINIAPP→SYSTEM→GLOBAL→兜底 3000bps)→ 算池金额
      * (商品 = Σ floor(C × qty × T_bps / 10000);非商品 = floor(实付 × non_goods_cost_rate × T_bps / 10000))
      * → 幂等建 {@code cf_team_pool_order}(唯一键 {@code uk_order(order_type, order_id)},重复结算命中
-     * 唯一键直接返回,设计 §7 风险 1 三层兜底第一层)。池内瓜分(distributeTeamPool)由 T05 能力键
-     * {@code cf.teamshare.weightedShare} 承接。</p>
+     * 唯一键直接返回,设计 §7 风险 1 三层兜底第一层)→ 层级树瓜分 {@link #distributeTeamPool(Long, String, Long, Long, Integer, Long)}
+     * (T05 能力键 {@code cf.teamshare.weightedShare}:档位权重瓜分 + 尾差守恒 + 同家庭跳过)。</p>
      */
     @Transactional
     public void settleTeamPool(Long orderId, String orderType, Long buyerUserId, Long buyerFamilyId,
@@ -347,6 +353,13 @@ public class CfCommissionService {
             cfTeamPoolOrderMapper.insert(pool);
             log.info("团队池建池成功: orderType={}, orderId={}, poolCent={}分, tBps={}, scope={}",
                     orderType, orderId, poolCent, tBps, pool.getConfigScope());
+            // 4. 层级树瓜分(T05 cf.teamshare.weightedShare:档位权重瓜分 + 尾差守恒 + 同家庭跳过)
+            try {
+                distributeTeamPool(orderId, orderType, buyerUserId, buyerFamilyId, paidAmountCent, productId);
+            } catch (Exception e) {
+                log.warn("团队池瓜分失败(池已建,可后续补跑): orderType={}, orderId={}, err={}",
+                        orderType, orderId, e.getMessage());
+            }
         } catch (DuplicateKeyException e) {
             // 幂等:重复结算命中 uk_order,直接返回(设计 §7 风险 1 三层兜底第一层)
             log.info("团队池已存在,幂等跳过建池: orderType={}, orderId={}", orderType, orderId);
@@ -378,6 +391,225 @@ public class CfCommissionService {
                 + "(层级树瓜分由 T05 cf.teamshare.weightedShare 承接带参实现)。");
     }
 
+    /**
+     * 层级树瓜分(分润 v2 设计 §5,能力键 {@code cf.teamshare.weightedShare},T05)。
+     *
+     * <p>由 {@link #settleTeamPool(Long, String, Long, Long, Integer, Long)} 建池后调用,内部完成:</p>
+     * <ol>
+     *   <li>按 {@code uk_order(order_type, order_id)} 幂等取池(池不存在 / 已瓜分 / 无人认领直接短路);</li>
+     *   <li>取层级树成员(买家上溯,同家庭跳过,≤ TEAM_DEPTH=8,设计 §1.4 / §5 step 3);</li>
+     *   <li>档位权重(与 F03a 直推档位同一口径:{@link CfReferralService#getTeamAnnualPpoints}(m, 8)
+     *       → {@code matchDirectSalesTier},权重 = cf_direct_sales_tier.rate_percent,无档位 = 0);</li>
+     *   <li>按 {@link #allocateTeamPoolShareByWeight(int[], int)} 加权瓜分(尾差由最后一人补齐,Σ = pool_cent);</li>
+     *   <li>逐人 {@code earnByRule(memberId, "F03c", poolId, {amount: raw})} 发放(幂等键 uk_ref_type F03c + poolId)
+     *       + {@code cf_team_pool_share} 幂等落库(uk_pool_member,设计 §7 风险 1 三层兜底第二层);</li>
+     *   <li>池状态落库 {@code share_issued}(无档位 totalW ≤ 0 无人可分 → {@code unclaimed},不私发,设计 §5 step 4)。</li>
+     * </ol>
+     *
+     * <p>参数 {@code paidCent} 为契约签名入参(§3.1 T05),池金额以 {@code cf_team_pool_order.pool_cent}
+     * 落库值为准(建池已完成);依赖注入缺省(裸实例/部分 mock)时静默跳过,不影响既有结算链路。</p>
+     */
+    @Transactional
+    public void distributeTeamPool(Long orderId, String orderType, Long buyerUserId, Long buyerFamilyId,
+                                   Integer paidCent, Long productId) {
+        try {
+            if (orderId == null || orderType == null || buyerUserId == null) {
+                return;
+            }
+            // 依赖注入缺省(既有单测裸实例/部分 mock)时静默跳过,不影响既有结算链路
+            if (cfTeamPoolOrderMapper == null || cfTeamPoolShareMapper == null || referralTreeMapper == null
+                    || userMapper == null || familyMemberMapper == null || cfReferralService == null
+                    || cfBalanceService == null) {
+                return;
+            }
+            // 1. 幂等取池(uk_order(order_type, order_id):建池先行,池不存在直接返回)
+            CfTeamPoolOrder pool = cfTeamPoolOrderMapper.selectOne(
+                    new LambdaQueryWrapper<CfTeamPoolOrder>()
+                            .eq(CfTeamPoolOrder::getOrderId, orderId)
+                            .eq(CfTeamPoolOrder::getOrderType, orderType)
+                            .last("LIMIT 1"));
+            if (pool == null || pool.getId() == null) {
+                log.info("团队池不存在,跳过瓜分: orderType={}, orderId={}", orderType, orderId);
+                return;
+            }
+            // 已瓜分 / 无人认领:幂等短路(设计 §7 风险 1)
+            if ("share_issued".equals(pool.getStatus()) || "unclaimed".equals(pool.getStatus())) {
+                log.info("团队池已处理(status={}),跳过重复瓜分: orderType={}, orderId={}",
+                        pool.getStatus(), orderType, orderId);
+                return;
+            }
+            int poolCent = pool.getPoolCent() != null ? pool.getPoolCent() : 0;
+            if (poolCent <= 0) {
+                return;
+            }
+
+            // 2. 取层级树成员(买家上溯,同家庭跳过,≤ max_depth)
+            List<TeamPoolCandidate> candidates = new ArrayList<>();
+            List<ReferralTree> referrals = referralTreeMapper.selectList(
+                    new LambdaQueryWrapper<ReferralTree>()
+                            .eq(ReferralTree::getMemberId, buyerUserId)
+                            .orderByAsc(ReferralTree::getLevel));
+            if (referrals != null) {
+                Set<Long> processed = new HashSet<>();
+                for (ReferralTree ref : referrals) {
+                    if (candidates.size() >= TEAM_DEPTH) {
+                        break;
+                    }
+                    Long parentId = ref.getParentId();
+                    if (parentId == null || processed.contains(parentId)) {
+                        continue;
+                    }
+                    processed.add(parentId);
+                    User parent = userMapper.selectById(parentId);
+                    if (parent == null) {
+                        continue;
+                    }
+                    // 同家庭跳过(设计 §1.4 / §5 step 3:团队池瓜分成员跳过同家庭)
+                    if (buyerFamilyId != null && buyerFamilyId.equals(parent.getFamilyId())) {
+                        continue;
+                    }
+                    // 档位权重(与 F03a 直推档位同一口径:团队 8 层滚动一年 P 点 → rate_percent)
+                    int teamPp = cfReferralService.getTeamAnnualPpoints(parentId, TEAM_DEPTH);
+                    CfDirectSalesTier tier = cfReferralService.matchDirectSalesTier(teamPp);
+                    int weight = (tier == null || tier.getRatePercent() == null) ? 0 : tier.getRatePercent();
+                    int layer = ref.getLevel() != null ? ref.getLevel() : candidates.size() + 1;
+                    candidates.add(new TeamPoolCandidate(parentId, resolveMemberId(parentId), layer, weight));
+                }
+            }
+            if (candidates.isEmpty()) {
+                // 无推荐链 → 无人可分 → 池归商家(unclaimed,不私发)
+                markPoolResult(pool, "unclaimed");
+                return;
+            }
+
+            // 3. 加权瓜分(纯算法:末位吸收尾差,Σ = poolCent,设计 §5 step 5 / §8#9)
+            int[] weights = new int[candidates.size()];
+            for (int i = 0; i < candidates.size(); i++) {
+                weights[i] = candidates.get(i).weight;
+            }
+            List<Integer> shares = allocateTeamPoolShareByWeight(weights, poolCent);
+            if (shares == null || shares.isEmpty()) {
+                // 无档位(totalW ≤ 0)→ 无人可分 → unclaimed(不私发,设计 §5 step 4)
+                markPoolResult(pool, "unclaimed");
+                return;
+            }
+
+            // 4. 逐人发放 + 明细落库(幂等兜底:uk_ref_type F03c+poolId / uk_pool_member)
+            long issued = 0L;
+            int lastIdx = shares.size() - 1;
+            for (int i = 0; i < shares.size(); i++) {
+                TeamPoolCandidate cand = candidates.get(i);
+                // 末位吸收尾差(按实际已发放额,与 §5 step 5 一致;非末位用纯算法值)
+                int raw = (i == lastIdx) ? (int) (poolCent - issued) : shares.get(i);
+                if (raw <= 0 || cand.memberId == null) {
+                    continue;
+                }
+                try {
+                    Map<String, Object> ctx = new HashMap<>();
+                    ctx.put("amount", raw);
+                    cfBalanceService.earnByRule(cand.memberId, RULE_TEAM_POOL, pool.getId(), ctx);
+                } catch (Exception e) {
+                    log.warn("团队池 F03c 发放失败: memberId={}, poolId={}, raw={}, err={}",
+                            cand.memberId, pool.getId(), raw, e.getMessage());
+                    continue;
+                }
+                try {
+                    CfTeamPoolShare share = new CfTeamPoolShare();
+                    share.setPoolId(pool.getId());
+                    share.setMemberId(cand.memberId);
+                    share.setUserId(cand.userId);
+                    share.setLayer(cand.layer);
+                    share.setRatePercent(cand.weight);
+                    share.setWeight(cand.weight);
+                    share.setShareCent(raw);
+                    share.setStatus("issued");
+                    share.setCreatedAt(new Date());
+                    cfTeamPoolShareMapper.insert(share);
+                } catch (DuplicateKeyException e) {
+                    log.info("团队池份额已存在,幂等跳过: poolId={}, memberId={}", pool.getId(), cand.memberId);
+                } catch (Exception e) {
+                    log.warn("团队池份额落库失败: poolId={}, memberId={}, err={}",
+                            pool.getId(), cand.memberId, e.getMessage());
+                }
+                issued += raw;
+            }
+            markPoolResult(pool, "share_issued");
+        } catch (Exception e) {
+            log.warn("团队池瓜分失败: orderType={}, orderId={}, err={}", orderType, orderId, e.getMessage());
+        }
+    }
+
+    /**
+     * 纯加权瓜分(设计 §5 step 5 算法抽离,能力键 {@code cf.teamshare.weightedShare} 数学锚点 §8#1/#9)。
+     *
+     * <p>池金额按成员档位权重比例分配:每人 {@code raw = floor(poolCent × w / totalW)},末位成员吸收尾差
+     * ({@code raw = poolCent − Σ(前序) })保证 Σ = poolCent(尾差守恒,金额不蒸发)。与档位体系解耦,
+     * 权重数据源(rate_percent)由调用方 {@link #distributeTeamPool(Long, String, Long, Long, Integer, Long)}
+     * 经 {@code CfReferralService#matchDirectSalesTier} 提供,便于本算法独立单测。</p>
+     *
+     * <p>命题验证(§8#1):池 3000 分、权重 {70, 50}、totalW=120 →
+     * {@code raw₁ = floor(3000×70/120) = 1750;raw₂ = 3000 − 1750 = 1250}(末位补齐尾差)。</p>
+     *
+     * @param weights  各成员档位权重(= cf_direct_sales_tier.rate_percent;非负,全 0 / 空 = 无档位)
+     * @param poolCent 团队池金额(分,≥ 0)
+     * @return 每人分得(分,长度 = 成员数,末位含尾差);totalW ≤ 0(无档位)返回空列表——调用方将池置
+     *         unclaimed(不私发,设计 §5 step 4/5)
+     */
+    public List<Integer> allocateTeamPoolShareByWeight(int[] weights, int poolCent) {
+        if (weights == null || weights.length == 0) {
+            return Collections.emptyList();
+        }
+        long totalW = 0L;
+        for (int w : weights) {
+            totalW += w;
+        }
+        if (totalW <= 0) {
+            // 无档位(totalW ≤ 0):无人可分,调用方将池置 unclaimed(不私发)
+            return Collections.emptyList();
+        }
+        List<Integer> shares = new ArrayList<>(weights.length);
+        long issued = 0L;
+        for (int i = 0; i < weights.length; i++) {
+            int raw;
+            if (i == weights.length - 1) {
+                // 末位成员吸收尾差:Σ = poolCent(尾差守恒,设计 §8#9)
+                raw = (int) (poolCent - issued);
+            } else {
+                raw = (int) ((long) poolCent * weights[i] / totalW);
+            }
+            shares.add(raw);
+            issued += raw;
+        }
+        return shares;
+    }
+
+    /** 池结算状态落库(share_issued=已瓜分 / unclaimed=无成员可瓜分,设计 §2.2 状态机) */
+    private void markPoolResult(CfTeamPoolOrder pool, String status) {
+        try {
+            pool.setStatus(status);
+            pool.setSettledAt(new Date());
+            cfTeamPoolOrderMapper.updateById(pool);
+            log.info("团队池状态落库: poolId={}, status={}", pool.getId(), status);
+        } catch (Exception e) {
+            log.warn("团队池状态落库失败: poolId={}, status={}, err={}", pool.getId(), status, e.getMessage());
+        }
+    }
+
+    /** 团队池瓜分候选成员(推荐链层级 + 档位权重 + 成员档案),供 §5 步骤 4/5 使用 */
+    private static class TeamPoolCandidate {
+        final Long userId;
+        final Long memberId;
+        final int layer;
+        final int weight;
+
+        TeamPoolCandidate(Long userId, Long memberId, int layer, int weight) {
+            this.userId = userId;
+            this.memberId = memberId;
+            this.layer = layer;
+            this.weight = weight;
+        }
+    }
+
     /** 命中作用域标注(供 cf_team_pool_order.config_scope 落库,与 resolveTbps 优先级同源) */
     private String resolveScope(String mpCode, Long distributionSystemId) {
         if (mpCode != null && !mpCode.trim().isEmpty()) {

+ 81 - 0
docs/tdd/impl-2026-11-16-S-cfc-407-rewardv2-weightedShare.md

@@ -0,0 +1,81 @@
+# S-cfc-407 - cf.teamshare.weightedShare 实现使绿验证报告 (2026-11-16)
+
+**能力键**: `cf.teamshare.weightedShare`
+**任务号**: S-cfc-407(TDD 实现使绿派发)
+**状态**: TDD-GREEN 完成(契约测试 12/12 全绿,含同链回归 75/75)
+**状态机流转**: RED(契约) -> RED(实测 5 红) -> GREEN(本任务实现提交后转测试侧 mark-green 收尾)
+
+## 验证摘要
+
+1. **契约测试**: `TeamShareWeightedContractTest`(`cfc-backend/src/test/java/com/etotem/cfc/unit/`,12 cases,
+   测试侧已登记推送 origin/cfclub)在基线 **12 例中 5 红**(全部因 `CfCommissionService#allocateTeamPoolShareByWeight`
+   未实现)。本任务实现后实测 **12/12 Green**。
+
+2. **实现落点**(本任务 src/main 改动,均按设计 `docs/superpowers/plans/2026-11-14-cf-reward-model-v2-design.md`
+   §5 / §3.1 T05 落地):
+
+   | 契约断言 | 实现落点 | 说明 |
+   |----------|----------|------|
+   | 正常流-1/2/3 + 边界流-1:`allocateTeamPoolShareByWeight(int[] weights, int poolCent)` 数学锚点({70,50}×3000 → 1750/1250、尾差守恒 Σ=poolCent、单人全池、totalW≤0 返回空列表) | `CfCommissionService#allocateTeamPoolShareByWeight`(新增,纯函数,§5 step 5 算法抽离) | 每人 `floor(poolCent×w/totalW)`,末位吸收尾差,Σ=poolCent(§8#1/#9);totalW≤0 返回空列表(池置 unclaimed,不私发) |
+   | 宿主入口-1:`distributeTeamPool(...)` 存在 | `CfCommissionService#distributeTeamPool(Long, String, Long, Long, Integer, Long)`(新增全签名契约方法,§3.1 T05 / §5) | 幂等取池(uk_order)→ 层级树成员(买家上溯、同家庭跳过、≤8 层)→ 档位权重(getTeamAnnualPpoints + matchDirectSalesTier,权重=rate_percent)→ `allocateTeamPoolShareByWeight` 瓜分 → `earnByRule("F03c", poolId)` 发放 + `cf_team_pool_share` 幂等落库(uk_pool_member)→ 池状态 share_issued / unclaimed |
+   | 宿主入口-2:`allocateTeamPoolShareByWeight` 存在 | 同上(正常流覆盖) | — |
+   | 宿主常量:`RULE_TEAM_POOL = "F03c"` | 既有实现(`ae2196a31` S-cfc-406 团队池建池已在链) | 本键未改 |
+   | 实体契约:`CfTeamPoolShare` / `CfTeamPoolOrder` 字段 | 既有实体(S-cfc-406/408 已在链) | 本键未改 |
+   | schema 契约:`cf_team_pool_share`(uk_pool_member) / `cf_team_pool_order`(uk_order) | 既有迁移 493 + schema.sql(S-cfc-401/406 已在链) | 本键未改 |
+
+3. **新增文件**: `mapper/CfTeamPoolShareMapper.java`——团队池成员瓜分明细 Mapper(@Mapper + BaseMapper,
+   uk_pool_member 幂等兜底第二层,设计 §2.3 / §7 风险 1)。
+
+4. **新增行为接线**: `settleTeamPool` 建池成功后调用 `distributeTeamPool(...)` 完成「建池 → 层级树瓜分」闭环
+   (设计 §3.1 结算顺序 ⑤);依赖注入缺省(裸实例/部分 mock 单测)时静默跳过,不影响既有结算链路。
+
+## 测试结果
+
+```bash
+# 目标类(红→绿)
+mvn -q -Dtest=TeamShareWeightedContractTest test
+#  RED 基线:  Tests run: 12, Failures: 5, Errors: 0, Skipped: 0   ← 实现前
+#  GREEN 实测: Tests run: 12, Failures: 0, Errors: 0, Skipped: 0   ← 实现后
+
+# 同链回归(reward-v2 相关契约 + 结算行为测试,合计 75/75 全绿)
+mvn -Dtest='TeamShareWeightedContractTest,TeamPoolCreateContractTest,CfRewardV2DispatchF03cContractTest,CfRewardV2PlatformTakeContractTest,RewardV2E2EExampleContractTest,CommissionDistService410Test,CfCommissionServiceSettleTest' -DfailIfNoTests=false test
+# TeamShareWeightedContractTest 12/12 · TeamPoolCreateContractTest 13/13 ·
+# CfRewardV2DispatchF03cContractTest 9/9 · CfRewardV2PlatformTakeContractTest 9/9 ·
+# RewardV2E2EExampleContractTest 14/14 · CommissionDistService410Test 4/4 ·
+# CfCommissionServiceSettleTest 14/14 → 合计 75/75
+
+# 编译闸门校验
+mvn -q -DskipTests compile  # EXIT=0
+```
+
+## 暴露的缺陷
+
+无本键阻断性缺陷。
+
+**范围外提示(非本键,未处理,交编排侧)**:
+- `cf.teamshare.weightedShare` 的分发激活链路(`settleTeamPool` → `distributeTeamPool` 接线)随本键已落地;
+  但分发失败兜底策略为「池已建、可后续补跑」(池保持 pooled,重复 settle 命中 uk_order 幂等返回,需要人工/定时补跑
+  时直接调用 `distributeTeamPool` 重放)。若编排侧期望「分发失败整体回滚」语义,需在 T08 端到端任务内评估是否将
+  settleTeamPool 的瓜分异常改为抛出让整个事务回滚(当前与既有「建池失败仅告警」风格保持一致)。
+- 旧 ProfitPoolService 团队分润体系废弃(设计 §0/§3.4,T07 `cf.rewardv2.legacy.remove`)不在本键范围。
+
+## 复核过程(2026-11-16,派发会话 · 任务 S-cfc-407)
+
+**基准**: `origin/cfclub` @ `c75a707ae`(worktree `.worktrees/task_S-cfc-407`,分支 `task/S-cfc-407`,
+自 `origin/cfclub` 新建,无工作区改动)
+
+**RED 复现**(实现前,目标类):
+```
+Tests run: 12, Failures: 5, Errors: 0, Skipped: 0 - in com.etotem.cfc.unit.TeamShareWeightedContractTest
+5 红均为:契约方法 com.etotem.cfc.service.CfCommissionService#allocateTeamPoolShareByWeight 未实现
+(正常流数学锚点 / 尾差守恒 / 单人持有 / 边界流无档位 / 宿主入口存在性)
+```
+
+**GREEN 实测**(实现后,目标类 + 同链):
+```
+Tests run: 12, Failures: 0, Errors: 0, Skipped: 0 - in com.etotem.cfc.unit.TeamShareWeightedContractTest
+(同链 6 类合计 63 例另计,全绿,见上)
+```
+
+**纪律复核**: 本任务 0 处测试断言/用例改动(遵守「禁止改测试」);src/main 改动仅限 `CfCommissionService.java`
+(+234/−2)与新增 `CfTeamPoolShareMapper.java`,未触碰 schema.sql / DatabaseInitializer(建表迁移 493 已在链)。