🔀 合并运单归属改造（司机档案 ID）到 dev

blade-service-api/blade-transport-api/src/main/java/org/springblade/transport/pojo/entity/LoadingManage.java

@@ -68,6 +68,9 @@ public class LoadingManage extends TenantEntity {
 	@Schema(description = "联系电话")
 	private String driverPhone;
 
+	@Schema(description = "司机ID")
+	private Long driverId;
+
 	@Schema(description = "押运人")
 	private String escortName;
 

blade-service-api/blade-transport-api/src/main/java/org/springblade/transport/pojo/vo/TripQueryVO.java

@@ -34,8 +34,10 @@ import java.util.Set;
 /**
  * 运次查询条件
  * <p>
- * 司机端用 {@link #forDriver(String)} 按司机手机号收口；管理端用 {@link #forAdmin()} 不按司机收口。
- * 两者都不给时收口为空集——收口一旦缺省就等于把别人的运次发出去，故缺省不放行。
+ * 司机端用 {@link #forDriver(Long)} 按司机档案 ID 收口；管理端用 {@link #forAdmin()} 不按司机收口。
+ * 两者都不给时收口为空集。
+ * <p>
+ * 归属判据只有司机档案 ID；driver_phone 是派单时的号码快照，不参与判定。
  */
 @Data
 @Schema(description = "运次查询条件")
@@ -47,8 +49,8 @@ public class TripQueryVO implements Serializable {
 	@Schema(description = "运次主键（详情按它取单个运次）")
 	private String tripId;
 
-	@Schema(description = "司机手机号")
-	private String driverPhone;
+	@Schema(description = "司机档案 ID（司机端收口判据，空或非正数一律不放行）")
+	private Long driverId;
 
 	@Schema(description = "是否不按司机收口（管理端）")
 	private boolean allDrivers;
@@ -92,9 +94,9 @@ public class TripQueryVO implements Serializable {
 	@Schema(description = "每页条数（按运次，不是运单）")
 	private Integer size;
 
-	public static TripQueryVO forDriver(String driverPhone) {
+	public static TripQueryVO forDriver(Long driverId) {
 		TripQueryVO query = new TripQueryVO();
-		query.setDriverPhone(driverPhone);
+		query.setDriverId(driverId);
 		return query;
 	}
 

blade-service/blade-transport/src/main/java/org/springblade/transport/controller/DriverAppController.java

@@ -54,9 +54,10 @@ public class DriverAppController extends BladeController {
 
 	@GetMapping("/mine")
 	@ApiOperationSupport(order = 1)
-	@Operation(summary = "当前登录司机档案", description = "按手机号匹配 blade_transport_driver.mobile；可传 mobile，未传则从登录态解析")
+	@Operation(summary = "当前登录司机档案", description = "按登录用户的 user_id 匹配 blade_transport_driver.user_id")
+	// mobile：旧版小程序仍会带这个参数，已不参与解析，保留只为不让老客户端报错
 	public R<DriverVO> mine(@RequestParam(required = false) String mobile) {
-		return R.data(driverAppService.currentByPhone(mobile));
+		return R.data(driverAppService.current());
 	}
 
 	@GetMapping("/vehicles")

blade-service/blade-transport/src/main/java/org/springblade/transport/controller/DriverWaybillController.java

@@ -65,14 +65,14 @@ public class DriverWaybillController extends BladeController {
 
 	@GetMapping("/current-task")
 	@ApiOperationSupport(order = 1)
-	@Operation(summary = "首页：当前运输中任务", description = "当前用户手机号匹配运单 driverPhone 且 businessStatus=running 的最新一条运单")
+	@Operation(summary = "首页：当前运输中任务", description = "当前司机档案（按登录用户解析）名下、businessStatus=running 的最新一条运单；归属判据是运单 driver_id")
 	public R<DriverWaybillCardVO> currentTask() {
 		return R.data(driverWaybillService.currentTask());
 	}
 
 	@GetMapping("/pending-preview")
 	@ApiOperationSupport(order = 2)
-	@Operation(summary = "首页：待接运单预览", description = "当前用户手机号匹配运单 driverPhone 且 businessStatus=pending 的预览列表与总数")
+	@Operation(summary = "首页：待接运单预览", description = "当前司机档案名下、businessStatus=pending 的预览列表与总数；归属判据是运单 driver_id")
 	public R<DriverWaybillPreviewVO> pendingPreview(
 		@Parameter(description = "预览条数，默认 2") @RequestParam(required = false) Integer size) {
 		return R.data(driverWaybillService.pendingPreview(size));
@@ -80,14 +80,14 @@ public class DriverWaybillController extends BladeController {
 
 	@GetMapping("/counts")
 	@ApiOperationSupport(order = 3)
-	@Operation(summary = "运单 Tab 统计", description = "仅统计当前用户手机号匹配运单 driverPhone 的运单：全部 / 待接单 / 进行中 / 已完成")
+	@Operation(summary = "运单 Tab 统计", description = "仅统计当前司机档案名下（运单 driver_id）的运单：全部 / 待接单 / 进行中 / 已完成")
 	public R<DriverWaybillTabCountsVO> counts() {
 		return R.data(driverWaybillService.tabCounts());
 	}
 
 	@GetMapping("/page")
 	@ApiOperationSupport(order = 4)
-	@Operation(summary = "运单分页列表", description = "仅返回运单 driverPhone 等于当前用户手机号的数据；status：空=全部，0待接单，1运输中，2已完成")
+	@Operation(summary = "运单分页列表", description = "仅返回运单 driver_id 等于当前司机档案的数据；status：空=全部，0待接单，1运输中，2已完成")
 	public R<IPage<DriverWaybillCardVO>> page(
 		@Parameter(description = "当前页") @RequestParam(required = false) Integer current,
 		@Parameter(description = "每页条数") @RequestParam(required = false) Integer size,
@@ -107,14 +107,14 @@ public class DriverWaybillController extends BladeController {
 
 	@GetMapping("/task/current")
 	@ApiOperationSupport(order = 21)
-	@Operation(summary = "首页：当前运输中运次", description = "当前用户手机号可见的运输中或待确认（待回单确认）运次（有配载单的一趟车算一个）最新一条")
+	@Operation(summary = "首页：当前运输中运次", description = "当前司机档案可见的运输中或待确认（待回单确认）运次（有配载单的一趟车算一个）最新一条；配载段按配载单 driver_id，未配载段按运单 driver_id")
 	public R<DriverWaybillCardVO> tripCurrentTask() {
 		return R.data(driverWaybillService.tripCurrentTask());
 	}
 
 	@GetMapping("/task/pending-preview")
 	@ApiOperationSupport(order = 22)
-	@Operation(summary = "首页：待接运次预览", description = "当前用户手机号可见的待接运次预览与总数（按运次计）")
+	@Operation(summary = "首页：待接运次预览", description = "当前司机档案可见的待接运次预览与总数（按运次计）")
 	public R<DriverWaybillPreviewVO> tripPendingPreview(
 		@Parameter(description = "预览条数，默认 2") @RequestParam(required = false) Integer size) {
 		return R.data(driverWaybillService.tripPendingPreview(size));
@@ -166,7 +166,7 @@ public class DriverWaybillController extends BladeController {
 
 	@PostMapping("/track")
 	@ApiOperationSupport(order = 11)
-	@Operation(summary = "司机端行驶轨迹", description = "按当前用户手机号校验归属后，根据打卡记录/计划时间自动推导起止日期并查询 LBS 轨迹（WGS-84）")
+	@Operation(summary = "司机端行驶轨迹", description = "按当前司机档案校验归属后，根据打卡记录/计划时间自动推导起止日期并查询 LBS 轨迹（WGS-84）")
 	public R<WaybillTrackVO> track(@Parameter(description = "运单ID", required = true) @RequestParam Long id) {
 		return R.data(driverWaybillService.track(id));
 	}

blade-service/blade-transport/src/main/java/org/springblade/transport/service/IDriverAppService.java

@@ -34,11 +34,11 @@ import java.util.List;
 public interface IDriverAppService {
 
 	/**
-	 * 当前登录用户对应的司机档案（按手机号匹配 blade_transport_driver.mobile）
+	 * 当前登录用户对应的司机档案（按 user_id 匹配 blade_transport_driver.user_id）
 	 *
-	 * @param mobile 小程序可显式传入当前用户手机号；为空时从登录态解析
+	 * @return 司机档案；未登录抛异常，查不到返回 null
 	 */
-	DriverVO currentByPhone(String mobile);
+	DriverVO current();
 
 	/**
 	 * 当前司机绑定的车辆列表（driver.driving_vehicle ↔ vehicle.plate_no）
@@ -49,10 +49,9 @@ public interface IDriverAppService {
 	 * 当前登录用户对应的司机**实体**
 	 * <p>
 	 * 认证提交要写回司机表，且越权校验要读 {@code driving_vehicle}，
-	 * 故这里返回实体而非视图对象。解析顺序：先按登录手机号匹配，
-	 * 匹配不到再按 {@code user_id} 兜底。
+	 * 故这里返回实体而非视图对象。解析口径与 {@link #current()} 一致。
 	 *
-	 * @return 司机实体；未登录或查不到时返回 null
+	 * @return 司机实体；未登录抛异常，查不到返回 null
 	 */
 	Driver currentDriverEntity();
 

blade-service/blade-transport/src/main/java/org/springblade/transport/service/IDriverService.java

@@ -111,4 +111,16 @@ public interface IDriverService extends BaseService<Driver> {
 	 */
 	List<DriverExcel> exportDriver(Wrapper<Driver> queryWrapper);
 
+	/**
+	 * 按手机号解析司机档案 ID
+	 * <p>
+	 * 归属主键是档案 ID，手机号只是派单时的号码快照：只有租户内唯一命中才认，
+	 * 0 条（承运商司机、未登录过小程序的司机）与多条（历史脏数据）都返回 null，不抛异常。
+	 *
+	 * @param tenantId 租户ID，为空时取当前登录租户
+	 * @param mobile   手机号
+	 * @return 司机档案ID；无法唯一确定时为 null
+	 */
+	Long resolveDriverIdByMobile(String tenantId, String mobile);
+
 }

blade-service/blade-transport/src/main/java/org/springblade/transport/service/ITripQueryService.java

@@ -41,7 +41,7 @@ public interface ITripQueryService {
 	 * <p>
 	 * 库层只取回收口与行级筛选命中的运单行，分组、分档、筛选、排序与分页都在服务层算完再做。
 	 *
-	 * @param query 查询条件，收口由 driverPhone 或 allDrivers 给出
+	 * @param query 查询条件，收口由 driverId（司机档案）或 allDrivers 给出
 	 * @return 运次分页
 	 */
 	IPage<TripVO> page(TripQueryVO query);

blade-service/blade-transport/src/main/java/org/springblade/transport/service/impl/DriverAppServiceImpl.java

@@ -27,10 +27,7 @@ import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import lombok.RequiredArgsConstructor;
 import org.springblade.core.log.exception.ServiceException;
 import org.springblade.core.secure.utils.AuthUtil;
-import org.springblade.core.tool.api.R;
 import org.springblade.core.tool.utils.Func;
-import org.springblade.system.feign.IMpUserClient;
-import org.springblade.system.pojo.entity.MpUser;
 import org.springblade.transport.pojo.entity.Driver;
 import org.springblade.transport.pojo.entity.TransportVehicle;
 import org.springblade.transport.pojo.vo.DriverVehicleCardVO;
@@ -57,17 +54,16 @@ public class DriverAppServiceImpl implements IDriverAppService {
 
 	private final IDriverService driverService;
 	private final ITransportVehicleService transportVehicleService;
-	private final IMpUserClient mpUserClient;
 
 	@Override
-	public DriverVO currentByPhone(String mobile) {
-		Driver driver = currentDriver(mobile);
+	public DriverVO current() {
+		Driver driver = currentDriver();
 		return driver == null ? null : DriverWrapper.build().entityVO(driver);
 	}
 
 	@Override
 	public List<DriverVehicleCardVO> myVehicles() {
-		Driver driver = currentDriver(null);
+		Driver driver = currentDriver();
 		if (driver == null || Func.isEmpty(driver.getDrivingVehicle())) {
 			return List.of();
 		}
@@ -92,28 +88,23 @@ public class DriverAppServiceImpl implements IDriverAppService {
 
 	@Override
 	public Driver currentDriverEntity() {
-		return currentDriver(null);
+		return currentDriver();
 	}
 
-	private Driver currentDriver(String mobileHint) {
+	/**
+	 * 当前司机的唯一解析入口：只按登录用户的 {@code user_id} 查档案。
+	 * <p>
+	 * 手机号不能用来认人：同一号码可能存在多条档案，按号码查「最近更新的一条」
+	 * 取到的可能是别人的档案；号码本身也会被改。
+	 */
+	private Driver currentDriver() {
 		Long userId = AuthUtil.getUserId();
 		if (userId == null || userId <= 0) {
 			throw new ServiceException("未登录");
 		}
-		String phone = resolvePhone(userId, mobileHint);
-		Driver driver = null;
-		if (Func.isNotEmpty(phone)) {
-			driver = driverService.getOne(Wrappers.<Driver>lambdaQuery()
-				.eq(Driver::getMobile, phone)
-				.orderByDesc(Driver::getUpdateTime)
-				.last("LIMIT 1"));
-		}
-		if (driver == null) {
-			driver = driverService.getOne(Wrappers.<Driver>lambdaQuery()
-				.eq(Driver::getUserId, userId)
-				.last("LIMIT 1"));
-		}
-		return driver;
+		return driverService.getOne(Wrappers.<Driver>lambdaQuery()
+			.eq(Driver::getUserId, userId)
+			.last("LIMIT 1"));
 	}
 
 	private DriverVehicleCardVO toCard(TransportVehicle vehicle) {
@@ -178,53 +169,4 @@ public class DriverAppServiceImpl implements IDriverAppService {
 		return date == null ? "" : date.toString();
 	}
 
-	/**
-	 * 解析用于匹配司机档案的手机号。
-	 * 优先级：前端传入且与本人一致的 mobile → JWT account（司机账号多为手机号）→ 用户中心 phone/account
-	 */
-	private String resolvePhone(Long userId, String mobileHint) {
-		String selfPhone = resolveSelfPhone(userId);
-		String hint = Func.isEmpty(mobileHint) ? null : mobileHint.trim();
-		if (Func.isNotEmpty(hint)) {
-			if (Func.isEmpty(selfPhone)) {
-				// 解析不出本人号码时不能拿前端传的 mobile 去查：
-				// currentDriver 会直接按 mobile 等值查询，传入他人号码即可读到他人档案。
-				// 这里返回空让它退回按 user_id 查，宁可查不到也不越权。
-				return null;
-			}
-			if (!selfPhone.equals(hint)) {
-				throw new ServiceException("只能查询本人司机档案");
-			}
-			return hint;
-		}
-		return selfPhone;
-	}
-
-	private String resolveSelfPhone(Long userId) {
-		String account = AuthUtil.getUserAccount();
-		if (isMobileLike(account)) {
-			return account.trim();
-		}
-		// 小程序用户 phone 带 @Sensitive(MOBILE)，经 Feign 回来是脱敏串，
-		// 因此这里只取未脱敏的 account；脱敏的 phone 一律不用。
-		R<MpUser> result = mpUserClient.userById(userId);
-		if (result != null && R.isSuccess(result) && result.getData() != null) {
-			String userAccount = result.getData().getAccount();
-			if (isMobileLike(userAccount)) {
-				return userAccount.trim();
-			}
-		}
-		return Func.isEmpty(account) ? null : account.trim();
-	}
-
-	/**
-	 * 是否是「可作为司机档案手机号使用」的号码串。
-	 * <p>
-	 * 只判 1 开头的 11~15 位纯数字：库里既有 11 位真实手机号，也有 12 位账号
-	 * （如 175874212082），写死 11 位会让这类账号的司机解析不出本人号码。
-	 */
-	private boolean isMobileLike(String value) {
-		return Func.isNotEmpty(value) && value.trim().matches("^1\\d{10,14}$");
-	}
-
 }

blade-service/blade-transport/src/main/java/org/springblade/transport/service/impl/DriverServiceImpl.java

@@ -25,6 +25,7 @@
  */
 package org.springblade.transport.service.impl;
 
+import cn.hutool.core.util.DesensitizedUtil;
 import com.baomidou.mybatisplus.core.conditions.Wrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
@@ -171,6 +172,31 @@ public class DriverServiceImpl extends BaseServiceImpl<DriverMapper, Driver> imp
 		return bindExistingProfile(existing.getId(), mpUserId);
 	}
 
+	@Override
+	public Long resolveDriverIdByMobile(String tenantId, String mobile) {
+		String resolvedTenantId = trimToNull(tenantId);
+		if (resolvedTenantId == null) {
+			resolvedTenantId = trimToNull(AuthUtil.getTenantId());
+		}
+		String mobileSnapshot = trimToNull(mobile);
+		// 脱敏手机号（如 138****8000）与空号都不是可用业务数据，查不到也不该查
+		if (resolvedTenantId == null || mobileSnapshot == null || mobileSnapshot.contains("*")) {
+			return null;
+		}
+		// 手机号会被二次放号，同租户内可能残留多条历史档案：只有唯一命中才认，不猜
+		List<Driver> matchedDrivers = list(Wrappers.<Driver>lambdaQuery()
+			.select(Driver::getId)
+			.eq(Driver::getTenantId, resolvedTenantId)
+			.eq(Driver::getMobile, mobileSnapshot));
+		if (matchedDrivers.size() != 1) {
+			log.warn("司机档案解析未唯一命中，driver_id 留空。租户={} 手机号={} 命中={} 条",
+				resolvedTenantId, DesensitizedUtil.mobilePhone(mobileSnapshot), matchedDrivers.size());
+			return null;
+		}
+		Driver matchedDriver = matchedDrivers.get(0);
+		return matchedDriver == null ? null : matchedDriver.getId();
+	}
+
 	@Override
 	@Transactional(rollbackFor = Exception.class)
 	public DriverSyncMobileVO syncMobile(String tenantId, Long mpUserId, String oldPhone, String newPhone) {

blade-service/blade-transport/src/main/java/org/springblade/transport/service/impl/DriverWaybillServiceImpl.java

@@ -33,10 +33,7 @@ import org.springblade.core.secure.utils.AuthUtil;
 import org.springblade.core.tool.jackson.JsonUtil;
 import org.springblade.core.tool.utils.DateUtil;
 import org.springblade.core.tool.constant.BladeConstant;
-import org.springblade.core.tool.api.R;
 import org.springblade.core.tool.utils.Func;
-import org.springblade.system.feign.IMpUserClient;
-import org.springblade.system.pojo.entity.MpUser;
 import org.springblade.transport.mapper.ExceptionDisposalMapper;
 import org.springblade.transport.mapper.WaybillEnroutePunchMapper;
 import org.springblade.transport.mapper.WaybillNodePunchMapper;
@@ -154,7 +151,6 @@ public class DriverWaybillServiceImpl implements IDriverWaybillService {
 
 	private final IWaybillService waybillService;
 	private final IDriverService driverService;
-	private final IMpUserClient mpUserClient;
 	private final IProcessConfigService processConfigService;
 	private final ITransportVehicleService transportVehicleService;
 	private final CertificationGate certificationGate;
@@ -166,12 +162,12 @@ public class DriverWaybillServiceImpl implements IDriverWaybillService {
 
 	@Override
 	public DriverWaybillCardVO currentTask() {
-		String phone = currentUserPhone();
-		if (Func.isEmpty(phone)) {
+		Driver driver = currentDriver();
+		if (driver == null) {
 			return null;
 		}
 		// 进行中：running，或无需确认接单但仍为 pending 的历史数据
-		List<Waybill> candidates = waybillService.list(scopedQuery(phone)
+		List<Waybill> candidates = waybillService.list(scopedQuery(driver.getId())
 			.in(Waybill::getBusinessStatus, List.of(STATUS_RUNNING, STATUS_PENDING))
 			.orderByDesc(Waybill::getUpdateTime)
 			.last("LIMIT 20"));
@@ -187,12 +183,12 @@ public class DriverWaybillServiceImpl implements IDriverWaybillService {
 	@Override
 	public DriverWaybillPreviewVO pendingPreview(Integer size) {
 		DriverWaybillPreviewVO preview = new DriverWaybillPreviewVO();
-		String phone = currentUserPhone();
-		if (Func.isEmpty(phone)) {
+		Driver driver = currentDriver();
+		if (driver == null) {
 			return preview;
 		}
 		int limit = normalizePreviewSize(size);
-		List<Waybill> pendingList = waybillService.list(scopedQuery(phone)
+		List<Waybill> pendingList = waybillService.list(scopedQuery(driver.getId())
 			.in(Waybill::getBusinessStatus, PENDING_STATUSES)
 			.orderByDesc(Waybill::getCreateTime));
 		List<Waybill> needAccept = pendingList.stream()
@@ -207,11 +203,11 @@ public class DriverWaybillServiceImpl implements IDriverWaybillService {
 	@Override
 	public DriverWaybillTabCountsVO tabCounts() {
 		DriverWaybillTabCountsVO vo = new DriverWaybillTabCountsVO();
-		String phone = currentUserPhone();
-		if (Func.isEmpty(phone)) {
+		Driver driver = currentDriver();
+		if (driver == null) {
 			return vo;
 		}
-		List<Waybill> waybills = waybillService.list(scopedQuery(phone)
+		List<Waybill> waybills = waybillService.list(scopedQuery(driver.getId())
 			.in(Waybill::getBusinessStatus, TAB_ALL_STATUSES));
 		long pending = 0;
 		long doing = 0;
@@ -243,12 +239,12 @@ public class DriverWaybillServiceImpl implements IDriverWaybillService {
 		int pageSize = size == null || size < 1 ? DEFAULT_PAGE_SIZE : Math.min(size, MAX_PAGE_SIZE);
 		Page<DriverWaybillCardVO> empty = new Page<>(pageNo, pageSize);
 
-		String phone = currentUserPhone();
-		if (Func.isEmpty(phone)) {
+		Driver driver = currentDriver();
+		if (driver == null) {
 			return empty;
 		}
 
-		LambdaQueryWrapper<Waybill> wrapper = scopedQuery(phone);
+		LambdaQueryWrapper<Waybill> wrapper = scopedQuery(driver.getId());
 		// 先按 Tab 口径拉候选，再按过程配置校正 pending→running 后内存分页
 		applyStatusFilterForQuery(wrapper, status);
 		applyKeyword(wrapper, keyword);
@@ -271,18 +267,17 @@ public class DriverWaybillServiceImpl implements IDriverWaybillService {
 
 	@Override
 	public DriverWaybillCardVO detail(Long id) {
-		requireCurrentDriver();
 		Waybill waybill = loadDriverWaybill(id);
 		return toCard(normalizeAcceptStatus(waybill), true);
 	}
 
 	@Override
 	public DriverWaybillCardVO tripCurrentTask() {
-		String phone = currentUserPhone();
-		if (Func.isEmpty(phone)) {
+		Driver driver = currentDriver();
+		if (driver == null) {
 			return null;
 		}
-		TripQueryVO query = TripQueryVO.forDriver(phone);
+		TripQueryVO query = TripQueryVO.forDriver(driver.getId());
 		// 待确认（待回单确认）的趟车司机仍需回到卡片上继续操作，与进行中并列作为当前任务
 		query.setStatuses(List.of(TRIP_STATUS_RUNNING, TRIP_STATUS_PENDING_RETURN_CONFIRM));
 		query.setCurrent(1);
@@ -294,11 +289,11 @@ public class DriverWaybillServiceImpl implements IDriverWaybillService {
 	@Override
 	public DriverWaybillPreviewVO tripPendingPreview(Integer size) {
 		DriverWaybillPreviewVO preview = new DriverWaybillPreviewVO();
-		String phone = currentUserPhone();
-		if (Func.isEmpty(phone)) {
+		Driver driver = currentDriver();
+		if (driver == null) {
 			return preview;
 		}
-		TripQueryVO query = TripQueryVO.forDriver(phone);
+		TripQueryVO query = TripQueryVO.forDriver(driver.getId());
 		query.setStatus(TRIP_STATUS_PENDING);
 		query.setCurrent(1);
 		query.setSize(normalizePreviewSize(size));
@@ -313,11 +308,11 @@ public class DriverWaybillServiceImpl implements IDriverWaybillService {
 	@Override
 	public DriverWaybillTabCountsVO tripTabCounts() {
 		DriverWaybillTabCountsVO counts = new DriverWaybillTabCountsVO();
-		String phone = currentUserPhone();
-		if (Func.isEmpty(phone)) {
+		Driver driver = currentDriver();
+		if (driver == null) {
 			return counts;
 		}
-		TripTabCountsVO tripCounts = tripQueryService.tabCounts(TripQueryVO.forDriver(phone));
+		TripTabCountsVO tripCounts = tripQueryService.tabCounts(TripQueryVO.forDriver(driver.getId()));
 		counts.setPending(tripCounts.getPending());
 		counts.setDoing(tripCounts.getDoing());
 		counts.setConfirm(tripCounts.getConfirm());
@@ -328,11 +323,11 @@ public class DriverWaybillServiceImpl implements IDriverWaybillService {
 
 	@Override
 	public IPage<DriverWaybillCardVO> tripPage(Integer current, Integer size, Integer status, String keyword) {
-		String phone = currentUserPhone();
-		if (Func.isEmpty(phone)) {
+		Driver driver = currentDriver();
+		if (driver == null) {
 			return new Page<>(normalizePageNo(current), normalizePageSize(size));
 		}
-		TripQueryVO query = TripQueryVO.forDriver(phone);
+		TripQueryVO query = TripQueryVO.forDriver(driver.getId());
 		query.setStatus(status);
 		query.setKeyword(keyword);
 		query.setCurrent(current);
@@ -347,15 +342,14 @@ public class DriverWaybillServiceImpl implements IDriverWaybillService {
 
 	@Override
 	public DriverWaybillCardVO tripDetail(String tripId) {
-		requireCurrentDriver();
-		TripQueryVO query = TripQueryVO.forDriver(currentUserPhone());
+		Driver driver = requireCurrentDriver();
+		TripQueryVO query = TripQueryVO.forDriver(driver.getId());
 		query.setTripId(tripId);
 		return toTripCard(tripQueryService.detail(query), true);
 	}
 
 	@Override
 	public WaybillTrackVO track(Long id) {
-		requireCurrentDriver();
 		Waybill waybill = loadDriverWaybill(id);
 		LocalDate[] range = resolveTrackDateRange(waybill);
 		return waybillService.trackVehicle(waybill.getId(), range[0].toString(), range[1].toString());
@@ -742,7 +736,7 @@ public class DriverWaybillServiceImpl implements IDriverWaybillService {
 	 * 子单集合是司机可见的那一批：已拒单的子单不在其中，否则接单会把本人拒掉的单重新拉回来。
 	 */
 	private List<TripVO.TripWaybillVO> tripChildren(String tripId) {
-		TripQueryVO query = TripQueryVO.forDriver(currentUserPhone());
+		TripQueryVO query = TripQueryVO.forDriver(requireCurrentDriver().getId());
 		query.setTripId(tripId);
 		TripVO trip = tripQueryService.detail(query);
 		List<TripVO.TripWaybillVO> children = trip.getWaybills() == null ? List.of() : trip.getWaybills();
@@ -822,13 +816,10 @@ public class DriverWaybillServiceImpl implements IDriverWaybillService {
 		if (id == null) {
 			throw new ServiceException("运单ID不能为空");
 		}
-		String phone = currentUserPhone();
-		if (Func.isEmpty(phone)) {
-			throw new ServiceException("当前用户手机号为空，无法查找运单");
-		}
+		Driver driver = requireCurrentDriver();
 		// MySQL 的 FOR UPDATE 必须跟在 LIMIT 之后
 		String tail = forUpdate ? "LIMIT 1 FOR UPDATE" : "LIMIT 1";
-		Waybill waybill = waybillService.getOne(scopedQuery(phone, includeRejected)
+		Waybill waybill = waybillService.getOne(scopedQuery(driver.getId(), includeRejected)
 			.eq(Waybill::getId, id).last(tail));
 		if (waybill == null) {
 			throw new ServiceException("运单不存在或无权操作");
@@ -885,14 +876,17 @@ public class DriverWaybillServiceImpl implements IDriverWaybillService {
 	}
 
 	/**
-	 * 司机可见运单范围：运单司机手机号（driver_phone）等于当前用户手机号，
+	 * 司机可见运单范围：运单归属档案（driver_id）就是当前司机档案，
 	 * 且该运单未被这个司机拒单。
 	 * <p>
+	 * driver_id 必须有值且大于 0 才算有主：存量数据的 -1 是哨兵值，与 0 一样等同无主。
+	 * 运单上的 driver_phone 只是派单快照，不参与归属判定——司机改号不影响可见性。
+	 * <p>
 	 * 拒单后运单对司机彻底脱离——列表、计数、详情、打卡、接单一律不可达，等管理员重新派单。
 	 * 运单上的司机姓名/手机/车牌不清空，调度重新派单时要知道原来派给谁。
 	 */
-	private LambdaQueryWrapper<Waybill> scopedQuery(String phone) {
-		return scopedQuery(phone, false);
+	private LambdaQueryWrapper<Waybill> scopedQuery(Long driverId) {
+		return scopedQuery(driverId, false);
 	}
 
 	/**
@@ -900,11 +894,10 @@ public class DriverWaybillServiceImpl implements IDriverWaybillService {
 	 *                        拒单的运单不可能处于运输中，收口拦不到合法操作，
 	 *                        而保留原判据可避免「已拒单 + 进行中」的历史脏数据被误伤
 	 */
-	private LambdaQueryWrapper<Waybill> scopedQuery(String phone, boolean includeRejected) {
-		String normalizedPhone = Func.toStr(phone, "").trim();
-		LambdaQueryWrapper<Waybill> wrapper = Wrappers.<Waybill>lambdaQuery().and(w -> w
-			.eq(Waybill::getDriverPhone, normalizedPhone)
-			.or().apply("REPLACE(IFNULL(driver_phone,''),' ','') = {0}", normalizedPhone));
+	private LambdaQueryWrapper<Waybill> scopedQuery(Long driverId, boolean includeRejected) {
+		LambdaQueryWrapper<Waybill> wrapper = Wrappers.<Waybill>lambdaQuery()
+			.gt(Waybill::getDriverId, 0)
+			.eq(Waybill::getDriverId, driverId);
 		if (!includeRejected) {
 			wrapper.and(w -> w.isNull(Waybill::getDriverAcceptStatus)
 				.or().ne(Waybill::getDriverAcceptStatus, WaybillProcessSupport.ACCEPT_REJECTED));
@@ -926,69 +919,18 @@ public class DriverWaybillServiceImpl implements IDriverWaybillService {
 	}
 
 	/**
-	 * 当前用户手机号：司机档案 mobile 优先，其次小程序用户账号。
+	 * 当前登录司机：只按登录用户 ID 查司机档案，查不到即「无归属」。
 	 * <p>
-	 * 派单时运单 driver_phone 取自司机档案 mobile，故档案有手机号就以它为准。
-	 */
-	private String currentUserPhone() {
-		Driver driver = currentDriver();
-		if (driver != null && isMobileLike(driver.getMobile())) {
-			return driver.getMobile().trim();
-		}
-		Long userId = AuthUtil.getUserId();
-		if (userId == null || userId <= 0) {
-			return null;
-		}
-		R<MpUser> result = mpUserClient.userById(userId);
-		if (result != null && R.isSuccess(result) && result.getData() != null
-			&& isMobileLike(result.getData().getAccount())) {
-			return result.getData().getAccount().trim();
-		}
-		return null;
-	}
-
-	/**
-	 * 当前登录司机：优先 userId，其次手机号（JWT 账号 / 小程序用户 account）匹配 driver.mobile
+	 * 归属判据：driver_id = 当前登录人的司机档案 id；driver_phone 不参与判定。
 	 */
 	private Driver currentDriver() {
 		Long userId = AuthUtil.getUserId();
 		if (userId == null || userId <= 0) {
 			return null;
 		}
-		Driver driver = driverService.getOne(Wrappers.<Driver>lambdaQuery()
+		return driverService.getOne(Wrappers.<Driver>lambdaQuery()
 			.eq(Driver::getUserId, userId)
 			.last("LIMIT 1"));
-		if (driver != null) {
-			return driver;
-		}
-		String phone = resolveSelfPhone(userId);
-		if (Func.isNotEmpty(phone)) {
-			return driverService.getOne(Wrappers.<Driver>lambdaQuery()
-				.eq(Driver::getMobile, phone)
-				.orderByDesc(Driver::getUpdateTime)
-				.last("LIMIT 1"));
-		}
-		return null;
-	}
-
-	/**
-	 * 解析当前小程序用户可用于匹配司机档案的手机号
-	 */
-	private String resolveSelfPhone(Long userId) {
-		String account = AuthUtil.getUserAccount();
-		if (isMobileLike(account)) {
-			return account.trim();
-		}
-		R<MpUser> result = mpUserClient.userById(userId);
-		if (result != null && R.isSuccess(result) && result.getData() != null
-			&& isMobileLike(result.getData().getAccount())) {
-			return result.getData().getAccount().trim();
-		}
-		return Func.isEmpty(account) ? null : account.trim();
-	}
-
-	private boolean isMobileLike(String value) {
-		return Func.isNotEmpty(value) && value.trim().matches("^1\\d{10,14}$");
 	}
 
 	private List<String> splitPlates(String drivingVehicle) {
@@ -1308,8 +1250,7 @@ public class DriverWaybillServiceImpl implements IDriverWaybillService {
 
 	@Override
 	public void assertCurrentDriverOwnsWaybill(Long waybillId) {
-		// 归属口径与司机打卡、司机接单一致：按当前用户手机号匹配运单司机手机号
-		requireCurrentDriver();
+		// 归属口径与司机打卡、司机接单一致：运单 driver_id 必须是当前登录司机的档案（查不到档案即无归属）
 		loadDriverWaybill(waybillId);
 	}
 

blade-service/blade-transport/src/main/java/org/springblade/transport/service/impl/LoadingManageServiceImpl.java

@@ -4,6 +4,7 @@
  */
 package org.springblade.transport.service.impl;
 
+import cn.hutool.core.util.DesensitizedUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
@@ -11,6 +12,7 @@ import jakarta.annotation.Resource;
 import lombok.extern.slf4j.Slf4j;
 import org.springblade.core.log.exception.ServiceException;
 import org.springblade.core.mp.base.BaseServiceImpl;
+import org.springblade.core.secure.utils.AuthUtil;
 import org.springblade.core.tool.jackson.JsonUtil;
 import org.springblade.core.tool.utils.BeanUtil;
 import org.springblade.core.tool.utils.Func;
@@ -29,6 +31,7 @@ import org.springblade.transport.pojo.vo.BusinessRemoveResultVO;
 import org.springblade.transport.pojo.vo.LoadingCarrierContractVO;
 import org.springblade.transport.pojo.vo.LoadingManageVO;
 import org.springblade.transport.service.IContractManageService;
+import org.springblade.transport.service.IDriverService;
 import org.springblade.transport.service.ILoadingManageService;
 import org.springblade.transport.service.IProcessConfigService;
 import org.springblade.transport.service.IReceivablePayableDetailService;
@@ -89,6 +92,9 @@ public class LoadingManageServiceImpl extends BaseServiceImpl<LoadingManageMappe
 	@Resource
 	private IProcessConfigService processConfigService;
 
+	@Resource
+	private IDriverService driverService;
+
 	@Override
 	public IPage<LoadingManageVO> selectLoadingManagePage(IPage<LoadingManage> page, LoadingManageVO loadingManage) {
 		IPage<LoadingManage> entityPage = page(page, buildQuery(loadingManage));
@@ -139,16 +145,17 @@ public class LoadingManageServiceImpl extends BaseServiceImpl<LoadingManageMappe
 		List<Long> oldWaybillIds = new ArrayList<>();
 		// 新建暂存为草稿；编辑已有单据时保持原业务状态（如待执行），避免被改回草稿
 		String businessStatus = STATUS_DRAFT;
-		if (Func.isNotEmpty(loadingManage.getId())) {
-			LoadingManage oldRecord = loadEditable(loadingManage.getId(), true);
-			oldWaybillIds = waybillIds(oldRecord.getWaybillIdsJson());
-			loadingManage.setLoadingNo(oldRecord.getLoadingNo());
-			loadingManage.setDeptId(oldRecord.getDeptId());
-			loadingManage.setDeptName(oldRecord.getDeptName());
-			if (Func.isNotEmpty(oldRecord.getBusinessStatus())) {
-				businessStatus = oldRecord.getBusinessStatus();
+		LoadingManage stored = Func.isEmpty(loadingManage.getId()) ? null : loadEditable(loadingManage.getId(), true);
+		if (stored != null) {
+			oldWaybillIds = waybillIds(stored.getWaybillIdsJson());
+			loadingManage.setLoadingNo(stored.getLoadingNo());
+			loadingManage.setDeptId(stored.getDeptId());
+			loadingManage.setDeptName(stored.getDeptName());
+			if (Func.isNotEmpty(stored.getBusinessStatus())) {
+				businessStatus = stored.getBusinessStatus();
 			}
 		}
+		applyDriverOwnership(loadingManage, stored);
 		prepareCreateOrUpdate(loadingManage);
 		loadingManage.setBusinessStatus(businessStatus);
 		if (Func.isEmpty(loadingManage.getLoadingNo())) {
@@ -200,6 +207,7 @@ public class LoadingManageServiceImpl extends BaseServiceImpl<LoadingManageMappe
 			loadingManage.setDeptId(oldRecord.getDeptId());
 			loadingManage.setDeptName(oldRecord.getDeptName());
 		}
+		applyDriverOwnership(loadingManage, oldRecord);
 		prepareCreateOrUpdate(loadingManage);
 		if (Func.isEmpty(loadingManage.getLoadingNo())) {
 			loadingManage.setLoadingNo(nextCode());
@@ -319,6 +327,7 @@ public class LoadingManageServiceImpl extends BaseServiceImpl<LoadingManageMappe
 		loadingManage.setCargoName(first.getCargoName());
 		loadingManage.setVehicleNo(first.getVehicleNo());
 		loadingManage.setTrailerVehicleNo(first.getTrailerVehicleNo());
+		loadingManage.setDriverId(first.getDriverId());
 		loadingManage.setDriverName(first.getDriverName());
 		loadingManage.setDriverPhone(first.getDriverPhone());
 		loadingManage.setEscortName(first.getEscortName());
@@ -478,6 +487,7 @@ public class LoadingManageServiceImpl extends BaseServiceImpl<LoadingManageMappe
 		target.setTrailerVehicleNo(source.getTrailerVehicleNo());
 		target.setDriverName(source.getDriverName());
 		target.setDriverPhone(source.getDriverPhone());
+		target.setDriverId(source.getDriverId());
 		target.setEscortName(source.getEscortName());
 		target.setEscortPhone(source.getEscortPhone());
 		target.setCarrierType(source.getCarrierType());
@@ -505,6 +515,7 @@ public class LoadingManageServiceImpl extends BaseServiceImpl<LoadingManageMappe
 		target.setBusinessStatus(STATUS_DRAFT);
 		target.setLoadingNo(nextCode());
 		prepare(target);
+		applyDriverOwnership(target, null);
 		validate(target, true);
 		save(target);
 		return detail(target.getId());
@@ -521,6 +532,7 @@ public class LoadingManageServiceImpl extends BaseServiceImpl<LoadingManageMappe
 			throw new ServiceException("仅司机拒绝接单后允许重新派单");
 		}
 		prepare(loadingManage);
+		applyDriverOwnership(loadingManage, oldRecord);
 		validate(loadingManage, false);
 		List<Long> oldWaybillIds = waybillIds(oldRecord.getWaybillIdsJson());
 		loadingManage.setLoadingNo(oldRecord.getLoadingNo());
@@ -781,6 +793,32 @@ public class LoadingManageServiceImpl extends BaseServiceImpl<LoadingManageMappe
 		}
 	}
 
+	/**
+	 * 写司机归属：档案 ID 只在需要时解析，已落在单据上的归属不会被无关保存抹掉。
+	 * <p>
+	 * 判定顺序：调用方带了正数档案 ID 就用它；更新时 driver_phone 与库中一致且库中 driver_id 非空就保留库中值；
+	 * 其余情况（新建、换号、原本无主）按手机号在租户内唯一匹配司机档案，匹配不到落 null 并留 WARN，不阻断保存。
+	 */
+	private void applyDriverOwnership(LoadingManage loadingManage, LoadingManage stored) {
+		Long driverId = loadingManage.getDriverId();
+		if (driverId != null && driverId > 0) {
+			return;
+		}
+		if (stored != null && Func.isNotEmpty(stored.getDriverId())
+			&& Objects.equals(TransportBusinessSupport.trimToNull(stored.getDriverPhone()), loadingManage.getDriverPhone())) {
+			loadingManage.setDriverId(stored.getDriverId());
+			return;
+		}
+		String tenantId = Func.isNotEmpty(loadingManage.getTenantId()) ? loadingManage.getTenantId() : AuthUtil.getTenantId();
+		Long resolvedDriverId = driverService.resolveDriverIdByMobile(tenantId, loadingManage.getDriverPhone());
+		loadingManage.setDriverId(resolvedDriverId);
+		if (resolvedDriverId == null) {
+			log.warn("配载单 {} 的司机手机号未唯一匹配司机档案，driver_id 落空。租户={} 手机号={}",
+				Func.isEmpty(loadingManage.getLoadingNo()) ? "（未编号）" : loadingManage.getLoadingNo(),
+				tenantId, DesensitizedUtil.mobilePhone(loadingManage.getDriverPhone()));
+		}
+	}
+
 	private void validate(LoadingManage loadingManage, boolean draftMode) {
 		TransportBusinessSupport.validateRequired(loadingManage.getLoadingSubNos(), "配载子单号不能为空");
 		TransportBusinessSupport.validateRequired(loadingManage.getTransportType(), "运输类型不能为空");
@@ -1150,6 +1188,7 @@ public class LoadingManageServiceImpl extends BaseServiceImpl<LoadingManageMappe
 			.set(Waybill::getCarrierType, loadingManage.getCarrierType())
 			.set(Waybill::getCarrierContractId, loadingManage.getCarrierContractId())
 			.set(Waybill::getCarrierName, loadingManage.getCarrierName())
+			.set(Waybill::getDriverId, loadingManage.getDriverId())
 			.set(Waybill::getDriverName, loadingManage.getDriverName())
 			.set(Waybill::getDriverPhone, loadingManage.getDriverPhone())
 			.set(Waybill::getVehicleNo, loadingManage.getVehicleNo())
@@ -1264,6 +1303,7 @@ public class LoadingManageServiceImpl extends BaseServiceImpl<LoadingManageMappe
 			.set(Waybill::getCarrierType, loadingManage.getCarrierType())
 			.set(Waybill::getCarrierContractId, loadingManage.getCarrierContractId())
 			.set(Waybill::getCarrierName, loadingManage.getCarrierName())
+			.set(Waybill::getDriverId, loadingManage.getDriverId())
 			.set(Waybill::getDriverName, loadingManage.getDriverName())
 			.set(Waybill::getDriverPhone, loadingManage.getDriverPhone())
 			.set(Waybill::getVehicleNo, loadingManage.getVehicleNo())

blade-service/blade-transport/src/main/java/org/springblade/transport/service/impl/MasterOrderServiceImpl.java

@@ -4,8 +4,10 @@
  */
 package org.springblade.transport.service.impl;
 
+import cn.hutool.core.util.DesensitizedUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
+import lombok.extern.slf4j.Slf4j;
 import org.springblade.core.log.exception.ServiceException;
 import org.springblade.core.mp.base.BaseServiceImpl;
 import org.springblade.core.tool.jackson.JsonUtil;
@@ -24,6 +26,7 @@ import org.springblade.transport.pojo.vo.MasterOrderCarrierVO;
 import org.springblade.transport.pojo.vo.MasterOrderVO;
 import org.springblade.transport.service.IMasterOrderService;
 import org.springblade.transport.service.IContractManageService;
+import org.springblade.transport.service.IDriverService;
 import org.springblade.transport.service.IProjectApplyService;
 import org.springblade.transport.service.ITransportPlanService;
 import org.springblade.transport.service.IWaybillService;
@@ -50,6 +53,7 @@ import java.util.Objects;
  * @author Chill
  */
 @Service
+@Slf4j
 public class MasterOrderServiceImpl extends BaseServiceImpl<MasterOrderMapper, MasterOrder> implements IMasterOrderService {
 
 	private static final String CARRIER_SELF = "自运";
@@ -58,13 +62,15 @@ public class MasterOrderServiceImpl extends BaseServiceImpl<MasterOrderMapper, M
 	private final ITransportPlanService transportPlanService;
 	private final IProjectApplyService projectApplyService;
 	private final IContractManageService contractManageService;
+	private final IDriverService driverService;
 
 	public MasterOrderServiceImpl(IWaybillService waybillService, ITransportPlanService transportPlanService, IProjectApplyService projectApplyService,
-		IContractManageService contractManageService) {
+		IContractManageService contractManageService, IDriverService driverService) {
 		this.waybillService = waybillService;
 		this.transportPlanService = transportPlanService;
 		this.projectApplyService = projectApplyService;
 		this.contractManageService = contractManageService;
+		this.driverService = driverService;
 	}
 
 	@Override
@@ -263,6 +269,17 @@ public class MasterOrderServiceImpl extends BaseServiceImpl<MasterOrderMapper, M
 		waybill.setTransportType(string(dispatch, "transportType")); waybill.setCarrierType(string(dispatch, "carrierType"));
 		waybill.setCarrierContractId(longValue(dispatch, "carrierContractId")); waybill.setCarrierName(string(dispatch, "carrierName")); waybill.setDriverName(string(dispatch, "driverName"));
 		waybill.setDriverPhone(string(dispatch, "driverPhone")); waybill.setVehicleNo(string(dispatch, "vehicleNo")); waybill.setTrailerVehicleNo(string(dispatch, "trailerVehicleNo"));
+		// 归属主键是档案 ID：调度带了就用它，否则按手机号解析；解析入口只返回 null 或唯一命中的
+		// 档案 ID，承运商司机解析为空也照常派单，落空时留 WARN
+		Long driverId = longValue(dispatch, "driverId");
+		if (driverId == null || driverId <= 0) {
+			driverId = driverService.resolveDriverIdByMobile(waybill.getTenantId(), waybill.getDriverPhone());
+			if (driverId == null) {
+				log.warn("总单 {} 派单的司机手机号未唯一匹配司机档案，driver_id 落空（不阻断派单）。租户={} 手机号={}",
+					masterOrder.getMasterNo(), waybill.getTenantId(), DesensitizedUtil.mobilePhone(waybill.getDriverPhone()));
+			}
+		}
+		waybill.setDriverId(driverId);
 		waybill.setCaptainName(string(dispatch, "captainName")); waybill.setCabinNo(string(dispatch, "cabinNo")); waybill.setContainerNo(string(dispatch, "containerNo"));
 		waybill.setEscortName(string(dispatch, "escortName")); waybill.setEscortPhone(string(dispatch, "escortPhone")); waybill.setMileage(nullableDecimal(dispatch, "mileage"));
 		waybill.setDepartureName(string(dispatch, "departureName")); waybill.setDepartureAddress(string(dispatch, "departureAddress"));

blade-service/blade-transport/src/main/java/org/springblade/transport/service/impl/TripQueryServiceImpl.java

@@ -389,22 +389,22 @@ public class TripQueryServiceImpl implements ITripQueryService {
 	}
 
 	/**
-	 * 运次可见范围：配载段按配载单的司机手机号收口，未配载段按运单的司机手机号收口。
+	 * 运次可见范围：已配载段按配载单的 driver_id 收口，未配载段按运单的 driver_id 收口。
 	 * <p>
-	 * 手机号允许带空格，与运单列表的收口判据一致。
+	 * 归属判据只有司机档案 ID（null 或非正数视为无主），driver_phone 不参与判定。
+	 * 无主的运次由 {@link #scoped} 在外层挡掉。
 	 */
 	private void applyScope(LambdaQueryWrapper<Waybill> wrapper, TripQueryVO condition) {
 		if (condition.isAllDrivers()) {
 			return;
 		}
-		String phone = Func.toStr(condition.getDriverPhone(), "").trim();
+		Long driverId = condition.getDriverId();
 		wrapper.and(scope -> scope
 			.apply("(IFNULL(loading_no, '') <> '' AND loading_no IN (SELECT lm.loading_no FROM blade_loading_manage lm"
-				+ " WHERE lm.is_deleted = 0 AND lm.driver_phone = {0}))", phone)
+				+ " WHERE lm.is_deleted = 0 AND lm.driver_id = {0}))", driverId)
 			.or(lone -> lone
 				.apply("IFNULL(loading_no, '') = ''")
-				.and(row -> row.eq(Waybill::getDriverPhone, phone)
-					.or().apply("REPLACE(IFNULL(driver_phone, ''), ' ', '') = {0}", phone))));
+				.and(row -> row.eq(Waybill::getDriverId, driverId))));
 	}
 
 	/**
@@ -786,7 +786,7 @@ public class TripQueryServiceImpl implements ITripQueryService {
 	}
 
 	/**
-	 * 按运次主键取配载单：主键命中配载单即配载运次，再按司机收口
+	 * 按运次主键取配载单：主键命中配载单即配载运次，再按配载单的司机档案 ID 收口
 	 */
 	private LoadingManage visibleLoading(Long id, TripQueryVO condition) {
 		LoadingManage loading = loadingManageService.getById(id);
@@ -796,7 +796,7 @@ public class TripQueryServiceImpl implements ITripQueryService {
 		if (condition.isAllDrivers()) {
 			return loading;
 		}
-		return samePhone(loading.getDriverPhone(), condition.getDriverPhone()) ? loading : null;
+		return ownedBy(loading.getDriverId(), condition.getDriverId()) ? loading : null;
 	}
 
 	/**
@@ -813,19 +813,23 @@ public class TripQueryServiceImpl implements ITripQueryService {
 		if (condition.isAllDrivers()) {
 			return waybill;
 		}
-		return samePhone(waybill.getDriverPhone(), condition.getDriverPhone()) ? waybill : null;
+		return ownedBy(waybill.getDriverId(), condition.getDriverId()) ? waybill : null;
 	}
 
+	/** 收口条件是否成立：管理端不收口；司机端必须给出有效的档案 ID，缺省一律拒绝 */
 	private boolean scoped(TripQueryVO condition) {
-		return condition.isAllDrivers() || Func.isNotEmpty(Func.toStr(condition.getDriverPhone(), "").trim());
+		Long driverId = condition.getDriverId();
+		return condition.isAllDrivers() || (driverId != null && driverId > 0);
 	}
 
-	private boolean samePhone(String left, String right) {
-		String expected = Func.toStr(right, "").trim().replace(" ", "");
-		if (Func.isEmpty(expected)) {
-			return false;
-		}
-		return expected.equals(Func.toStr(left, "").trim().replace(" ", ""));
+	/**
+	 * 归属判据：行的司机档案 ID 与收口条件相等。
+	 * <p>
+	 * 条件侧缺省（空、0、负数）一律不可见——没有有效档案 ID 就等于没有收口条件，
+	 * 此时任何行都不能算作「本人」，否则业务主键未回填的历史数据会把运次漏给所有人。
+	 */
+	private boolean ownedBy(Long ownerId, Long expectedId) {
+		return expectedId != null && expectedId > 0 && expectedId.equals(ownerId);
 	}
 
 	private TripQueryVO condition(TripQueryVO query) {
@@ -835,7 +839,7 @@ public class TripQueryServiceImpl implements ITripQueryService {
 	/** 去掉 Tab 条件、其余照搬：统计四档时不按某一档收窄 */
 	private TripQueryVO withoutTab(TripQueryVO source) {
 		TripQueryVO copy = new TripQueryVO();
-		copy.setDriverPhone(source.getDriverPhone());
+		copy.setDriverId(source.getDriverId());
 		copy.setAllDrivers(source.isAllDrivers());
 		copy.setDeptIds(source.getDeptIds());
 		copy.setProjectIds(source.getProjectIds());

blade-service/blade-transport/src/main/java/org/springblade/transport/service/impl/WaybillImportBatchServiceImpl.java

@@ -10,6 +10,7 @@ import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import jakarta.servlet.http.HttpServletResponse;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springblade.common.excel.ImportFailureExcelUtil;
 import org.springblade.core.log.exception.ServiceException;
 import org.springblade.core.mp.base.BaseServiceImpl;
@@ -41,6 +42,7 @@ import org.springblade.transport.pojo.vo.WaybillImportBatchVO;
 import org.springblade.transport.pojo.vo.WaybillImportRowErrorVO;
 import org.springblade.transport.pojo.vo.WaybillImportValidateResultVO;
 import org.springblade.transport.service.ICustomerArchiveService;
+import org.springblade.transport.service.IDriverService;
 import org.springblade.transport.service.IProjectApplyService;
 import org.springblade.transport.service.IReceivablePayableDetailService;
 import org.springblade.transport.service.ILoadingManageService;
@@ -68,6 +70,7 @@ import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
 /** 运单批次服务实现。 */
+@Slf4j
 @Service
 @RequiredArgsConstructor
 public class WaybillImportBatchServiceImpl extends BaseServiceImpl<WaybillImportBatchMapper, WaybillImportBatch> implements IWaybillImportBatchService {
@@ -101,6 +104,7 @@ public class WaybillImportBatchServiceImpl extends BaseServiceImpl<WaybillImport
 	private final IReceivablePayableDetailService receivablePayableDetailService;
 	private final ILoadingManageService loadingManageService;
 	private final ISysClient sysClient;
+	private final IDriverService driverService;
 
 	@Override
 	@Transactional(rollbackFor = Exception.class)
@@ -207,7 +211,9 @@ public class WaybillImportBatchServiceImpl extends BaseServiceImpl<WaybillImport
 		List<Waybill> rowWaybills = new ArrayList<>();
 		for (int index = 0; index < rows.size(); index++) {
 			try {
-				rowWaybills.add(buildWaybill(rows.get(index), batch, request.getCarrierContractId(), draft));
+				Waybill builtWaybill = buildWaybill(rows.get(index), batch, request.getCarrierContractId(), draft);
+				fillDriverOwnership(builtWaybill, index + 1);
+				rowWaybills.add(builtWaybill);
 			} catch (Exception exception) {
 				throw new ServiceException("第" + (index + 1) + "行" + (draft ? "保存" : "导入") + "失败：" + exception.getMessage());
 			}
@@ -485,6 +491,26 @@ public class WaybillImportBatchServiceImpl extends BaseServiceImpl<WaybillImport
 		return id == null || id <= 0L ? null : id;
 	}
 
+	/**
+	 * 补齐导入运单的司机档案 ID：行内有（老系统导出）就用，否则按手机号解析。
+	 * 解析不到不阻断导入，只留行级 WARN：承运商司机与未登录过小程序的司机本来就没有档案。
+	 */
+	private void fillDriverOwnership(Waybill waybill, int rowNo) {
+		Long driverId = waybill.getDriverId();
+		if (driverId != null && driverId > 0) {
+			return;
+		}
+		// 解析入口只返回 null 或唯一命中的档案 ID，不需要再按哨兵归一
+		Long resolvedDriverId = driverService.resolveDriverIdByMobile(waybill.getTenantId(), waybill.getDriverPhone());
+		if (resolvedDriverId != null) {
+			waybill.setDriverId(resolvedDriverId);
+			return;
+		}
+		waybill.setDriverId(null);
+		log.warn("第{}行 运单 {} 的司机手机号未唯一匹配司机档案，driver_id 留空（不阻断导入）",
+			rowNo, waybill.getWaybillNo());
+	}
+
 	private Waybill buildWaybill(Map<String, Object> row, WaybillImportBatch batch, Long carrierContractId, boolean draft) {
 		if (row == null) throw new ServiceException("运单数据不正确");
 		Waybill waybill = new Waybill();

blade-service/blade-transport/src/main/java/org/springblade/transport/service/impl/WaybillServiceImpl.java

@@ -22,6 +22,7 @@
  */
 package org.springblade.transport.service.impl;
 
+import cn.hutool.core.util.DesensitizedUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
@@ -61,6 +62,7 @@ import org.springblade.transport.pojo.vo.WaybillPunchPhotoVO;
 import org.springblade.transport.pojo.vo.WaybillPunchRecordItemVO;
 import org.springblade.transport.pojo.vo.WaybillPunchRecordsVO;
 import org.springblade.transport.pojo.vo.WaybillVO;
+import org.springblade.transport.service.IDriverService;
 import org.springblade.transport.service.ILoadingManageService;
 import org.springblade.transport.service.IProcessConfigService;
 import org.springblade.transport.service.IProjectApplyService;
@@ -110,6 +112,9 @@ public class WaybillServiceImpl extends BaseServiceImpl<WaybillMapper, Waybill>
 	@jakarta.annotation.Resource
 	private ILoadingManageService loadingManageService;
 
+	@jakarta.annotation.Resource
+	private IDriverService driverService;
+
 	@jakarta.annotation.Resource
 	private IProcessConfigService processConfigService;
 
@@ -1610,7 +1615,18 @@ public class WaybillServiceImpl extends BaseServiceImpl<WaybillMapper, Waybill>
 		TransportBusinessSupport.validateRequired(driverPhone, "手机号不能为空");
 		TransportBusinessSupport.validateRequired(vehicleNo, "车牌号不能为空");
 
-		waybill.setDriverId(request.getDriverId());
+		// 归属主键是档案 ID，手机号只是派单时的号码快照：调用方带了档案 ID 就用它，
+		// 否则按手机号解析；解析入口只返回 null 或唯一命中的档案 ID，承运商司机、未建档司机
+		// 解析为空，派单照旧成功，落空时留 WARN
+		Long driverId = request.getDriverId();
+		if (driverId == null || driverId <= 0) {
+			driverId = driverService.resolveDriverIdByMobile(waybill.getTenantId(), driverPhone);
+			if (driverId == null) {
+				log.warn("运单 {} 的司机手机号未唯一匹配司机档案，driver_id 落空（不阻断派单）。租户={} 手机号={}",
+					waybill.getWaybillNo(), waybill.getTenantId(), DesensitizedUtil.mobilePhone(driverPhone));
+			}
+		}
+		waybill.setDriverId(driverId);
 		waybill.setDriverName(driverName);
 		waybill.setDriverPhone(driverPhone);
 		waybill.setVehicleNo(vehicleNo);

blade-service/blade-transport/src/test/java/org/springblade/transport/service/impl/DriverAppServiceImplTest.java

@@ -1,15 +1,16 @@
 package org.springblade.transport.service.impl;
 
+import com.baomidou.mybatisplus.core.MybatisConfiguration;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
+import org.apache.ibatis.builder.MapperBuilderAssistant;
+import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.mockito.MockedStatic;
 import org.springblade.core.log.exception.ServiceException;
 import org.springblade.core.secure.utils.AuthUtil;
-import org.springblade.core.tool.api.R;
-import org.springblade.system.feign.IMpUserClient;
-import org.springblade.system.pojo.entity.MpUser;
 import org.springblade.transport.pojo.entity.Driver;
 import org.springblade.transport.pojo.entity.TransportVehicle;
 import org.springblade.transport.pojo.vo.DriverVehicleCardVO;
@@ -17,19 +18,23 @@ import org.springblade.transport.service.IDriverService;
 import org.springblade.transport.service.ITransportVehicleService;
 
 import java.time.LocalDate;
+import java.util.Date;
 import java.util.List;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.mockStatic;
 import static org.mockito.Mockito.when;
 
 /**
- * 司机端车辆卡片（重新认证表单的数据来源）测试。
+ * 司机端「当前司机」解析与车辆卡片（重新认证表单的数据来源）测试。
  * <p>
- * 卡片字段会**直接进表单**，所以这里盯的不是「显示得好不好看」，而是两条会让回显出错的契约：
+ * 解析侧盯住 ADR-0028 的唯一入口：登录用户 → {@code user_id} → 档案，手机号只是档案上的一个字段，
+ * 不参与查找；卡片字段会**直接进表单**，所以这里盯的不是「显示得好不好看」，而是两条会让回显出错的契约：
  * 日期字段只能是 {@code yyyy-MM-dd} 或空串（不能是「长期」这类文字）；
  * 标了长期有效的字段不能再下发一个作废的止期。
  */
@@ -42,11 +47,17 @@ class DriverAppServiceImplTest {
 	private ITransportVehicleService transportVehicleService;
 	private DriverAppServiceImpl service;
 
+	@BeforeAll
+	static void initTableInfo() {
+		// 实体元数据就绪后，LambdaQueryWrapper 才能把 Driver::getUserId 解析成列名
+		TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new MybatisConfiguration(), ""), Driver.class);
+	}
+
 	@BeforeEach
 	void setUp() {
 		driverService = mock(IDriverService.class);
 		transportVehicleService = mock(ITransportVehicleService.class);
-		service = new DriverAppServiceImpl(driverService, transportVehicleService, mock(IMpUserClient.class));
+		service = new DriverAppServiceImpl(driverService, transportVehicleService);
 	}
 
 	@Test
@@ -85,33 +96,69 @@ class DriverAppServiceImplTest {
 		assertEquals("2028-12-04", card.getRoadTransportCertStartDate());
 	}
 
-	// ---------------------------------------------------------------- 手机号解析
+	// ---------------------------------------------------------------- 当前司机解析
 
 	@Test
-	@DisplayName("12 位手机号也能解析出本人号码——库里存在 12 位司机账号，写死 11 位会让他们查不到自己的档案")
-	void twelveDigitAccountIsUsableAsPhone() {
-		assertEquals("黄大富", currentByPhone("175874212082", "175874212082", null).getDriverName());
+	@DisplayName("同号两条档案时取登录人自己那条——按手机号取「最近更新的一条」会把冒名者当成当前司机")
+	void currentDriverComesFromUserIdNotMobile() {
+		Driver owner = driver(9001L, USER_ID, "黄大富", MOBILE);
+		owner.setUpdateTime(new Date(1735689600000L));
+		Driver impostor = driver(9002L, 7002L, "冒名者", MOBILE);
+		impostor.setUpdateTime(new Date(1767225600000L));
+
+		when(driverService.getOne(any(LambdaQueryWrapper.class))).thenAnswer(invocation -> {
+			LambdaQueryWrapper<Driver> wrapper = invocation.getArgument(0);
+			String sqlSegment = wrapper.getSqlSegment();
+			if (sqlSegment.contains("mobile")) {
+				return impostor;
+			}
+			return sqlSegment.contains("user_id") ? owner : null;
+		});
+
+		try (MockedStatic<AuthUtil> authUtil = mockStatic(AuthUtil.class)) {
+			authUtil.when(AuthUtil::getUserId).thenReturn(USER_ID);
+			// 司机账号本身就是手机号：手机号优先的实现正是靠它命中那条同号档案
+			authUtil.when(AuthUtil::getUserAccount).thenReturn(MOBILE);
+			assertEquals("黄大富", service.current().getDriverName());
+		}
 	}
 
 	@Test
-	@DisplayName("小程序用户 phone 是脱敏串时改用其 account——脱敏 phone 既查不到档案，也会把本人真实号码误判成越权")
-	void maskedUserPhoneFallsBackToAccount() {
-		MpUser user = new MpUser();
-		user.setPhone("175****12082");
-		user.setAccount("175874212082");
+	@DisplayName("没有档案时返回空数据而不是异常——没档案的登录用户看到的是空页面、也不能操作")
+	void missingProfileReturnsEmptyInsteadOfFailing() {
+		when(driverService.getOne(any(LambdaQueryWrapper.class))).thenReturn(null);
 
-		assertEquals("黄大富", currentByPhone(null, null, user).getDriverName());
+		try (MockedStatic<AuthUtil> authUtil = mockStatic(AuthUtil.class)) {
+			authUtil.when(AuthUtil::getUserId).thenReturn(USER_ID);
+			assertNull(service.current(), "查不到档案时档案为空");
+			assertNull(service.currentDriverEntity(), "查不到档案时实体为空");
+			assertTrue(service.myVehicles().isEmpty(), "查不到档案时车辆列表为空");
+		}
 	}
 
 	@Test
-	@DisplayName("传他人手机号一律拒绝——不能因为解析不到本人号码就放行，那等于允许按手机号查任意档案")
-	void otherPeoplesMobileIsRejected() {
-		assertEquals("只能查询本人司机档案", assertThrows(ServiceException.class,
-			() -> currentByPhone("13900000001", "175874212082", null)).getMessage());
+	@DisplayName("未登录直接抛异常，不能当成「没有档案」静默返回空")
+	void anonymousIsRejected() {
+		try (MockedStatic<AuthUtil> authUtil = mockStatic(AuthUtil.class)) {
+			authUtil.when(AuthUtil::getUserId).thenReturn(null);
+			assertEquals("未登录", assertThrows(ServiceException.class,
+				() -> service.current()).getMessage());
+			assertEquals("未登录", assertThrows(ServiceException.class, service::myVehicles).getMessage());
+			assertEquals("未登录", assertThrows(ServiceException.class, service::currentDriverEntity).getMessage());
+		}
 	}
 
 	// ---------------------------------------------------------------- 辅助
 
+	private Driver driver(Long id, Long userId, String driverName, String mobile) {
+		Driver driver = new Driver();
+		driver.setId(id);
+		driver.setUserId(userId);
+		driver.setDriverName(driverName);
+		driver.setMobile(mobile);
+		return driver;
+	}
+
 	/** 造一辆只关心有效期三个字段的车 */
 	private TransportVehicle vehicle(LocalDate licenseStart, LocalDate licenseEnd, Integer licenseLongTerm) {
 		TransportVehicle vehicle = new TransportVehicle();
@@ -129,13 +176,9 @@ class DriverAppServiceImplTest {
 		return vehicle;
 	}
 
-	/** 按当前登录司机的手机号跑一次「我的车辆」，取第一张卡片 */
+	/** 按当前登录司机跑一次「我的车辆」，取第一张卡片 */
 	private DriverVehicleCardVO firstCard(TransportVehicle vehicle) {
-		Driver driver = new Driver();
-		driver.setId(9001L);
-		driver.setUserId(USER_ID);
-		driver.setDriverName("韦司机");
-		driver.setMobile(MOBILE);
+		Driver driver = driver(9001L, USER_ID, "韦司机", MOBILE);
 		driver.setDrivingVehicle(vehicle.getPlateNo());
 
 		when(driverService.getOne(any(LambdaQueryWrapper.class))).thenReturn(driver);
@@ -143,39 +186,9 @@ class DriverAppServiceImplTest {
 
 		try (MockedStatic<AuthUtil> authUtil = mockStatic(AuthUtil.class)) {
 			authUtil.when(AuthUtil::getUserId).thenReturn(USER_ID);
-			// 账号本身就是手机号，resolvePhone 走这条短路分支，不再回调用户中心
-			authUtil.when(AuthUtil::getUserAccount).thenReturn(MOBILE);
 			List<DriverVehicleCardVO> cards = service.myVehicles();
 			assertEquals(1, cards.size(), "应当只返回绑定到本人的这一辆车");
 			return cards.get(0);
 		}
 	}
-
-	/**
-	 * 按给定的登录态跑一次 currentByPhone。
-	 *
-	 * @param mobileHint 前端传入的 mobile，可为 null
-	 * @param account    JWT 里的账号，可为 null
-	 * @param user       小程序用户，可为 null（表示走不到小程序用户中心）
-	 */
-	private Driver currentByPhone(String mobileHint, String account, MpUser user) {
-		IMpUserClient mpUserClient = mock(IMpUserClient.class);
-		if (user != null) {
-			when(mpUserClient.userById(USER_ID)).thenReturn(R.data(user));
-		}
-		DriverAppServiceImpl scoped = new DriverAppServiceImpl(driverService, transportVehicleService, mpUserClient);
-
-		Driver driver = new Driver();
-		driver.setId(9002L);
-		driver.setUserId(USER_ID);
-		driver.setDriverName("黄大富");
-		driver.setMobile("175874212082");
-		when(driverService.getOne(any(LambdaQueryWrapper.class))).thenReturn(driver);
-
-		try (MockedStatic<AuthUtil> authUtil = mockStatic(AuthUtil.class)) {
-			authUtil.when(AuthUtil::getUserId).thenReturn(USER_ID);
-			authUtil.when(AuthUtil::getUserAccount).thenReturn(account);
-			return scoped.currentByPhone(mobileHint);
-		}
-	}
 }

blade-service/blade-transport/src/test/java/org/springblade/transport/service/impl/DriverNodePunchPhotoTest.java

@@ -12,7 +12,6 @@ import org.mockito.MockedStatic;
 import org.springblade.core.log.exception.ServiceException;
 import org.springblade.core.secure.utils.AuthUtil;
 import org.springblade.core.tool.jackson.JsonUtil;
-import org.springblade.system.feign.IMpUserClient;
 import org.springblade.transport.mapper.ExceptionDisposalMapper;
 import org.springblade.transport.mapper.WaybillEnroutePunchMapper;
 import org.springblade.transport.mapper.WaybillNodePunchMapper;
@@ -95,7 +94,6 @@ class DriverNodePunchPhotoTest {
 		service = new DriverWaybillServiceImpl(
 			waybillService,
 			driverService,
-			mock(IMpUserClient.class),
 			mock(IProcessConfigService.class),
 			mock(ITransportVehicleService.class),
 			mock(CertificationGate.class),

blade-service/blade-transport/src/test/java/org/springblade/transport/service/impl/DriverPunchFinishFlagTest.java

@@ -7,7 +7,6 @@ import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
-import org.springblade.system.feign.IMpUserClient;
 import org.springblade.transport.mapper.ExceptionDisposalMapper;
 import org.springblade.transport.mapper.WaybillEnroutePunchMapper;
 import org.springblade.transport.mapper.WaybillNodePunchMapper;
@@ -92,7 +91,6 @@ class DriverPunchFinishFlagTest {
 		service = new DriverWaybillServiceImpl(
 			waybillService,
 			mock(IDriverService.class),
-			mock(IMpUserClient.class),
 			mock(IProcessConfigService.class),
 			mock(ITransportVehicleService.class),
 			mock(CertificationGate.class),

blade-service/blade-transport/src/test/java/org/springblade/transport/service/impl/DriverPunchNodeCardTest.java

@@ -10,7 +10,6 @@ import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.mockito.ArgumentCaptor;
 import org.springblade.core.tool.jackson.JsonUtil;
-import org.springblade.system.feign.IMpUserClient;
 import org.springblade.transport.mapper.ExceptionDisposalMapper;
 import org.springblade.transport.mapper.WaybillEnroutePunchMapper;
 import org.springblade.transport.mapper.WaybillNodePunchMapper;
@@ -87,7 +86,6 @@ class DriverPunchNodeCardTest {
 		service = new DriverWaybillServiceImpl(
 			waybillService,
 			mock(IDriverService.class),
-			mock(IMpUserClient.class),
 			mock(IProcessConfigService.class),
 			mock(ITransportVehicleService.class),
 			mock(CertificationGate.class),

blade-service/blade-transport/src/test/java/org/springblade/transport/service/impl/DriverResolveMobileTest.java

@@ -0,0 +1,131 @@
+package org.springblade.transport.service.impl;
+
+import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
+import org.apache.ibatis.builder.MapperBuilderAssistant;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springblade.system.feign.IMpUserClient;
+import org.springblade.system.feign.ISysClient;
+import org.springblade.transport.mapper.DriverMapper;
+import org.springblade.transport.pojo.entity.Driver;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * 手机号 -> 司机档案 ID 解析入口的测试。
+ * <p>
+ * 归属主键是档案 ID，手机号只是派单时的号码快照：只有租户内唯一命中才认，0 条与多条都不认。
+ * 解析结果是"能不能写归属"的判断，不是业务校验，因此任何入参都只返回 null，不抛异常。
+ */
+class DriverResolveMobileTest {
+
+	private static final String TENANT_ID = "000000";
+	private static final String MOBILE = "13800138000";
+
+	private DriverMapper driverMapper;
+	private DriverServiceImpl service;
+
+	@BeforeAll
+	static void initTableInfo() {
+		MybatisConfiguration configuration = new MybatisConfiguration();
+		MapperBuilderAssistant assistant = new MapperBuilderAssistant(configuration, "");
+		assistant.setCurrentNamespace("test");
+		TableInfoHelper.initTableInfo(assistant, Driver.class);
+	}
+
+	@BeforeEach
+	void setUp() throws Exception {
+		driverMapper = mock(DriverMapper.class);
+		service = new DriverServiceImpl(mock(IMpUserClient.class), mock(ISysClient.class));
+		inject("baseMapper", driverMapper);
+	}
+
+	@Test
+	@DisplayName("租户内唯一命中：返回档案 ID")
+	void returnsProfileIdWhenUnique() {
+		when(driverMapper.selectList(any())).thenReturn(List.of(profile(9001L)));
+
+		assertEquals(9001L, service.resolveDriverIdByMobile(TENANT_ID, MOBILE));
+	}
+
+	@Test
+	@DisplayName("租户内没有档案：返回 null")
+	void returnsNullWhenAbsent() {
+		when(driverMapper.selectList(any())).thenReturn(Collections.emptyList());
+
+		assertNull(service.resolveDriverIdByMobile(TENANT_ID, MOBILE));
+	}
+
+	@Test
+	@DisplayName("租户内多条档案（历史同号）：返回 null，不猜")
+	void returnsNullWhenMultiple() {
+		List<Driver> profiles = new ArrayList<>();
+		profiles.add(profile(9001L));
+		profiles.add(profile(9002L));
+		when(driverMapper.selectList(any())).thenReturn(profiles);
+
+		assertNull(service.resolveDriverIdByMobile(TENANT_ID, MOBILE));
+	}
+
+	@Test
+	@DisplayName("手机号为空或脱敏串：返回 null，且不查库")
+	void returnsNullWithoutQueryForBlankOrMaskedMobile() {
+		assertNull(service.resolveDriverIdByMobile(TENANT_ID, null));
+		assertNull(service.resolveDriverIdByMobile(TENANT_ID, " "));
+		assertNull(service.resolveDriverIdByMobile(TENANT_ID, "138****8000"));
+		verify(driverMapper, never()).selectList(any());
+	}
+
+	@Test
+	@DisplayName("租户为空：取当前登录租户，仍不抛异常")
+	void fallsBackToCurrentTenant() {
+		when(driverMapper.selectList(any())).thenReturn(List.of(profile(9001L)));
+
+		Long driverId = null;
+		try (org.mockito.MockedStatic<org.springblade.core.secure.utils.AuthUtil> authUtil
+			= org.mockito.Mockito.mockStatic(org.springblade.core.secure.utils.AuthUtil.class)) {
+			authUtil.when(org.springblade.core.secure.utils.AuthUtil::getTenantId).thenReturn(TENANT_ID);
+			driverId = service.resolveDriverIdByMobile(null, MOBILE);
+		}
+		assertEquals(9001L, driverId);
+	}
+
+	private Driver profile(Long id) {
+		Driver profile = new Driver();
+		profile.setId(id);
+		profile.setIsDeleted(0);
+		profile.setTenantId(TENANT_ID);
+		profile.setMobile(MOBILE);
+		return profile;
+	}
+
+	private void inject(String field, Object value) throws Exception {
+		Class<?> type = service.getClass();
+		while (type != null) {
+			try {
+				Field declared = type.getDeclaredField(field);
+				declared.setAccessible(true);
+				declared.set(service, value);
+				return;
+			} catch (NoSuchFieldException ignored) {
+				type = type.getSuperclass();
+			}
+		}
+		throw new IllegalStateException("未找到字段：" + field);
+	}
+
+}

blade-service/blade-transport/src/test/java/org/springblade/transport/service/impl/DriverSyncMobileTest.java

@@ -105,6 +105,17 @@ class DriverSyncMobileTest {
 		verify(driverMapper, never()).updateById(any(Driver.class));
 	}
 
+	@Test
+	@DisplayName("改号链路不持有运单/配载服务：换号只改档案，不回写单据上的手机号快照")
+	void phoneSyncDoesNotDependOnWaybillServices() {
+		for (Field field : DriverServiceImpl.class.getDeclaredFields()) {
+			String typeName = field.getType().getSimpleName();
+			assertFalse(typeName.contains("Waybill") || typeName.contains("LoadingManage"),
+				"改号链路引入了 " + typeName + "：换号不得顺手回写运单/配载单的司机快照，"
+					+ "否则司机档案与历史单据的归属会一起漂移");
+		}
+	}
+
 	@Test
 	@DisplayName("档案 mobile 与账号旧号不一致：不动档案，返回可读原因（不抛异常）")
 	void skipsWhenProfileMobileDiffersFromOldPhone() {

blade-service/blade-transport/src/test/java/org/springblade/transport/service/impl/DriverTripAcceptRejectTest.java

@@ -14,7 +14,6 @@ import org.mockito.MockedStatic;
 import org.springblade.core.log.exception.ServiceException;
 import org.springblade.core.secure.BladeUser;
 import org.springblade.core.secure.utils.AuthUtil;
-import org.springblade.system.feign.IMpUserClient;
 import org.springblade.transport.mapper.ExceptionDisposalMapper;
 import org.springblade.transport.mapper.WaybillEnroutePunchMapper;
 import org.springblade.transport.mapper.WaybillNodePunchMapper;
@@ -57,7 +56,10 @@ class DriverTripAcceptRejectTest {
 
 	private static final Long USER_ID = 7401L;
 	private static final Long DRIVER_ID = 9001L;
-	private static final String PHONE = "17587421208";
+	/** 派单时落在运次上的号码快照。 */
+	private static final String SNAPSHOT_PHONE = "17587421208";
+	/** 司机改号后档案与登录账号上的号码。 */
+	private static final String CURRENT_PHONE = "17687421208";
 	private static final String TRIP_ID = "2101146192739459074";
 	private static final Long PENDING_ID = 2101144166395699202L;
 	private static final Long SECOND_ID = 2101145869819994113L;
@@ -85,7 +87,6 @@ class DriverTripAcceptRejectTest {
 		service = new DriverWaybillServiceImpl(
 			waybillService,
 			driverService,
-			mock(IMpUserClient.class),
 			mock(IProcessConfigService.class),
 			mock(ITransportVehicleService.class),
 			certificationGate,
@@ -121,7 +122,8 @@ class DriverTripAcceptRejectTest {
 			"两张子运单与接单司机一起下发：" + capturedUpdateParams());
 		assertTrue(capturedWhereSql().contains("(id IN ("), capturedWhereSql());
 		assertEquals(TRIP_ID, capturedQuery().getTripId());
-		assertEquals(PHONE, capturedQuery().getDriverPhone(), "归属仍按司机手机号收口");
+		assertEquals(DRIVER_ID, capturedQuery().getDriverId(),
+			"运次查询按司机档案 ID 收口：手机号换了也认得出本人");
 	}
 
 	@Test
@@ -340,6 +342,16 @@ class DriverTripAcceptRejectTest {
 		verify(waybillService, never()).update(any());
 	}
 
+	@Test
+	@DisplayName("没有司机档案的账号不能运次接单：不按手机号回退、不提供代报")
+	void tripAcceptWithoutDriverProfileIsRefused() {
+		when(driverService.getOne(any())).thenReturn(null);
+
+		assertEquals("未找到当前登录司机档案", assertThrows(ServiceException.class,
+			() -> runAsDriver(() -> service.tripAccept(TRIP_ID))).getMessage());
+		verify(waybillService, never()).update(any());
+	}
+
 	// ------------------------------------------------------------ 夹具
 
 	private <T> T runAsDriver(Supplier<T> action) {
@@ -373,7 +385,7 @@ class DriverTripAcceptRejectTest {
 	private void stubTrip(TripVO.TripWaybillVO[] leading, TripVO.TripWaybillVO... children) {
 		TripVO trip = new TripVO();
 		trip.setId(TRIP_ID);
-		trip.setDriverPhone(PHONE);
+		trip.setDriverPhone(SNAPSHOT_PHONE);
 		List<TripVO.TripWaybillVO> all = new java.util.ArrayList<>(List.of(leading));
 		all.addAll(List.of(children));
 		trip.setWaybills(all);
@@ -400,7 +412,7 @@ class DriverTripAcceptRejectTest {
 		driver.setUserId(USER_ID);
 		driver.setDriverName("黄宇富");
 		driver.setDrivingVehicle("桂A32523");
-		driver.setMobile(PHONE);
+		driver.setMobile(CURRENT_PHONE);
 		return driver;
 	}
 

blade-service/blade-transport/src/test/java/org/springblade/transport/service/impl/DriverTripCardTest.java

@@ -10,7 +10,6 @@ import org.mockito.ArgumentCaptor;
 import org.mockito.MockedStatic;
 import org.springblade.core.log.exception.ServiceException;
 import org.springblade.core.secure.utils.AuthUtil;
-import org.springblade.system.feign.IMpUserClient;
 import org.springblade.transport.mapper.ExceptionDisposalMapper;
 import org.springblade.transport.mapper.WaybillEnroutePunchMapper;
 import org.springblade.transport.mapper.WaybillNodePunchMapper;
@@ -74,7 +73,6 @@ class DriverTripCardTest {
 
 	private IWaybillService waybillService;
 	private IDriverService driverService;
-	private IMpUserClient mpUserClient;
 	private ITripQueryService tripQueryService;
 	private WaybillEnroutePunchMapper enroutePunchMapper;
 	private WaybillNodePunchMapper nodePunchMapper;
@@ -94,14 +92,12 @@ class DriverTripCardTest {
 	void setUp() {
 		waybillService = mock(IWaybillService.class);
 		driverService = mock(IDriverService.class);
-		mpUserClient = mock(IMpUserClient.class);
 		tripQueryService = mock(ITripQueryService.class);
 		enroutePunchMapper = mock(WaybillEnroutePunchMapper.class);
 		nodePunchMapper = mock(WaybillNodePunchMapper.class);
 		service = new DriverWaybillServiceImpl(
 			waybillService,
 			driverService,
-			mpUserClient,
 			mock(IProcessConfigService.class),
 			mock(ITransportVehicleService.class),
 			mock(CertificationGate.class),
@@ -125,7 +121,7 @@ class DriverTripCardTest {
 		IPage<DriverWaybillCardVO> page = runAsDriver(() -> service.tripPage(1, 10, null, null));
 
 		given = capturedQuery();
-		assertEquals(PHONE, given.getDriverPhone());
+		assertEquals(DRIVER_ID, given.getDriverId(), "运次列表按司机档案 ID 收口");
 		assertEquals(1, given.getCurrent());
 		assertEquals(10, given.getSize(), "一页 10 条即 10 个运次");
 		assertNull(given.getStatus());
@@ -334,10 +330,9 @@ class DriverTripCardTest {
 	}
 
 	@Test
-	@DisplayName("收口缺失时不放行：空页、零统计、当前任务为空，且不查运次")
-	void missingPhoneIsRefused() {
+	@DisplayName("收口缺失时不放行：没有司机档案就空页、零统计、当前任务为空，且不查运次")
+	void missingDriverProfileIsRefused() {
 		when(driverService.getOne(any())).thenReturn(null);
-		when(mpUserClient.userById(any())).thenReturn(null);
 
 		IPage<DriverWaybillCardVO> page = runAsDriver(() -> service.tripPage(null, null, null, null));
 		DriverWaybillPreviewVO preview = runAsDriver(() -> service.tripPendingPreview(null));

blade-service/blade-transport/src/test/java/org/springblade/transport/service/impl/DriverWaybillAutoCompleteTest.java

@@ -11,7 +11,6 @@ import org.mockito.ArgumentCaptor;
 import org.mockito.MockedStatic;
 import org.springblade.core.log.exception.ServiceException;
 import org.springblade.core.secure.utils.AuthUtil;
-import org.springblade.system.feign.IMpUserClient;
 import org.springblade.transport.mapper.ExceptionDisposalMapper;
 import org.springblade.transport.mapper.WaybillEnroutePunchMapper;
 import org.springblade.transport.mapper.WaybillNodePunchMapper;
@@ -116,7 +115,6 @@ class DriverWaybillAutoCompleteTest {
 		service = new DriverWaybillServiceImpl(
 			waybillService,
 			driverService,
-			mock(IMpUserClient.class),
 			mock(IProcessConfigService.class),
 			mock(ITransportVehicleService.class),
 			mock(CertificationGate.class),

blade-service/blade-transport/src/test/java/org/springblade/transport/service/impl/DriverWaybillCardLocationTest.java

@@ -7,7 +7,6 @@ import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
-import org.springblade.system.feign.IMpUserClient;
 import org.springblade.transport.mapper.ExceptionDisposalMapper;
 import org.springblade.transport.mapper.WaybillEnroutePunchMapper;
 import org.springblade.transport.mapper.WaybillNodePunchMapper;
@@ -73,7 +72,6 @@ class DriverWaybillCardLocationTest {
 		service = new DriverWaybillServiceImpl(
 			waybillService,
 			mock(IDriverService.class),
-			mock(IMpUserClient.class),
 			mock(IProcessConfigService.class),
 			mock(ITransportVehicleService.class),
 			mock(CertificationGate.class),

blade-service/blade-transport/src/test/java/org/springblade/transport/service/impl/DriverWaybillNodePunchTest.java

@@ -7,7 +7,6 @@ import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
-import org.springblade.system.feign.IMpUserClient;
 import org.springblade.transport.mapper.ExceptionDisposalMapper;
 import org.springblade.transport.mapper.WaybillEnroutePunchMapper;
 import org.springblade.transport.mapper.WaybillNodePunchMapper;
@@ -55,7 +54,6 @@ class DriverWaybillNodePunchTest {
 		service = new DriverWaybillServiceImpl(
 			mock(IWaybillService.class),
 			mock(IDriverService.class),
-			mock(IMpUserClient.class),
 			mock(IProcessConfigService.class),
 			mock(ITransportVehicleService.class),
 			mock(CertificationGate.class),

blade-service/blade-transport/src/test/java/org/springblade/transport/service/impl/DriverWaybillOwnershipTest.java

@@ -12,7 +12,6 @@ import org.mockito.ArgumentCaptor;
 import org.mockito.MockedStatic;
 import org.springblade.core.log.exception.ServiceException;
 import org.springblade.core.secure.utils.AuthUtil;
-import org.springblade.system.feign.IMpUserClient;
 import org.springblade.transport.mapper.ExceptionDisposalMapper;
 import org.springblade.transport.mapper.WaybillEnroutePunchMapper;
 import org.springblade.transport.mapper.WaybillNodePunchMapper;
@@ -27,26 +26,34 @@ import org.springblade.transport.support.CertificationGate;
 
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.mockStatic;
 import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 /**
  * 司机对运单的归属校验（异常上报等按运单操作的前置条件）。
  * <p>
- * 口径：当前用户手机号匹配运单 {@code driverPhone}。
+ * 口径：登录用户按 {@code user_id} 解析到司机档案，运单归属键是运单上的 {@code driver_id}；
+ * {@code driver_phone} 只是派单快照，不参与判定。
  * 管理端与调度员账号没有司机档案，会停在这里，这是刻意的：不提供代报。
  */
 class DriverWaybillOwnershipTest {
 
 	private static final Long WAYBILL_ID = 5301L;
 	private static final Long USER_ID = 7001L;
-	private static final String PHONE = "13800138000";
+	private static final Long DRIVER_ID = 9001L;
+	private static final Long OTHER_DRIVER_ID = 9002L;
+	/** 派单时落在运单上的号码快照。 */
+	private static final String SNAPSHOT_PHONE = "13800138000";
+	/** 司机改号后档案与登录账号上的号码。 */
+	private static final String CURRENT_PHONE = "13900139000";
 
 	private IDriverService driverService;
 	private IWaybillService waybillService;
@@ -58,6 +65,7 @@ class DriverWaybillOwnershipTest {
 		MapperBuilderAssistant assistant = new MapperBuilderAssistant(configuration, "");
 		assistant.setCurrentNamespace("test");
 		TableInfoHelper.initTableInfo(assistant, Waybill.class);
+		TableInfoHelper.initTableInfo(assistant, Driver.class);
 	}
 
 	@BeforeEach
@@ -67,7 +75,6 @@ class DriverWaybillOwnershipTest {
 		service = new DriverWaybillServiceImpl(
 			waybillService,
 			driverService,
-			mock(IMpUserClient.class),
 			mock(IProcessConfigService.class),
 			mock(ITransportVehicleService.class),
 			mock(CertificationGate.class),
@@ -91,33 +98,26 @@ class DriverWaybillOwnershipTest {
 	}
 
 	@Test
-	@DisplayName("司机档案与登录态都没有手机号时被拒")
-	void withoutPhoneIsRejected() {
-		Driver driver = driver(null);
-		when(driverService.getOne(any())).thenReturn(driver);
+	@DisplayName("司机档案只按登录用户 ID 解析，不按手机号回退")
+	void driverProfileResolvedByUserIdOnly() {
+		when(driverService.getOne(any())).thenReturn(driver(CURRENT_PHONE));
+		when(waybillService.getOne(any())).thenReturn(waybill());
 
-		ServiceException exception = assertThrows(ServiceException.class,
-			() -> runOwnershipCheck(WAYBILL_ID));
+		assertDoesNotThrow(() -> runOwnershipCheck(WAYBILL_ID));
 
-		assertEquals("当前用户手机号为空，无法查找运单", exception.getMessage());
+		ArgumentCaptor<LambdaQueryWrapper<Driver>> captor = ArgumentCaptor.forClass(LambdaQueryWrapper.class);
+		verify(driverService, times(1)).getOne(captor.capture());
+		LambdaQueryWrapper<Driver> wrapper = captor.getValue();
+		assertTrue(wrapper.getTargetSql().contains("user_id"),
+			"司机档案必须按登录用户 ID 解析：" + wrapper.getTargetSql());
+		assertFalse(wrapper.getTargetSql().contains("mobile"),
+			"司机档案不允许再按手机号回退：" + wrapper.getTargetSql());
 	}
 
 	@Test
-	@DisplayName("运单司机手机号与当前用户不一致时被拒")
-	void waybillOfAnotherPhoneIsRejected() {
-		when(driverService.getOne(any())).thenReturn(driver(PHONE));
-		when(waybillService.getOne(any())).thenReturn(null);
-
-		ServiceException exception = assertThrows(ServiceException.class,
-			() -> runOwnershipCheck(WAYBILL_ID));
-
-		assertEquals("运单不存在或无权操作", exception.getMessage());
-	}
-
-	@Test
-	@DisplayName("本人手机号运单放行，且查询确实按司机手机号收敛")
-	void ownWaybillPasses() {
-		when(driverService.getOne(any())).thenReturn(driver(PHONE));
+	@DisplayName("司机改号后本人运单仍放行，归属只认 driver_id")
+	void ownWaybillPassesAfterNumberChange() {
+		when(driverService.getOne(any())).thenReturn(driver(CURRENT_PHONE));
 		when(waybillService.getOne(any())).thenReturn(waybill());
 
 		assertDoesNotThrow(() -> runOwnershipCheck(WAYBILL_ID));
@@ -125,17 +125,55 @@ class DriverWaybillOwnershipTest {
 		ArgumentCaptor<LambdaQueryWrapper<Waybill>> captor = ArgumentCaptor.forClass(LambdaQueryWrapper.class);
 		verify(waybillService).getOne(captor.capture());
 		LambdaQueryWrapper<Waybill> wrapper = captor.getValue();
-		assertTrue(wrapper.getTargetSql().contains("driver_phone"),
-			"归属查询必须落在运单司机手机号上：" + wrapper.getTargetSql());
-		assertTrue(wrapper.getParamNameValuePairs().values().stream()
-				.anyMatch(PHONE::equals),
-			"归属查询必须带上当前用户手机号：" + wrapper.getParamNameValuePairs());
+		// 护栏：归属查询必须落在运单 driver_id 上，不能再出现手机号比较，否则改号即失效。
+		assertTrue(wrapper.getTargetSql().contains("driver_id"),
+			"归属查询必须落在运单司机档案 ID 上：" + wrapper.getTargetSql());
+		assertFalse(wrapper.getTargetSql().contains("driver_phone"),
+			"归属查询不能再比较运单司机手机号快照：" + wrapper.getTargetSql());
+		assertTrue(wrapper.getParamNameValuePairs().values().contains(DRIVER_ID),
+			"归属查询必须带上当前司机档案 ID：" + wrapper.getParamNameValuePairs());
+		assertFalse(wrapper.getParamNameValuePairs().values().contains(SNAPSHOT_PHONE),
+			"快照号不参与归属判定：" + wrapper.getParamNameValuePairs());
+		assertFalse(wrapper.getParamNameValuePairs().values().contains(CURRENT_PHONE),
+			"档案手机号不参与归属判定：" + wrapper.getParamNameValuePairs());
+	}
+
+	@Test
+	@DisplayName("同号换人：同手机号但不同档案看不到对方的运单")
+	void waybillOwnedByAnotherDriverWithSamePhoneIsRejected() {
+		when(driverService.getOne(any())).thenReturn(driver(CURRENT_PHONE));
+		// 库里存在该运单，但归属档案是另一个同号档案，按 driver_id 收口后查不到。
+		when(waybillService.getOne(any())).thenReturn(null);
+
+		ServiceException exception = assertThrows(ServiceException.class,
+			() -> runOwnershipCheck(WAYBILL_ID));
+
+		assertEquals("运单不存在或无权操作", exception.getMessage());
+
+		ArgumentCaptor<LambdaQueryWrapper<Waybill>> captor = ArgumentCaptor.forClass(LambdaQueryWrapper.class);
+		verify(waybillService).getOne(captor.capture());
+		LambdaQueryWrapper<Waybill> wrapper = captor.getValue();
+		// 参数槽由 SQL 片段构建时填充：不先取一次片段，参数表是空的
+		wrapper.getTargetSql();
+		assertTrue(wrapper.getParamNameValuePairs().values().contains(DRIVER_ID),
+			"收口条件必须是当前档案 ID：" + wrapper.getParamNameValuePairs());
+		assertFalse(wrapper.getParamNameValuePairs().values().contains(OTHER_DRIVER_ID),
+			"不能把别人的档案 ID 当查询条件：" + wrapper.getParamNameValuePairs());
+	}
+
+	@Test
+	@DisplayName("司机档案没有手机号也能按档案 ID 认领自己的运单")
+	void profileWithoutPhoneStillOwnsByDriverId() {
+		when(driverService.getOne(any())).thenReturn(driver(null));
+		when(waybillService.getOne(any())).thenReturn(waybill());
+
+		assertDoesNotThrow(() -> runOwnershipCheck(WAYBILL_ID));
 	}
 
 	@Test
 	@DisplayName("运单ID为空时被拒")
 	void withoutWaybillIdIsRejected() {
-		when(driverService.getOne(any())).thenReturn(driver(PHONE));
+		when(driverService.getOne(any())).thenReturn(driver(CURRENT_PHONE));
 
 		ServiceException exception = assertThrows(ServiceException.class,
 			() -> runOwnershipCheck(null));
@@ -148,14 +186,14 @@ class DriverWaybillOwnershipTest {
 	private void runOwnershipCheck(Long waybillId) {
 		try (MockedStatic<AuthUtil> authUtil = mockStatic(AuthUtil.class)) {
 			authUtil.when(AuthUtil::getUserId).thenReturn(USER_ID);
-			authUtil.when(AuthUtil::getUserAccount).thenReturn(PHONE);
+			authUtil.when(AuthUtil::getUserAccount).thenReturn(CURRENT_PHONE);
 			service.assertCurrentDriverOwnsWaybill(waybillId);
 		}
 	}
 
 	private Driver driver(String mobile) {
 		Driver driver = new Driver();
-		driver.setId(9001L);
+		driver.setId(DRIVER_ID);
 		driver.setUserId(USER_ID);
 		driver.setDriverName("韦司机");
 		driver.setMobile(mobile);
@@ -166,7 +204,8 @@ class DriverWaybillOwnershipTest {
 		Waybill waybill = new Waybill();
 		waybill.setId(WAYBILL_ID);
 		waybill.setWaybillNo("YD202610070001");
-		waybill.setDriverPhone(PHONE);
+		waybill.setDriverId(DRIVER_ID);
+		waybill.setDriverPhone(SNAPSHOT_PHONE);
 		waybill.setIsDeleted(0);
 		return waybill;
 	}

blade-service/blade-transport/src/test/java/org/springblade/transport/service/impl/DriverWaybillRejectDetachTest.java

@@ -15,7 +15,6 @@ import org.mockito.ArgumentMatchers;
 import org.mockito.MockedStatic;
 import org.springblade.core.log.exception.ServiceException;
 import org.springblade.core.secure.utils.AuthUtil;
-import org.springblade.system.feign.IMpUserClient;
 import org.springblade.transport.mapper.ExceptionDisposalMapper;
 import org.springblade.transport.mapper.WaybillEnroutePunchMapper;
 import org.springblade.transport.mapper.WaybillNodePunchMapper;
@@ -34,6 +33,7 @@ import org.springblade.transport.support.CertificationGate;
 import java.util.List;
 import java.util.function.Supplier;
 
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -58,7 +58,10 @@ class DriverWaybillRejectDetachTest {
 	private static final Long USER_ID = 7401L;
 	private static final Long DRIVER_ID = 9001L;
 	private static final String PLATE = "沪AE31312";
-	private static final String PHONE = "13800138002";
+	/** 派单时落在运单上的号码快照。 */
+	private static final String SNAPSHOT_PHONE = "13800138002";
+	/** 司机改号后档案与登录账号上的号码。 */
+	private static final String CURRENT_PHONE = "13900139002";
 	private static final Long REJECTED_ID = 7201L;
 
 	private IDriverService driverService;
@@ -83,7 +86,6 @@ class DriverWaybillRejectDetachTest {
 		service = new DriverWaybillServiceImpl(
 			waybillService,
 			driverService,
-			mock(IMpUserClient.class),
 			mock(IProcessConfigService.class),
 			mock(ITransportVehicleService.class),
 			certificationGate,
@@ -155,6 +157,29 @@ class DriverWaybillRejectDetachTest {
 		assertEquals(2, page.getRecords().size());
 	}
 
+	@Test
+	@DisplayName("司机改号后运单仍可见，卡片仍展示派单时的号码快照")
+	void numberChangeKeepsWaybillsVisible() {
+		// 同一个档案：档案与登录账号已换成新号，运单快照还是派单时的旧号
+		when(waybillService.list(ArgumentMatchers.<com.baomidou.mybatisplus.core.conditions.Wrapper<Waybill>>any()))
+			.thenReturn(List.of(waybill(7202L, "YD-20261001-0002", "pending", "pending")));
+
+		IPage<DriverWaybillCardVO> page = runAsDriver(() -> service.page(1, 10, null, null));
+
+		assertEquals(1, page.getTotal(), "改号不影响本人运单的可见性");
+		assertEquals(SNAPSHOT_PHONE, page.getRecords().get(0).getDriverPhone(),
+			"卡片展示的仍是运单上的号码快照，不改成本人新号");
+	}
+
+	@Test
+	@DisplayName("重新派回后运单恢复可见：归属看新的 driver_id，不看历史拒单")
+	void reassignedWaybillBecomesVisibleAgain() {
+		when(waybillService.getOne(any()))
+			.thenReturn(waybill(REJECTED_ID, "YD-20261010-0001", "pending", "pending"));
+
+		assertDoesNotThrow(() -> runAsDriver(() -> service.detail(REJECTED_ID)));
+	}
+
 	@Test
 	@DisplayName("已拒单运单的详情不可达：取单条件已把它挡住")
 	void detailOfRejectedIsUnreachable() {
@@ -218,7 +243,7 @@ class DriverWaybillRejectDetachTest {
 		driver.setUserId(USER_ID);
 		driver.setDriverName("黄大富");
 		driver.setDrivingVehicle(PLATE);
-		driver.setMobile(PHONE);
+		driver.setMobile(CURRENT_PHONE);
 		return driver;
 	}
 
@@ -231,7 +256,8 @@ class DriverWaybillRejectDetachTest {
 		waybill.setId(id);
 		waybill.setWaybillNo(no);
 		waybill.setVehicleNo(PLATE);
-		waybill.setDriverPhone(PHONE);
+		waybill.setDriverId(DRIVER_ID);
+		waybill.setDriverPhone(SNAPSHOT_PHONE);
 		waybill.setBusinessStatus(businessStatus);
 		waybill.setDriverAcceptStatus(acceptStatus);
 		waybill.setIsDeleted(0);

blade-service/blade-transport/src/test/java/org/springblade/transport/service/impl/DriverWaybillTabStatusTest.java

@@ -12,7 +12,6 @@ import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.mockito.MockedStatic;
 import org.springblade.core.secure.utils.AuthUtil;
-import org.springblade.system.feign.IMpUserClient;
 import org.springblade.transport.mapper.ExceptionDisposalMapper;
 import org.springblade.transport.mapper.WaybillEnroutePunchMapper;
 import org.springblade.transport.mapper.WaybillNodePunchMapper;
@@ -35,6 +34,7 @@ import java.util.List;
 import java.util.function.Supplier;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
@@ -51,8 +51,12 @@ class DriverWaybillTabStatusTest {
 
 	private static final Long WAYBILL_ID = 5901L;
 	private static final Long USER_ID = 7001L;
+	private static final Long DRIVER_ID = 9001L;
 	private static final String PLATE = "桂AAW3256";
-	private static final String PHONE = "13800138002";
+	/** 派单时落在运单上的号码快照。 */
+	private static final String SNAPSHOT_PHONE = "13800138002";
+	/** 司机改号后档案与登录账号上的号码。 */
+	private static final String CURRENT_PHONE = "13900139002";
 
 	private IWaybillService waybillService;
 	private IDriverService driverService;
@@ -81,7 +85,6 @@ class DriverWaybillTabStatusTest {
 		service = new DriverWaybillServiceImpl(
 			waybillService,
 			driverService,
-			mock(IMpUserClient.class),
 			mock(IProcessConfigService.class),
 			mock(ITransportVehicleService.class),
 			mock(CertificationGate.class),
@@ -141,6 +144,27 @@ class DriverWaybillTabStatusTest {
 		assertEquals(1, counts.getAll());
 	}
 
+	@Test
+	@DisplayName("司机改号后三档计数不变，计数查询按 driver_id 收口")
+	void tabCountsAfterNumberChangeScopedByDriverId() {
+		DriverWaybillTabCountsVO counts = runAsDriver(service::tabCounts);
+
+		assertEquals(1, counts.getDoing(), "改号不影响本人运单的分档");
+		assertEquals(1, counts.getAll());
+
+		LambdaQueryWrapper<Waybill> wrapper = firstQueriedWrapper();
+		// 护栏：计数查询必须落在运单 driver_id 上；比对手机号的话，改号后司机的数字会清零
+		String sql = wrapper.getTargetSql();
+		assertTrue(sql.contains("driver_id"), "计数查询必须按司机档案 ID 收口：" + sql);
+		assertFalse(sql.contains("driver_phone"), "计数查询不能再比较运单手机号快照：" + sql);
+		assertTrue(wrapper.getParamNameValuePairs().values().contains(DRIVER_ID),
+			"计数查询必须带上当前司机档案 ID：" + wrapper.getParamNameValuePairs());
+		assertFalse(wrapper.getParamNameValuePairs().values().contains(SNAPSHOT_PHONE),
+			"快照号不参与计数：" + wrapper.getParamNameValuePairs());
+		assertFalse(wrapper.getParamNameValuePairs().values().contains(CURRENT_PHONE),
+			"档案手机号不参与计数：" + wrapper.getParamNameValuePairs());
+	}
+
 	// ------------------------------------------------------------ 夹具
 
 	private <T> T runAsDriver(Supplier<T> action) {
@@ -167,6 +191,15 @@ class DriverWaybillTabStatusTest {
 		return statuses;
 	}
 
+	@SuppressWarnings("unchecked")
+	private LambdaQueryWrapper<Waybill> firstQueriedWrapper() {
+		assertEquals(1, queried.size(), "一次列表查询");
+		LambdaQueryWrapper<Waybill> wrapper = (LambdaQueryWrapper<Waybill>) queried.get(0);
+		// 参数槽由 SQL 片段构建时填充：不先取一次片段，参数表是空的
+		wrapper.getSqlSegment();
+		return wrapper;
+	}
+
 	@SuppressWarnings("unchecked")
 	private static Wrapper<Waybill> anyWrapper() {
 		return org.mockito.ArgumentMatchers.<Wrapper<Waybill>>any();
@@ -177,7 +210,8 @@ class DriverWaybillTabStatusTest {
 		waybill.setId(WAYBILL_ID);
 		waybill.setWaybillNo("YD202610080002");
 		waybill.setVehicleNo(PLATE);
-		waybill.setDriverPhone(PHONE);
+		waybill.setDriverId(DRIVER_ID);
+		waybill.setDriverPhone(SNAPSHOT_PHONE);
 		waybill.setBusinessStatus(WaybillProcessSupport.STATUS_PENDING_RETURN_CONFIRM);
 		waybill.setIsDeleted(0);
 		return waybill;
@@ -185,10 +219,10 @@ class DriverWaybillTabStatusTest {
 
 	private Driver driver() {
 		Driver driver = new Driver();
-		driver.setId(9001L);
+		driver.setId(DRIVER_ID);
 		driver.setUserId(USER_ID);
 		driver.setDrivingVehicle(PLATE);
-		driver.setMobile(PHONE);
+		driver.setMobile(CURRENT_PHONE);
 		return driver;
 	}
 

blade-service/blade-transport/src/test/java/org/springblade/transport/service/impl/LoadingManageAdmissionTest.java

@@ -19,6 +19,7 @@ import org.springblade.transport.pojo.entity.ContractManage;
 import org.springblade.transport.pojo.entity.LoadingManage;
 import org.springblade.transport.pojo.entity.Waybill;
 import org.springblade.transport.service.IContractManageService;
+import org.springblade.transport.service.IDriverService;
 
 import java.lang.reflect.Field;
 import java.util.List;
@@ -81,6 +82,7 @@ class LoadingManageAdmissionTest {
 		inject("baseMapper", loadingManageMapper);
 		inject("waybillMapper", waybillMapper);
 		inject("contractManageService", contractManageService);
+		inject("driverService", mock(IDriverService.class));
 		authUtil = mockStatic(AuthUtil.class);
 		authUtil.when(AuthUtil::getDeptId).thenReturn(String.valueOf(DEPT_ID));
 	}

blade-service/blade-transport/src/test/java/org/springblade/transport/service/impl/LoadingManageChildStatusWriteTest.java

@@ -1,5 +1,7 @@
 package org.springblade.transport.service.impl;
 
+import ch.qos.logback.classic.Level;
+import ch.qos.logback.classic.spi.ILoggingEvent;
 import com.baomidou.mybatisplus.core.MybatisConfiguration;
 import com.baomidou.mybatisplus.core.conditions.Wrapper;
 import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
@@ -15,16 +17,20 @@ import org.mockito.ArgumentMatchers;
 import org.mockito.MockedStatic;
 import org.springblade.core.secure.utils.AuthUtil;
 import org.springblade.core.tool.jackson.JsonUtil;
+import org.springblade.transport.mapper.LoadingManageMapper;
 import org.springblade.transport.mapper.WaybillMapper;
 import org.springblade.transport.pojo.entity.LoadingManage;
 import org.springblade.transport.pojo.entity.ProcessConfig;
 import org.springblade.transport.pojo.entity.Waybill;
 import org.springblade.transport.service.IContractManageService;
+import org.springblade.transport.service.IDriverService;
 import org.springblade.transport.service.IProcessConfigService;
 import org.springblade.transport.service.IReceivablePayableDetailService;
+import org.springblade.transport.support.LogCapture;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
+import java.util.regex.Matcher;
 import java.util.Arrays;
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -32,9 +38,11 @@ import java.util.Map;
 import java.util.Set;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.atLeastOnce;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
@@ -60,6 +68,12 @@ class LoadingManageChildStatusWriteTest {
 	private static final String LOADING_NO = "PZ-20261018-001";
 	private static final Long LOADING_ID = 1800000000000000001L;
 	private static final String DRIVER_PHONE = "13800138000";
+	private static final String TENANT_ID = "000000";
+	private static final Long RESOLVED_DRIVER_ID = 9321L;
+	private static final Long MANUAL_DRIVER_ID = 7001L;
+	private static final Long OTHER_PROFILE_ID = 8888L;
+	private static final String OTHER_DRIVER_PHONE = "13900139000";
+	private static final Long SOURCE_LOADING_ID = 1800000000000000002L;
 
 	private static final Long NEED_ACCEPT_WAYBILL_ID = 3101L;
 	private static final Long NO_ACCEPT_WAYBILL_ID = 3102L;
@@ -80,6 +94,7 @@ class LoadingManageChildStatusWriteTest {
 		"carrier_type",
 		"carrier_contract_id",
 		"carrier_name",
+		"driver_id",
 		"driver_name",
 		"driver_phone",
 		"vehicle_no",
@@ -104,6 +119,8 @@ class LoadingManageChildStatusWriteTest {
 	private IProcessConfigService processConfigService;
 	private IContractManageService contractManageService;
 	private IReceivablePayableDetailService receivablePayableDetailService;
+	private IDriverService driverService;
+	private LoadingManageMapper loadingManageMapper;
 	private LoadingManageServiceImpl service;
 	private MockedStatic<AuthUtil> authUtil;
 
@@ -115,6 +132,7 @@ class LoadingManageChildStatusWriteTest {
 		assistant.setCurrentNamespace("test");
 		TableInfoHelper.initTableInfo(assistant, Waybill.class);
 		TableInfoHelper.initTableInfo(assistant, ProcessConfig.class);
+		TableInfoHelper.initTableInfo(assistant, LoadingManage.class);
 	}
 
 	@BeforeEach
@@ -123,14 +141,19 @@ class LoadingManageChildStatusWriteTest {
 		processConfigService = mock(IProcessConfigService.class);
 		contractManageService = mock(IContractManageService.class);
 		receivablePayableDetailService = mock(IReceivablePayableDetailService.class);
+		driverService = mock(IDriverService.class);
+		loadingManageMapper = mock(LoadingManageMapper.class);
 		service = spy(new LoadingManageServiceImpl());
 		inject(service, "waybillMapper", waybillMapper);
 		inject(service, "processConfigService", processConfigService);
 		inject(service, "contractManageService", contractManageService);
 		inject(service, "receivablePayableDetailService", receivablePayableDetailService);
+		inject(service, "driverService", driverService);
+		inject(service, "baseMapper", loadingManageMapper);
 		doReturnTrue(service);
 		authUtil = mockStatic(AuthUtil.class);
 		authUtil.when(AuthUtil::getDeptId).thenReturn(DEPT_ID);
+		authUtil.when(AuthUtil::getTenantId).thenReturn(TENANT_ID);
 	}
 
 	@AfterEach
@@ -309,6 +332,179 @@ class LoadingManageChildStatusWriteTest {
 		verify(processConfigService, never()).list(ArgumentMatchers.<Wrapper<ProcessConfig>>any());
 	}
 
+	@Test
+	@DisplayName("提交配载单：按手机号解析到档案 ID 时，配载单与子单一起记住归属")
+	void submitWritesResolvedDriverId() {
+		stubWaybills(waybill(NO_ACCEPT_WAYBILL_ID, NO_ACCEPT_PROJECT_ID));
+		stubConfigs(config(NO_ACCEPT_PROJECT_ID, NO_ACCEPT_JSON));
+		when(driverService.resolveDriverIdByMobile(any(), eq(DRIVER_PHONE))).thenReturn(RESOLVED_DRIVER_ID);
+
+		assertTrue(service.submit(loadingForm(NO_ACCEPT_WAYBILL_ID)));
+
+		assertEquals(RESOLVED_DRIVER_ID, capturedLoading().getDriverId());
+		assertEquals(RESOLVED_DRIVER_ID, statusSyncUpdates().get(0).setValue("driver_id"),
+			"子单必须与配载单写同一个归属，否则司机端按归属查不到这张票");
+	}
+
+	@Test
+	@DisplayName("解析不到档案（承运商司机）：提交照常成功，归属留空")
+	void submitAllowsUnresolvedDriverId() {
+		stubWaybills(waybill(NO_ACCEPT_WAYBILL_ID, NO_ACCEPT_PROJECT_ID));
+		stubConfigs(config(NO_ACCEPT_PROJECT_ID, NO_ACCEPT_JSON));
+		when(driverService.resolveDriverIdByMobile(any(), eq(DRIVER_PHONE))).thenReturn(null);
+
+		assertTrue(service.submit(loadingForm(NO_ACCEPT_WAYBILL_ID)));
+
+		assertNull(capturedLoading().getDriverId());
+		assertNull(statusSyncUpdates().get(0).setValue("driver_id"));
+	}
+
+	@Test
+	@DisplayName("进行中编辑保留的子单：任务字段更新也带上司机归属，改派后不留旧值")
+	void runningEditCarriesDriverIdToKeptWaybills() {
+		LoadingManage record = runningRecord();
+		stubLoadingRecord(record);
+		stubWaybills(waybill(NEED_ACCEPT_WAYBILL_ID, NEED_ACCEPT_PROJECT_ID));
+		when(driverService.resolveDriverIdByMobile(any(), eq(DRIVER_PHONE))).thenReturn(RESOLVED_DRIVER_ID);
+
+		assertTrue(service.submit(editForm(LOADING_ID, NEED_ACCEPT_WAYBILL_ID)));
+
+		CapturedUpdate taskUpdate = waybillUpdates().stream()
+			.filter(update -> update.columns().contains("driver_name"))
+			.findFirst()
+			.orElseThrow();
+		assertEquals(List.of(NEED_ACCEPT_WAYBILL_ID), taskUpdate.whereIds());
+		assertEquals(RESOLVED_DRIVER_ID, taskUpdate.setValue("driver_id"));
+	}
+
+	@Test
+	@DisplayName("复制配载单：沿用源单的司机归属，不按手机号重解析覆盖")
+	void copyKeepsSourceDriverId() {
+		LoadingManage source = copySource();
+		source.setDriverId(555L);
+		stubCopyDependencies(source);
+
+		service.copy(SOURCE_LOADING_ID);
+
+		assertEquals(555L, capturedSaved().getDriverId());
+	}
+
+	@Test
+	@DisplayName("复制配载单：源单没有归属时，用手机号解析出的档案 ID")
+	void copyFallsBackToResolvedDriverId() {
+		LoadingManage source = copySource();
+		stubCopyDependencies(source);
+		when(driverService.resolveDriverIdByMobile(any(), eq(DRIVER_PHONE))).thenReturn(RESOLVED_DRIVER_ID);
+
+		service.copy(SOURCE_LOADING_ID);
+
+		assertEquals(RESOLVED_DRIVER_ID, capturedSaved().getDriverId());
+	}
+
+	@Test
+	@DisplayName("已归属的单子号码没变：无关字段的保存不重解析，归属原样保留")
+	void unrelatedEditKeepsStoredDriverId() {
+		LoadingManage record = runningRecord();
+		record.setDriverId(RESOLVED_DRIVER_ID);
+		stubLoadingRecord(record);
+		stubWaybills(waybill(NEED_ACCEPT_WAYBILL_ID, NEED_ACCEPT_PROJECT_ID));
+		// 这一次谁都解析不到：只要实现还按手机号重解析，归属就会被清空
+		when(driverService.resolveDriverIdByMobile(any(), any())).thenReturn(null);
+
+		assertTrue(service.submit(editForm(LOADING_ID, NEED_ACCEPT_WAYBILL_ID)));
+
+		assertEquals(RESOLVED_DRIVER_ID, capturedLoading().getDriverId());
+		assertEquals(RESOLVED_DRIVER_ID, statusSyncUpdates().get(0).setValue("driver_id"));
+		verify(driverService, never()).resolveDriverIdByMobile(any(), any());
+	}
+
+	@Test
+	@DisplayName("人工补过归属的单子：号码恰好命中别人的档案，保存也不改归属")
+	void unrelatedEditKeepsManualOwnership() {
+		LoadingManage record = runningRecord();
+		record.setDriverId(MANUAL_DRIVER_ID);
+		stubLoadingRecord(record);
+		stubWaybills(waybill(NEED_ACCEPT_WAYBILL_ID, NEED_ACCEPT_PROJECT_ID));
+		when(driverService.resolveDriverIdByMobile(any(), any())).thenReturn(OTHER_PROFILE_ID);
+
+		assertTrue(service.submit(editForm(LOADING_ID, NEED_ACCEPT_WAYBILL_ID)));
+
+		assertEquals(MANUAL_DRIVER_ID, capturedLoading().getDriverId(),
+			"人工归属不能被一次无关保存改到同号的另一个档案上");
+		assertEquals(MANUAL_DRIVER_ID, statusSyncUpdates().get(0).setValue("driver_id"));
+	}
+
+	@Test
+	@DisplayName("-1 哨兵的归属：号码没变的保存原样保留，不抹成 NULL")
+	void sentinelDriverIdSurvivesUnrelatedEdit() {
+		LoadingManage record = runningRecord();
+		record.setDriverId(-1L);
+		stubLoadingRecord(record);
+		stubWaybills(waybill(NEED_ACCEPT_WAYBILL_ID, NEED_ACCEPT_PROJECT_ID));
+		when(driverService.resolveDriverIdByMobile(any(), any())).thenReturn(null);
+
+		assertTrue(service.submit(editForm(LOADING_ID, NEED_ACCEPT_WAYBILL_ID)));
+
+		assertEquals(-1L, capturedLoading().getDriverId());
+	}
+
+	@Test
+	@DisplayName("换司机：号码变了就按新号码重新解析，归属跟着换")
+	void changingPhoneResolvesNewDriverId() {
+		LoadingManage record = pendingRecord();
+		record.setDriverId(RESOLVED_DRIVER_ID);
+		stubLoadingRecord(record);
+		stubWaybills(waybill(NEED_ACCEPT_WAYBILL_ID, NEED_ACCEPT_PROJECT_ID));
+		stubConfigs(config(NEED_ACCEPT_PROJECT_ID, NEED_ACCEPT_JSON));
+		when(driverService.resolveDriverIdByMobile(any(), eq(OTHER_DRIVER_PHONE))).thenReturn(OTHER_PROFILE_ID);
+		LoadingManage form = editForm(LOADING_ID, NEED_ACCEPT_WAYBILL_ID);
+		form.setDriverPhone(OTHER_DRIVER_PHONE);
+
+		assertTrue(service.submit(form));
+
+		assertEquals(OTHER_PROFILE_ID, capturedLoading().getDriverId());
+		assertEquals(OTHER_PROFILE_ID, statusSyncUpdates().get(0).setValue("driver_id"));
+	}
+
+	@Test
+	@DisplayName("号码改成一个解析不到的号：归属落空，子单同步落空")
+	void changingPhoneToUnresolvedNumberClearsDriverId() {
+		LoadingManage record = pendingRecord();
+		record.setDriverId(RESOLVED_DRIVER_ID);
+		stubLoadingRecord(record);
+		stubWaybills(waybill(NEED_ACCEPT_WAYBILL_ID, NEED_ACCEPT_PROJECT_ID));
+		stubConfigs(config(NEED_ACCEPT_PROJECT_ID, NEED_ACCEPT_JSON));
+		when(driverService.resolveDriverIdByMobile(any(), eq(OTHER_DRIVER_PHONE))).thenReturn(null);
+		LoadingManage form = editForm(LOADING_ID, NEED_ACCEPT_WAYBILL_ID);
+		form.setDriverPhone(OTHER_DRIVER_PHONE);
+
+		assertTrue(service.submit(form));
+
+		assertNull(capturedLoading().getDriverId());
+		assertNull(statusSyncUpdates().get(0).setValue("driver_id"));
+	}
+
+	@Test
+	@DisplayName("解析不到档案：留一条脱敏 WARN，保存照常成功")
+	void unresolvedPhoneLogsMaskedWarning() {
+		stubWaybills(waybill(NO_ACCEPT_WAYBILL_ID, NO_ACCEPT_PROJECT_ID));
+		stubConfigs(config(NO_ACCEPT_PROJECT_ID, NO_ACCEPT_JSON));
+		when(driverService.resolveDriverIdByMobile(any(), eq(DRIVER_PHONE))).thenReturn(null);
+		try (LogCapture logs = LogCapture.open(LoadingManageServiceImpl.class)) {
+			assertTrue(service.submit(loadingForm(NO_ACCEPT_WAYBILL_ID)));
+
+			String warning = logs.events().stream()
+				.filter(event -> event.getLevel() == Level.WARN)
+				.map(ILoggingEvent::getFormattedMessage)
+				.filter(message -> message.contains("司机档案"))
+				.findFirst()
+				.orElseThrow(() -> new AssertionError("解析失败必须留 WARN，实际日志：" + logs.messages()));
+			assertTrue(warning.contains("138****8000"), "WARN 里的号码必须脱敏，实际：" + warning);
+			assertFalse(warning.contains(DRIVER_PHONE), "WARN 里不能出现完整号码，实际：" + warning);
+			assertTrue(warning.contains(LOADING_NO), "WARN 要带业务标识（配载单号），实际：" + warning);
+		}
+	}
+
 	// ------------------------------------------------------------ 夹具
 
 	private LoadingManage loadingForm(Long... waybillIds) {
@@ -375,10 +571,54 @@ class LoadingManageChildStatusWriteTest {
 		return waybill;
 	}
 
-	private String capturedLoadingStatus() {
+	private LoadingManage runningRecord() {
+		LoadingManage record = loadingRecord("running", NEED_ACCEPT_WAYBILL_ID);
+		record.setVehicleNo("桂A12345");
+		record.setDriverName("张三");
+		record.setDriverPhone(DRIVER_PHONE);
+		return record;
+	}
+
+	private LoadingManage pendingRecord() {
+		LoadingManage record = loadingRecord("pending", NEED_ACCEPT_WAYBILL_ID);
+		record.setVehicleNo("桂A12345");
+		record.setDriverName("张三");
+		record.setDriverPhone(DRIVER_PHONE);
+		return record;
+	}
+
+	private LoadingManage copySource() {
+		LoadingManage source = loadingRecord("pending", NEED_ACCEPT_WAYBILL_ID);
+		source.setLoadingSubNos("YD-" + NEED_ACCEPT_WAYBILL_ID);
+		source.setTransportType("公路运输");
+		source.setVehicleNo("桂A12345");
+		source.setDriverName("张三");
+		source.setDriverPhone(DRIVER_PHONE);
+		source.setDepartureAddress("南宁");
+		source.setArrivalAddress("广州");
+		return source;
+	}
+
+	private void stubCopyDependencies(LoadingManage source) {
+		source.setId(SOURCE_LOADING_ID);
+		doReturn(source).when(service).getById(SOURCE_LOADING_ID);
+		doReturn(null).when(service).detail(any());
+	}
+
+	private LoadingManage capturedSaved() {
+		ArgumentCaptor<LoadingManage> captor = ArgumentCaptor.forClass(LoadingManage.class);
+		verify(service, atLeastOnce()).save(captor.capture());
+		return captor.getValue();
+	}
+
+	private LoadingManage capturedLoading() {
 		ArgumentCaptor<LoadingManage> captor = ArgumentCaptor.forClass(LoadingManage.class);
 		verify(service, atLeastOnce()).saveOrUpdate(captor.capture());
-		return captor.getValue().getBusinessStatus();
+		return captor.getValue();
+	}
+
+	private String capturedLoadingStatus() {
+		return capturedLoading().getBusinessStatus();
 	}
 
 	private void stubWaybills(Waybill... waybills) {
@@ -438,18 +678,28 @@ class LoadingManageChildStatusWriteTest {
 	}
 
 	private static void inject(LoadingManageServiceImpl target, String fieldName, Object value) {
-		try {
-			Field field = LoadingManageServiceImpl.class.getDeclaredField(fieldName);
-			field.setAccessible(true);
-			field.set(target, value);
-		} catch (ReflectiveOperationException exception) {
-			throw new IllegalStateException("注入测试替身失败：" + fieldName, exception);
+		Class<?> type = LoadingManageServiceImpl.class;
+		while (type != null) {
+			try {
+				Field field = type.getDeclaredField(fieldName);
+				field.setAccessible(true);
+				field.set(target, value);
+				return;
+			} catch (NoSuchFieldException ignored) {
+				type = type.getSuperclass();
+			} catch (ReflectiveOperationException exception) {
+				throw new IllegalStateException("注入测试替身失败：" + fieldName, exception);
+			}
 		}
+		throw new IllegalStateException("注入测试替身失败：" + fieldName);
 	}
 
 	/** 一条被捕获的批量更新：SET 的列 → 值、WHERE 的运单 id */
 	private record CapturedUpdate(String sqlSet, String whereSql, Map<String, Object> params, List<String> columns) {
 
+		private static final java.util.regex.Pattern PARAM_REF =
+			java.util.regex.Pattern.compile("#\\{ew\\.paramNameValuePairs\\.([^}]+)}");
+
 		@SuppressWarnings("unchecked")
 		static CapturedUpdate of(Wrapper<Waybill> wrapper) {
 			LambdaUpdateWrapper<Waybill> update = (LambdaUpdateWrapper<Waybill>) wrapper;
@@ -478,8 +728,20 @@ class LoadingManageChildStatusWriteTest {
 			return null;
 		}
 
+		/** 只认 WHERE 段用到的参数：SET 段的 driver_id 也是 Long，混进来会当成运单 id */
 		List<Long> whereIds() {
-			return params.values().stream().filter(Long.class::isInstance).map(Long.class::cast).toList();
+			Set<String> setParamKeys = new java.util.HashSet<>();
+			Matcher matcher = PARAM_REF.matcher(sqlSet);
+			while (matcher.find()) {
+				setParamKeys.add(matcher.group(1));
+			}
+			List<Long> ids = new java.util.ArrayList<>();
+			for (Map.Entry<String, Object> entry : params.entrySet()) {
+				if (entry.getValue() instanceof Long longValue && !setParamKeys.contains(entry.getKey())) {
+					ids.add(longValue);
+				}
+			}
+			return ids;
 		}
 	}
 }

blade-service/blade-transport/src/test/java/org/springblade/transport/service/impl/MasterOrderDriverIdTest.java

@@ -0,0 +1,143 @@
+package org.springblade.transport.service.impl;
+
+import ch.qos.logback.classic.Level;
+import ch.qos.logback.classic.spi.ILoggingEvent;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+import org.springblade.transport.pojo.entity.MasterOrder;
+import org.springblade.transport.pojo.entity.Waybill;
+import org.springblade.transport.service.IContractManageService;
+import org.springblade.transport.service.IDriverService;
+import org.springblade.transport.service.IProjectApplyService;
+import org.springblade.transport.service.ITransportPlanService;
+import org.springblade.transport.service.IWaybillService;
+import org.springblade.transport.support.LogCapture;
+
+import java.lang.reflect.Method;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * 多联总单派单建运单时写司机档案 ID 的测试。
+ * <p>
+ * 派单请求可能来自调度（带档案 ID），也可能只填了姓名手机号（手工派单、承运商司机），
+ * 后者按手机号解析；解析不到也不能挡住派单。
+ */
+class MasterOrderDriverIdTest {
+
+	private static final String DRIVER_PHONE = "13800138000";
+	private static final Long RESOLVED_DRIVER_ID = 9321L;
+
+	private IWaybillService waybillService;
+	private IDriverService driverService;
+	private MasterOrderServiceImpl service;
+
+	@BeforeEach
+	void setUp() {
+		waybillService = mock(IWaybillService.class);
+		driverService = mock(IDriverService.class);
+		service = new MasterOrderServiceImpl(waybillService, mock(ITransportPlanService.class),
+			mock(IProjectApplyService.class), mock(IContractManageService.class), driverService);
+		when(waybillService.submit(any(Waybill.class))).thenReturn(true);
+	}
+
+	@Test
+	@DisplayName("调度带了档案 ID：按它写，不再按手机号解析")
+	void keepsExplicitDriverId() throws Exception {
+		Map<String, Object> dispatch = dispatch();
+		dispatch.put("driverId", 7001L);
+
+		assertTrue(createWaybill(dispatch));
+
+		assertEquals(7001L, submittedWaybill().getDriverId());
+		verify(driverService, never()).resolveDriverIdByMobile(any(), any());
+	}
+
+	@Test
+	@DisplayName("只填了手机号：派单时解析出档案 ID 写入运单")
+	void resolvesDriverIdFromPhone() throws Exception {
+		when(driverService.resolveDriverIdByMobile(any(), eq(DRIVER_PHONE))).thenReturn(RESOLVED_DRIVER_ID);
+
+		assertTrue(createWaybill(dispatch()));
+
+		assertEquals(RESOLVED_DRIVER_ID, submittedWaybill().getDriverId());
+	}
+
+	@Test
+	@DisplayName("解析不到档案（承运商司机）：运单照常提交，归属留空")
+	void allowsDispatchWithoutProfile() throws Exception {
+		when(driverService.resolveDriverIdByMobile(any(), eq(DRIVER_PHONE))).thenReturn(null);
+
+		assertTrue(createWaybill(dispatch()));
+
+		assertNull(submittedWaybill().getDriverId());
+		verify(waybillService).submit(any(Waybill.class));
+	}
+
+	@Test
+	@DisplayName("解析不到档案：落空时留一条脱敏 WARN，派单照常成功")
+	void unresolvedProfileLogsMaskedWarning() throws Exception {
+		when(driverService.resolveDriverIdByMobile(any(), eq(DRIVER_PHONE))).thenReturn(null);
+		try (LogCapture logs = LogCapture.open(MasterOrderServiceImpl.class)) {
+			assertTrue(createWaybill(dispatch()));
+
+			String warning = logs.events().stream()
+				.filter(event -> event.getLevel() == Level.WARN)
+				.map(ILoggingEvent::getFormattedMessage)
+				.filter(message -> message.contains("司机档案"))
+				.findFirst()
+				.orElseThrow(() -> new AssertionError("解析失败必须留 WARN，实际日志：" + logs.messages()));
+			assertTrue(warning.contains("138****8000"), "WARN 里的号码必须脱敏，实际：" + warning);
+			assertFalse(warning.contains(DRIVER_PHONE), "WARN 里不能出现完整号码，实际：" + warning);
+			assertTrue(warning.contains("ZD-20261027-001"), "WARN 要带业务标识（总单号），实际：" + warning);
+		}
+	}
+
+	// ------------------------------------------------------------ 夹具
+
+	private boolean createWaybill(Map<String, Object> dispatch) throws Exception {
+		MasterOrder masterOrder = new MasterOrder();
+		masterOrder.setId(1L);
+		masterOrder.setMasterNo("ZD-20261027-001");
+		masterOrder.setProjectId(2101L);
+		masterOrder.setProjectName("测试项目");
+		Method method = MasterOrderServiceImpl.class
+			.getDeclaredMethod("createWaybill", MasterOrder.class, List.class);
+		method.setAccessible(true);
+		return (boolean) method.invoke(service, masterOrder, List.of(dispatch));
+	}
+
+	private Map<String, Object> dispatch() {
+		Map<String, Object> dispatch = new LinkedHashMap<>();
+		dispatch.put("documentType", "运单");
+		dispatch.put("transportType", "公路运输");
+		dispatch.put("carrierType", "自运");
+		dispatch.put("driverName", "张三");
+		dispatch.put("driverPhone", DRIVER_PHONE);
+		dispatch.put("vehicleNo", "桂A12345");
+		dispatch.put("quantity", 1);
+		dispatch.put("unitPrice", 100);
+		return dispatch;
+	}
+
+	private Waybill submittedWaybill() {
+		ArgumentCaptor<Waybill> captor = ArgumentCaptor.forClass(Waybill.class);
+		verify(waybillService).submit(captor.capture());
+		return captor.getValue();
+	}
+
+}

blade-service/blade-transport/src/test/java/org/springblade/transport/service/impl/MasterOrderProgressTest.java

@@ -14,6 +14,7 @@ import org.springblade.transport.pojo.entity.TransportPlan;
 import org.springblade.transport.pojo.entity.Waybill;
 import org.springblade.transport.pojo.vo.MasterOrderVO;
 import org.springblade.transport.service.IContractManageService;
+import org.springblade.transport.service.IDriverService;
 import org.springblade.transport.service.IProjectApplyService;
 import org.springblade.transport.service.ITransportPlanService;
 import org.springblade.transport.service.IWaybillService;
@@ -67,7 +68,8 @@ class MasterOrderProgressTest {
 			waybillService,
 			transportPlanService,
 			mock(IProjectApplyService.class),
-			mock(IContractManageService.class));
+			mock(IContractManageService.class),
+			mock(IDriverService.class));
 		inject("baseMapper", masterOrderMapper);
 
 		when(transportPlanService.list(anyWrapper())).thenReturn(List.of());

blade-service/blade-transport/src/test/java/org/springblade/transport/service/impl/TripQueryServiceImplTest.java

@@ -50,7 +50,10 @@ import static org.mockito.Mockito.when;
  */
 class TripQueryServiceImplTest {
 
+	/** 派单时的司机手机号快照：只用于展示，归属判据是下面的档案 ID */
 	private static final String PHONE = "17587421208";
+	private static final Long DRIVER_ID = 9001L;
+	private static final Long OTHER_DRIVER_ID = 9002L;
 	private static final String LOADING_NO = "PZ-20261017-001";
 	private static final Long LOADING_ID = 2111350784070275123L;
 	private static final Long WAYBILL_ID = 2110690671695380513L;
@@ -85,7 +88,7 @@ class TripQueryServiceImplTest {
 	@Test
 	@DisplayName("段一在库层只做收口与行级筛选，分组与分档不在 SQL 里")
 	void rowsAreFetchedWithoutDatabaseGrouping() {
-		TripQueryVO query = TripQueryVO.forDriver(PHONE);
+		TripQueryVO query = TripQueryVO.forDriver(DRIVER_ID);
 		query.setStatus(1);
 		query.setCurrent(1);
 		query.setSize(10);
@@ -98,9 +101,9 @@ class TripQueryServiceImplTest {
 		assertFalse(sql.contains("LIMIT"), "分页在服务层，不在 wrapper 里拼：" + sql);
 		assertFalse(sql.contains("MAX(create_time)"), "排序键在服务层算：" + sql);
 		assertTrue(sql.contains("blade_loading_manage"), "配载段按配载单的司机收口：" + sql);
-		assertTrue(sql.contains("lm.driver_phone = ?"), "司机手机号要作为参数下发：" + sql);
-		assertTrue(sql.contains("REPLACE(IFNULL(driver_phone, ''), ' ', '') = ?"),
-			"未配载段按运单司机收口，且容忍手机号带空格：" + sql);
+		assertTrue(sql.contains("lm.driver_id = ?"), "配载段按配载单的司机档案 ID 收口：" + sql);
+		assertTrue(sql.contains("driver_id = ?"), "未配载段按运单的司机档案 ID 收口：" + sql);
+		assertFalse(sql.contains("driver_phone"), "手机号不再是归属判据：" + sql);
 		assertTrue(sql.contains("business_status IN"), "草稿子单不成运次：" + sql);
 		assertTrue(sql.contains("driver_accept_status"), "被该司机拒单的子单不进运次：" + sql);
 	}
@@ -108,7 +111,7 @@ class TripQueryServiceImplTest {
 	@Test
 	@DisplayName("段一只 select 用得上的列，大 JSON 列不拖回来")
 	void onlyNeededColumnsAreSelected() {
-		service.page(TripQueryVO.forDriver(PHONE));
+		service.page(TripQueryVO.forDriver(DRIVER_ID));
 
 		String select = String.valueOf(capturedRowQuery().getSqlSelect());
 		assertTrue(select.contains("process_json"), "分档要按过程配置推导，必须取：" + select);
@@ -124,7 +127,7 @@ class TripQueryServiceImplTest {
 	@Test
 	@DisplayName("组织收口给了就落在库层运单行上，分档与分页都由缩过的行集合算")
 	void deptScopeIsAppliedOnRows() {
-		TripQueryVO query = TripQueryVO.forDriver(PHONE);
+		TripQueryVO query = TripQueryVO.forDriver(DRIVER_ID);
 		query.setDeptIds(List.of(1123598813738675202L, 1123598813738675201L));
 
 		service.page(query);
@@ -134,7 +137,7 @@ class TripQueryServiceImplTest {
 		Set<Object> values = new HashSet<>(capturedRowQuery().getParamNameValuePairs().values());
 		assertTrue(values.contains(1123598813738675202L) && values.contains(1123598813738675201L),
 			"组织值按参数下发：" + values);
-		assertTrue(capturedRowSql().contains("driver_phone"), "组织收口不顶替司机收口：两种收口同时生效");
+		assertTrue(capturedRowSql().contains("driver_id"), "组织收口不顶替司机收口：两种收口同时生效");
 	}
 
 	@Test
@@ -152,7 +155,7 @@ class TripQueryServiceImplTest {
 	@Test
 	@DisplayName("组织收口缺省时不下发组织条件：超管与司机端都按不传处理")
 	void deptScopeIsOptional() {
-		service.page(TripQueryVO.forDriver(PHONE));
+		service.page(TripQueryVO.forDriver(DRIVER_ID));
 
 		assertFalse(capturedRowSql().contains("dept_id"), "不给组织集合即不过滤：" + capturedRowSql());
 	}
@@ -165,7 +168,7 @@ class TripQueryServiceImplTest {
 			waybill(2L, "YD-2", null, "completed", "accepted", at(2000L), ACCEPT_NO),
 			waybill(3L, "YD-3", null, "running", "accepted", at(1000L), ACCEPT_NO));
 
-		TripQueryVO doing = TripQueryVO.forDriver(PHONE);
+		TripQueryVO doing = TripQueryVO.forDriver(DRIVER_ID);
 		doing.setStatus(1);
 		IPage<TripVO> doingPage = service.page(doing);
 
@@ -175,11 +178,11 @@ class TripQueryServiceImplTest {
 		assertTrue(doingPage.getRecords().stream().allMatch(trip -> Integer.valueOf(1).equals(trip.getStatus())),
 			"每张卡的 status 都要等于这一档");
 
-		TripQueryVO done = TripQueryVO.forDriver(PHONE);
+		TripQueryVO done = TripQueryVO.forDriver(DRIVER_ID);
 		done.setStatus(2);
 		assertEquals(List.of("2"), service.page(done).getRecords().stream().map(TripVO::getId).toList());
 
-		TripQueryVO all = TripQueryVO.forDriver(PHONE);
+		TripQueryVO all = TripQueryVO.forDriver(DRIVER_ID);
 		all.setStatus(null);
 		assertEquals(3, service.page(all).getTotal(), "不传 Tab 为全部（不含已取消）");
 	}
@@ -192,12 +195,12 @@ class TripQueryServiceImplTest {
 			waybill(2L, "YD-2", null, "running", null, at(2000L), ACCEPT_YES),
 			waybill(1L, "YD-1", null, "pending", "pending", at(1000L), ACCEPT_NO));
 
-		TripQueryVO pending = TripQueryVO.forDriver(PHONE);
+		TripQueryVO pending = TripQueryVO.forDriver(DRIVER_ID);
 		pending.setStatus(0);
 		assertEquals(List.of("2"), service.page(pending).getRecords().stream().map(TripVO::getId).toList(),
 			"库值 running 但要接单未接 → 落待接单档");
 
-		TripQueryVO doing = TripQueryVO.forDriver(PHONE);
+		TripQueryVO doing = TripQueryVO.forDriver(DRIVER_ID);
 		doing.setStatus(1);
 		assertEquals(List.of("1"), service.page(doing).getRecords().stream().map(TripVO::getId).toList(),
 			"库值 pending 但不需要接单 → 落进行中档");
@@ -212,8 +215,8 @@ class TripQueryServiceImplTest {
 			List.of(
 				waybill(1L, "YD-1", LOADING_NO, "running", null, at(3000L), ACCEPT_YES),
 				waybill(2L, "YD-2", LOADING_NO, "running", null, at(2000L), ACCEPT_YES)));
-		when(loadingManageService.list(anyLoadingWrapper())).thenReturn(List.of(loading(PHONE)));
-		TripQueryVO query = TripQueryVO.forDriver(PHONE);
+		when(loadingManageService.list(anyLoadingWrapper())).thenReturn(List.of(loading(DRIVER_ID)));
+		TripQueryVO query = TripQueryVO.forDriver(DRIVER_ID);
 		query.setKeyword("PZ-20261017");
 
 		TripVO trip = service.page(query).getRecords().get(0);
@@ -232,7 +235,7 @@ class TripQueryServiceImplTest {
 	void unloadedWaybillIsItsOwnTrip() {
 		stubRows(waybill(WAYBILL_ID, "YD-20260920-0003", null, "running", null, at(1000L), ACCEPT_NO));
 
-		IPage<TripVO> page = service.page(TripQueryVO.forDriver(PHONE));
+		IPage<TripVO> page = service.page(TripQueryVO.forDriver(DRIVER_ID));
 
 		assertEquals(1, page.getTotal());
 		assertEquals(1, page.getRecords().size());
@@ -256,7 +259,7 @@ class TripQueryServiceImplTest {
 		row.setMasterNo("DL-20261001-0001");
 		stubRows(row);
 
-		TripVO trip = service.page(TripQueryVO.forDriver(PHONE)).getRecords().get(0);
+		TripVO trip = service.page(TripQueryVO.forDriver(DRIVER_ID)).getRecords().get(0);
 
 		assertEquals(Boolean.TRUE, trip.getMultimodal(), "挂总单即含多式联运");
 		assertEquals("common", trip.getTransportOrgType(), "运输类型是组织形态维，与多式联运各算一个值");
@@ -270,9 +273,9 @@ class TripQueryServiceImplTest {
 		stubRows(
 			onMasterOrder,
 			waybill(2092186187470467073L, "YD-2", LOADING_NO, "running", null, at(1000L), ACCEPT_NO));
-		when(loadingManageService.list(anyLoadingWrapper())).thenReturn(List.of(loading(PHONE)));
+		when(loadingManageService.list(anyLoadingWrapper())).thenReturn(List.of(loading(DRIVER_ID)));
 
-		TripVO trip = service.page(TripQueryVO.forDriver(PHONE)).getRecords().get(0);
+		TripVO trip = service.page(TripQueryVO.forDriver(DRIVER_ID)).getRecords().get(0);
 
 		assertEquals("load", trip.getTransportOrgType());
 		assertEquals(Boolean.TRUE, trip.getMultimodal(), "两个事实叠加，不做互斥单选");
@@ -283,7 +286,7 @@ class TripQueryServiceImplTest {
 	void unloadedTripStateComesFromFetchedWaybill() {
 		stubRows(waybill(WAYBILL_ID, "YD-20260920-0003", null, "pending", "pending", at(1000L), ACCEPT_YES));
 
-		TripVO trip = service.page(TripQueryVO.forDriver(PHONE)).getRecords().get(0);
+		TripVO trip = service.page(TripQueryVO.forDriver(DRIVER_ID)).getRecords().get(0);
 
 		assertEquals(Boolean.TRUE, trip.getRequireAccept());
 		assertEquals("pending", trip.getAcceptStatus());
@@ -300,7 +303,7 @@ class TripQueryServiceImplTest {
 		row.setEstimatedEndTime(LocalDate.of(2026, 8, 24));
 		stubRows(row);
 
-		TripVO listed = service.page(TripQueryVO.forDriver(PHONE)).getRecords().get(0);
+		TripVO listed = service.page(TripQueryVO.forDriver(DRIVER_ID)).getRecords().get(0);
 
 		assertEquals(LocalDate.of(2026, 8, 7), listed.getEstimatedStartDate(), "列表卡片与详情同源，不能只在列表补");
 		assertEquals(LocalDate.of(2026, 8, 24), listed.getEstimatedEndDate());
@@ -319,7 +322,7 @@ class TripQueryServiceImplTest {
 	void loadingMissingIsDropped() {
 		stubRows(waybill(2092186187239780353L, "YD-20260825-0006", LOADING_NO, "running", null, at(1000L), ACCEPT_YES));
 
-		IPage<TripVO> page = service.page(TripQueryVO.forDriver(PHONE));
+		IPage<TripVO> page = service.page(TripQueryVO.forDriver(DRIVER_ID));
 
 		assertTrue(page.getRecords().isEmpty(), "配载单取不到就不给这一趟车");
 		assertEquals(1, page.getTotal(), "总数按运次算，卡片少一张时总数仍在");
@@ -335,9 +338,9 @@ class TripQueryServiceImplTest {
 			waybill(2092186187470467073L, "YD-20260825-0007", LOADING_NO, "running", null, earlier, ACCEPT_NO),
 			waybill(2092186187571130369L, "YD-20260825-0008", LOADING_NO, "running", null, earlier, ACCEPT_NO),
 			waybill(2102780956493299713L, "YD-20260923-0008", LOADING_NO, "running", null, latest, ACCEPT_NO));
-		when(loadingManageService.list(anyLoadingWrapper())).thenReturn(List.of(loading(PHONE)));
+		when(loadingManageService.list(anyLoadingWrapper())).thenReturn(List.of(loading(DRIVER_ID)));
 
-		TripVO trip = service.page(TripQueryVO.forDriver(PHONE)).getRecords().get(0);
+		TripVO trip = service.page(TripQueryVO.forDriver(DRIVER_ID)).getRecords().get(0);
 
 		assertEquals(String.valueOf(LOADING_ID), trip.getId());
 		assertEquals(LOADING_NO, trip.getLoadingNo());
@@ -358,9 +361,9 @@ class TripQueryServiceImplTest {
 		stubRows(
 			waybill(2092186187239780353L, "YD-1", LOADING_NO, "pending", "pending", at(2000L), ACCEPT_YES),
 			waybill(2092186187470467073L, "YD-2", LOADING_NO, "running", null, at(1000L), ACCEPT_NO));
-		when(loadingManageService.list(anyLoadingWrapper())).thenReturn(List.of(loading(PHONE)));
+		when(loadingManageService.list(anyLoadingWrapper())).thenReturn(List.of(loading(DRIVER_ID)));
 
-		TripVO trip = service.page(TripQueryVO.forDriver(PHONE)).getRecords().get(0);
+		TripVO trip = service.page(TripQueryVO.forDriver(DRIVER_ID)).getRecords().get(0);
 
 		assertEquals(Boolean.TRUE, trip.getRequireAccept(), "跨项目按 OR 合并：一张要接单整趟车都要接单");
 		assertEquals("pending", trip.getAcceptStatus());
@@ -372,8 +375,8 @@ class TripQueryServiceImplTest {
 	void repeatedReadsDoNotDriftAndNeverWrite() {
 		stubOneLoadedTrip();
 
-		TripVO first = service.page(TripQueryVO.forDriver(PHONE)).getRecords().get(0);
-		TripVO second = service.page(TripQueryVO.forDriver(PHONE)).getRecords().get(0);
+		TripVO first = service.page(TripQueryVO.forDriver(DRIVER_ID)).getRecords().get(0);
+		TripVO second = service.page(TripQueryVO.forDriver(DRIVER_ID)).getRecords().get(0);
 
 		assertEquals(first.getStatus(), second.getStatus());
 		assertEquals(first.getAcceptStatus(), second.getAcceptStatus());
@@ -412,19 +415,19 @@ class TripQueryServiceImplTest {
 			waybill(2L, "YD-2", null, "running", null, at(2000L), ACCEPT_YES),
 			waybill(1L, "YD-1", null, "running", null, at(1000L), ACCEPT_YES));
 
-		TripQueryVO firstPage = TripQueryVO.forDriver(PHONE);
+		TripQueryVO firstPage = TripQueryVO.forDriver(DRIVER_ID);
 		firstPage.setCurrent(1);
 		firstPage.setSize(2);
 		assertEquals(3, service.page(firstPage).getTotal(), "总数是过滤后的运次数，不是运单数");
 		assertEquals(List.of("3", "2"), service.page(firstPage).getRecords().stream().map(TripVO::getId).toList());
 
-		TripQueryVO secondPage = TripQueryVO.forDriver(PHONE);
+		TripQueryVO secondPage = TripQueryVO.forDriver(DRIVER_ID);
 		secondPage.setCurrent(2);
 		secondPage.setSize(2);
 		assertEquals(List.of("1"), service.page(secondPage).getRecords().stream().map(TripVO::getId).toList(),
 			"第 2 页接着第 1 页，不重复不遗漏");
 
-		TripQueryVO bySeven = TripQueryVO.forDriver(PHONE);
+		TripQueryVO bySeven = TripQueryVO.forDriver(DRIVER_ID);
 		bySeven.setCurrent(1);
 		bySeven.setSize(7);
 		assertEquals(3, service.page(bySeven).getTotal(), "换每页条数总数不变");
@@ -440,7 +443,7 @@ class TripQueryServiceImplTest {
 			waybill(2L, "YD-2", null, "running", null, at(2000L), ACCEPT_NO),
 			waybill(1L, "YD-1", null, "completed", "accepted", at(1000L), ACCEPT_NO));
 
-		TripTabCountsVO counts = service.tabCounts(TripQueryVO.forDriver(PHONE));
+		TripTabCountsVO counts = service.tabCounts(TripQueryVO.forDriver(DRIVER_ID));
 
 		assertEquals(1, counts.getPending());
 		assertEquals(2, counts.getDoing());
@@ -476,7 +479,7 @@ class TripQueryServiceImplTest {
 		stubRows(
 			waybill(2L, "YD-2", LOADING_NO, "completed", "accepted", at(2000L), ACCEPT_NO),
 			waybill(1L, "YD-1", LOADING_NO, "running", null, at(1000L), ACCEPT_NO));
-		when(loadingManageService.list(anyLoadingWrapper())).thenReturn(List.of(loading(PHONE)));
+		when(loadingManageService.list(anyLoadingWrapper())).thenReturn(List.of(loading(DRIVER_ID)));
 		TripQueryVO query = TripQueryVO.forAdmin();
 		query.setException("exception");
 		query.setExceptionWaybillIds(java.util.Set.of(2L));
@@ -572,7 +575,7 @@ class TripQueryServiceImplTest {
 	@Test
 	@DisplayName("详情与列表同口径：子单快照没有接单节点、项目生效配置要求接单时，详情也算待接单")
 	void detailUsesLiveProcessConfig() {
-		when(loadingManageService.getById(LOADING_ID)).thenReturn(loading(PHONE));
+		when(loadingManageService.getById(LOADING_ID)).thenReturn(loading(DRIVER_ID));
 		Waybill child = waybill(2092186187239780353L, "YD-20260915-0001", LOADING_NO, "running", "pending",
 			at(2000L), ACCEPT_NO);
 		child.setProjectId(7001L);
@@ -590,7 +593,7 @@ class TripQueryServiceImplTest {
 	@Test
 	@DisplayName("详情仍是只读取数：生效配置只写回内存里的行，不落库")
 	void detailStaysReadOnly() {
-		when(loadingManageService.getById(LOADING_ID)).thenReturn(loading(PHONE));
+		when(loadingManageService.getById(LOADING_ID)).thenReturn(loading(DRIVER_ID));
 		Waybill child = waybill(2092186187239780353L, "YD-20260915-0001", LOADING_NO, "running", "pending",
 			at(2000L), ACCEPT_NO);
 		child.setProjectId(7001L);
@@ -611,7 +614,7 @@ class TripQueryServiceImplTest {
 		when(loadingManageService.getById(WAYBILL_ID)).thenReturn(null);
 		when(waybillService.getById(WAYBILL_ID))
 			.thenReturn(waybill(WAYBILL_ID, "YD-20260920-0003", null, "running", null, at(1000L), ACCEPT_YES));
-		when(loadingManageService.getById(LOADING_ID)).thenReturn(loading(PHONE));
+		when(loadingManageService.getById(LOADING_ID)).thenReturn(loading(DRIVER_ID));
 		stubChildren();
 
 		TripVO lone = service.detail(tripQuery(String.valueOf(WAYBILL_ID)));
@@ -627,13 +630,13 @@ class TripQueryServiceImplTest {
 	@Test
 	@DisplayName("详情的收口与列表一致：别人的运次、子单全被拒单的配载运次都不可达")
 	void detailRefusesForeignTrips() {
-		when(loadingManageService.getById(LOADING_ID)).thenReturn(loading("13800000001"));
+		when(loadingManageService.getById(LOADING_ID)).thenReturn(loading(OTHER_DRIVER_ID));
 		when(waybillService.getById(WAYBILL_ID))
 			.thenReturn(waybill(WAYBILL_ID, "YD-20260920-0003", null, "running", null, at(1000L), ACCEPT_YES));
 
 		assertThrows(ServiceException.class, () -> service.detail(tripQuery(String.valueOf(LOADING_ID))));
 
-		when(loadingManageService.getById(LOADING_ID)).thenReturn(loading(PHONE));
+		when(loadingManageService.getById(LOADING_ID)).thenReturn(loading(DRIVER_ID));
 		when(waybillService.list(anyWaybillWrapper())).thenReturn(List.of());
 		assertThrows(ServiceException.class, () -> service.detail(tripQuery(String.valueOf(LOADING_ID))));
 
@@ -647,14 +650,119 @@ class TripQueryServiceImplTest {
 	void rejectedChildrenLeaveTheTrip() {
 		// 段一的可见口径已经把被拒子单挡在库层，取回来是空则这趟车不存在
 		stubRows();
-		when(loadingManageService.list(anyLoadingWrapper())).thenReturn(List.of(loading(PHONE)));
+		when(loadingManageService.list(anyLoadingWrapper())).thenReturn(List.of(loading(DRIVER_ID)));
 
-		IPage<TripVO> page = service.page(TripQueryVO.forDriver(PHONE));
+		IPage<TripVO> page = service.page(TripQueryVO.forDriver(DRIVER_ID));
 
 		assertTrue(page.getRecords().isEmpty(), "可见子单为空时不给没有子单的运次");
 		assertEquals(0, page.getTotal());
 	}
 
+	// ------------------------------------------------------------ 收口判据：司机档案 ID
+
+	@Test
+	@DisplayName("司机改号后运次仍可见：判据是档案 ID，派单快照号不再参与")
+	void driverScopeSurvivesPhoneChange() {
+		Waybill lone = waybill(7001L, "YD-LONE-0001", null, "running", null, at(1000L), ACCEPT_YES);
+		stubRows(
+			waybill(2092186187239780353L, "YD-20260825-0006", LOADING_NO, "running", null, at(2000L), ACCEPT_YES),
+			lone);
+		when(loadingManageService.getById(LOADING_ID)).thenReturn(loading(DRIVER_ID));
+		when(waybillService.getById(7001L)).thenReturn(lone);
+		when(loadingManageService.list(anyLoadingWrapper())).thenReturn(List.of(loading(DRIVER_ID)));
+
+		TripQueryVO query = TripQueryVO.forDriver(DRIVER_ID);
+		query.setCurrent(1);
+		query.setSize(10);
+		IPage<TripVO> page = service.page(query);
+
+		assertEquals(2, page.getTotal(), "档案换号不影响归属：已配载与未配载两段都要按档案 ID 命中");
+		assertEquals(Set.of(LOADING_NO, "YD-LONE-0001"),
+			page.getRecords().stream().map(TripVO::getTripNo).collect(java.util.stream.Collectors.toSet()));
+		assertTrue(page.getRecords().stream().allMatch(trip -> PHONE.equals(trip.getDriverPhone())),
+			"响应里的司机手机号仍是派单快照，改号后不变");
+
+		assertEquals(LOADING_NO, service.detail(tripQuery(String.valueOf(LOADING_ID))).getTripNo());
+		assertEquals(PHONE, service.detail(tripQuery(String.valueOf(LOADING_ID))).getDriverPhone(),
+			"已配载运次详情仍回派单快照号");
+		assertEquals(PHONE, service.detail(tripQuery(String.valueOf(7001L))).getDriverPhone(),
+			"未配载运次详情仍回派单快照号");
+	}
+
+	@Test
+	@DisplayName("同号换人不放行：手机号相同、档案 ID 不同的运次仍然看不到")
+	void samePhoneDoesNotGrantAccess() {
+		// 派单快照号一模一样，档案 ID 却是别人
+		Waybill foreignLone = waybill(7002L, "YD-LONE-0002", null, "running", null, at(1000L), ACCEPT_YES);
+		foreignLone.setDriverId(OTHER_DRIVER_ID);
+		when(waybillService.getById(7002L)).thenReturn(foreignLone);
+
+		assertThrows(ServiceException.class, () -> service.detail(tripQuery(String.valueOf(7002L))),
+			"快照号相同不代表同一个司机");
+
+		// 已配载段同样只认配载单上的档案 ID
+		when(loadingManageService.getById(LOADING_ID)).thenReturn(loading(OTHER_DRIVER_ID));
+		assertThrows(ServiceException.class, () -> service.detail(tripQuery(String.valueOf(LOADING_ID))),
+			"配载单归别人时详情同样拒绝");
+	}
+
+	@Test
+	@DisplayName("两段各按自己的 driver_id 判：已配载看配载单，未配载看运单")
+	void driverScopeReadsDriverIdOnBothSegments() {
+		Waybill loadedRow = waybill(2092186187239780353L, "YD-20260825-0006", LOADING_NO, "running", null,
+			at(2000L), ACCEPT_YES);
+		// 运单行归别人、配载单归本人：已配载段只认配载单
+		loadedRow.setDriverId(OTHER_DRIVER_ID);
+		stubRows(loadedRow);
+		when(loadingManageService.list(anyLoadingWrapper())).thenReturn(List.of(loading(DRIVER_ID)));
+		TripQueryVO query = TripQueryVO.forDriver(DRIVER_ID);
+		query.setCurrent(1);
+		query.setSize(10);
+
+		assertEquals(1, service.page(query).getTotal(), "已配载段按配载单的 driver_id 收口，不看运单行的");
+
+		Waybill lone = waybill(7003L, "YD-LONE-0003", null, "running", null, at(1000L), ACCEPT_YES);
+		// 运单归本人、手机号却完全对不上：未配载段只认运单的 driver_id
+		lone.setDriverPhone("13800000003");
+		stubRows(lone);
+
+		IPage<TripVO> page = service.page(query);
+		assertEquals(1, page.getTotal(), "未配载段按运单的 driver_id 收口，不看手机号");
+		assertEquals("13800000003", page.getRecords().get(0).getDriverPhone(), "展示的仍是运单上的派单快照号");
+	}
+
+	@Test
+	@DisplayName("管理端不按司机收口：带上任何 driverId 都照样全出")
+	void adminScopeIgnoresDriverId() {
+		stubRows(
+			waybill(2L, "YD-2", null, "running", null, at(2000L), ACCEPT_YES),
+			waybill(1L, "YD-1", null, "running", null, at(1000L), ACCEPT_YES));
+
+		for (Long driverId : java.util.Arrays.asList(null, 0L, -1L, OTHER_DRIVER_ID)) {
+			TripQueryVO admin = TripQueryVO.forAdmin();
+			admin.setDriverId(driverId);
+
+			assertEquals(2, service.page(admin).getTotal(), "管理端收口与司机无关：" + driverId);
+		}
+	}
+
+	@Test
+	@DisplayName("收口缺省（空、0、负数）一律空集：不放行也不抛异常")
+	void missingDriverIdIsRefused() {
+		stubRows(waybill(1L, "YD-1", null, "running", null, at(1000L), ACCEPT_YES));
+
+		for (Long driverId : java.util.Arrays.asList(null, 0L, -1L, -9001L)) {
+			TripQueryVO query = TripQueryVO.forDriver(driverId);
+
+			IPage<TripVO> page = service.page(query);
+			assertEquals(0, page.getTotal(), "收口缺失不能退回「不按司机收口」：" + driverId);
+			assertTrue(page.getRecords().isEmpty());
+			assertEquals(0, service.tabCounts(query).getAll(), "统计同样为零：" + driverId);
+			assertThrows(ServiceException.class, () -> service.detail(query), "详情直接拒绝：" + driverId);
+		}
+		verify(waybillService, never()).list(anyWaybillWrapper());
+	}
+
 	// ------------------------------------------------------------ 夹具
 
 	@SuppressWarnings("unchecked")
@@ -712,7 +820,7 @@ class TripQueryServiceImplTest {
 	}
 
 	private List<TripVO> orgTypeTrips(String orgType) {
-		TripQueryVO query = TripQueryVO.forDriver(PHONE);
+		TripQueryVO query = TripQueryVO.forDriver(DRIVER_ID);
 		query.setTransportOrgType(orgType);
 		query.setCurrent(1);
 		query.setSize(50);
@@ -737,7 +845,7 @@ class TripQueryServiceImplTest {
 		stubRows(
 			waybill(2092186187239780353L, "YD-20260825-0006", LOADING_NO, "running", null, at(2000L), ACCEPT_YES),
 			waybill(2092186187470467073L, "YD-20260825-0007", LOADING_NO, "running", "pending", at(1000L), ACCEPT_NO));
-		when(loadingManageService.list(anyLoadingWrapper())).thenReturn(List.of(loading(PHONE)));
+		when(loadingManageService.list(anyLoadingWrapper())).thenReturn(List.of(loading(DRIVER_ID)));
 	}
 
 	private void stubChildren() {
@@ -756,23 +864,25 @@ class TripQueryServiceImplTest {
 	}
 
 	private TripQueryVO tripQuery(String tripId) {
-		TripQueryVO query = TripQueryVO.forDriver(PHONE);
+		TripQueryVO query = TripQueryVO.forDriver(DRIVER_ID);
 		query.setTripId(tripId);
 		return query;
 	}
 
 	private LoadingManage loading(String loadingNo, Long loadingId) {
-		LoadingManage loading = loading(PHONE);
+		LoadingManage loading = loading(DRIVER_ID);
 		loading.setId(loadingId);
 		loading.setLoadingNo(loadingNo);
 		return loading;
 	}
 
-	private LoadingManage loading(String driverPhone) {
+	private LoadingManage loading(Long driverId) {
 		LoadingManage loading = new LoadingManage();
 		loading.setId(LOADING_ID);
 		loading.setLoadingNo(LOADING_NO);
-		loading.setDriverPhone(driverPhone);
+		loading.setDriverId(driverId);
+		// 配载单上留的是派单时的手机号快照，档案改号后它不变
+		loading.setDriverPhone(PHONE);
 		loading.setDriverName("黄宇富");
 		loading.setVehicleNo("桂A32523");
 		loading.setProjectName("武宣建筑原料运输项目");
@@ -791,6 +901,8 @@ class TripQueryServiceImplTest {
 		waybill.setLoadingNo(loadingNo);
 		waybill.setBusinessStatus(businessStatus);
 		waybill.setDriverAcceptStatus(acceptStatus);
+		waybill.setDriverId(DRIVER_ID);
+		// 运单上留的是派单时的手机号快照，档案改号后它不变
 		waybill.setDriverPhone(PHONE);
 		waybill.setProcessJson(processJson);
 		waybill.setCreateTime(createTime);

blade-service/blade-transport/src/test/java/org/springblade/transport/service/impl/TripReadServiceBoundaryTest.java

@@ -45,6 +45,7 @@ import static org.mockito.Mockito.when;
 class TripReadServiceBoundaryTest {
 
 	private static final String PHONE = "17587421208";
+	private static final Long DRIVER_ID = 9001L;
 	private static final String LOADING_NO = "PZ-20261017-001";
 	/** 19 位雪花号，按数字下发会被双精度取整 */
 	private static final Long LOADING_ID = 2111350784070275074L;
@@ -100,7 +101,7 @@ class TripReadServiceBoundaryTest {
 			child(CHILD_B, "cancelled", null, ACCEPT_NO, at(1787671422000L)));
 
 		// 「全部」按定义不含已取消档，别在它上面找这趟车；这一趟车本身仍要算成已取消
-		TripQueryVO query = TripQueryVO.forDriver(PHONE);
+		TripQueryVO query = TripQueryVO.forDriver(DRIVER_ID);
 		query.setStatus(3);
 		TripVO trip = onlyTrip(query);
 
@@ -205,7 +206,7 @@ class TripReadServiceBoundaryTest {
 	void emptyChildrenDoNotThrow() {
 		stubLoadedTrip();
 
-		IPage<TripVO> page = service.page(TripQueryVO.forDriver(PHONE));
+		IPage<TripVO> page = service.page(TripQueryVO.forDriver(DRIVER_ID));
 
 		assertTrue(page.getRecords().isEmpty(), "配载单在、可见子单为空时不给没有子单的运次");
 
@@ -239,6 +240,8 @@ class TripReadServiceBoundaryTest {
 		bare.setBusinessStatus("pending");
 		bare.setDriverAcceptStatus("pending");
 		bare.setProcessJson(ACCEPT_YES);
+		bare.setDriverId(DRIVER_ID);
+		// 运单上留的是派单时的手机号快照，档案改号后它不变
 		bare.setDriverPhone(PHONE);
 		when(waybillService.list(anyWaybillWrapper())).thenReturn(List.of(bare));
 
@@ -368,7 +371,7 @@ class TripReadServiceBoundaryTest {
 	}
 
 	private TripVO onlyTrip() {
-		return onlyTrip(TripQueryVO.forDriver(PHONE));
+		return onlyTrip(TripQueryVO.forDriver(DRIVER_ID));
 	}
 
 	private TripVO onlyTrip(TripQueryVO query) {
@@ -378,7 +381,7 @@ class TripReadServiceBoundaryTest {
 	}
 
 	private TripQueryVO detailQuery() {
-		TripQueryVO query = TripQueryVO.forDriver(PHONE);
+		TripQueryVO query = TripQueryVO.forDriver(DRIVER_ID);
 		query.setTripId(String.valueOf(LOADING_ID));
 		return query;
 	}
@@ -387,6 +390,8 @@ class TripReadServiceBoundaryTest {
 		LoadingManage loading = new LoadingManage();
 		loading.setId(LOADING_ID);
 		loading.setLoadingNo(LOADING_NO);
+		loading.setDriverId(DRIVER_ID);
+		// 配载单上留的是派单时的手机号快照
 		loading.setDriverPhone(PHONE);
 		loading.setDriverName("黄宇富");
 		loading.setVehicleNo("桂A32523");
@@ -401,6 +406,8 @@ class TripReadServiceBoundaryTest {
 		waybill.setLoadingNo(LOADING_NO);
 		waybill.setBusinessStatus(businessStatus);
 		waybill.setDriverAcceptStatus(acceptStatus);
+		waybill.setDriverId(DRIVER_ID);
+		// 运单上留的是派单时的手机号快照
 		waybill.setDriverPhone(PHONE);
 		waybill.setProcessJson(processJson);
 		waybill.setCreateTime(createTime);

blade-service/blade-transport/src/test/java/org/springblade/transport/service/impl/WaybillImportDriverIdTest.java

@@ -0,0 +1,110 @@
+package org.springblade.transport.service.impl;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springblade.system.feign.ISysClient;
+import org.springblade.transport.pojo.entity.Waybill;
+import org.springblade.transport.service.ICustomerArchiveService;
+import org.springblade.transport.service.IDriverService;
+import org.springblade.transport.service.ILoadingManageService;
+import org.springblade.transport.service.IProjectApplyService;
+import org.springblade.transport.service.IReceivablePayableDetailService;
+import org.springblade.transport.service.ITransportPlanService;
+import org.springblade.transport.service.IWaybillService;
+
+import java.lang.reflect.Method;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * 批量导入运单时写司机档案 ID 的测试。
+ * <p>
+ * 导入模板可能带档案 ID（老系统导出），也可能只有司机姓名手机号。
+ * 解析不到档案时只留行级 WARN，该行照常导入（承运商司机本来就没有小程序档案）。
+ */
+class WaybillImportDriverIdTest {
+
+	private static final String DRIVER_PHONE = "13800138000";
+	private static final Long RESOLVED_DRIVER_ID = 9321L;
+
+	private IDriverService driverService;
+	private WaybillImportBatchServiceImpl service;
+
+	@BeforeEach
+	void setUp() {
+		driverService = mock(IDriverService.class);
+		service = new WaybillImportBatchServiceImpl(
+			mock(IWaybillService.class),
+			mock(ICustomerArchiveService.class),
+			mock(IProjectApplyService.class),
+			mock(ITransportPlanService.class),
+			mock(IReceivablePayableDetailService.class),
+			mock(ILoadingManageService.class),
+			mock(ISysClient.class),
+			driverService);
+	}
+
+	@Test
+	@DisplayName("行内带了档案 ID：直接用，不再按手机号解析")
+	void keepsDriverIdFromRow() throws Exception {
+		Waybill waybill = importedWaybill(7001L);
+
+		fillDriverOwnership(waybill, 3);
+
+		assertEquals(7001L, waybill.getDriverId());
+		verify(driverService, never()).resolveDriverIdByMobile(any(), any());
+	}
+
+	@Test
+	@DisplayName("行内只有手机号：按手机号解析出档案 ID 写入")
+	void resolvesDriverIdFromRowPhone() throws Exception {
+		when(driverService.resolveDriverIdByMobile(any(), eq(DRIVER_PHONE))).thenReturn(RESOLVED_DRIVER_ID);
+
+		Waybill waybill = importedWaybill(null);
+		fillDriverOwnership(waybill, 3);
+
+		assertEquals(RESOLVED_DRIVER_ID, waybill.getDriverId());
+	}
+
+	@Test
+	@DisplayName("解析不到档案：该行照常导入，归属留空（只留行级 WARN）")
+	void keepsRowWithoutResolvedProfile() throws Exception {
+		when(driverService.resolveDriverIdByMobile(any(), eq(DRIVER_PHONE))).thenReturn(null);
+
+		Waybill waybill = importedWaybill(null);
+		assertDoesNotThrow(() -> fillDriverOwnership(waybill, 3));
+
+		assertNull(waybill.getDriverId());
+	}
+
+	// ------------------------------------------------------------ 夹具
+
+	private void fillDriverOwnership(Waybill waybill, int rowNo) throws Exception {
+		Method method = WaybillImportBatchServiceImpl.class.getDeclaredMethod("fillDriverOwnership", Waybill.class, int.class);
+		method.setAccessible(true);
+		try {
+			method.invoke(service, waybill, rowNo);
+		} catch (java.lang.reflect.InvocationTargetException exception) {
+			throw (Exception) exception.getCause();
+		}
+	}
+
+	private Waybill importedWaybill(Long driverId) {
+		Waybill waybill = new Waybill();
+		waybill.setWaybillNo("YD-IMPORT-1");
+		waybill.setDriverId(driverId);
+		waybill.setDriverName("张三");
+		waybill.setDriverPhone(DRIVER_PHONE);
+		return waybill;
+	}
+
+}

blade-service/blade-transport/src/test/java/org/springblade/transport/service/impl/WaybillReassignDriverIdTest.java

@@ -0,0 +1,197 @@
+package org.springblade.transport.service.impl;
+
+import ch.qos.logback.classic.Level;
+import ch.qos.logback.classic.spi.ILoggingEvent;
+import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
+import org.apache.ibatis.builder.MapperBuilderAssistant;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+import org.springblade.transport.mapper.WaybillMapper;
+import org.springblade.transport.pojo.entity.Waybill;
+import org.springblade.transport.service.IDriverService;
+import org.springblade.transport.service.IProcessConfigService;
+import org.springblade.transport.support.LogCapture;
+
+import java.lang.reflect.Field;
+import java.util.Collections;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * 重新派单写司机档案 ID 的测试。
+ * <p>
+ * 派单是司机归属的唯一入口：调用方带了档案 ID（>0）就按它写，
+ * 只带姓名手机号（承运商司机、手工派单）就按手机号解析；解析不到也不能挡住派单。
+ */
+class WaybillReassignDriverIdTest {
+
+	private static final Long WAYBILL_ID = 1900000000000000001L;
+	private static final String TENANT_ID = "000000";
+	private static final String DRIVER_PHONE = "13800138000";
+	private static final Long RESOLVED_DRIVER_ID = 9321L;
+
+	private WaybillMapper waybillMapper;
+	private IDriverService driverService;
+	private WaybillServiceImpl service;
+
+	@BeforeAll
+	static void initTableInfo() {
+		MybatisConfiguration configuration = new MybatisConfiguration();
+		MapperBuilderAssistant assistant = new MapperBuilderAssistant(configuration, "");
+		assistant.setCurrentNamespace("test");
+		TableInfoHelper.initTableInfo(assistant, Waybill.class);
+	}
+
+	@BeforeEach
+	void setUp() throws Exception {
+		waybillMapper = mock(WaybillMapper.class);
+		driverService = mock(IDriverService.class);
+		service = new WaybillServiceImpl();
+		inject("baseMapper", waybillMapper);
+		inject("driverService", driverService);
+		inject("processConfigService", processConfigService());
+		when(waybillMapper.selectById(WAYBILL_ID)).thenReturn(pendingWaybill());
+		when(waybillMapper.updateById(any(Waybill.class))).thenReturn(1);
+	}
+
+	@Test
+	@DisplayName("调用方带了档案 ID：按它写，不再按手机号解析")
+	void keepsExplicitDriverId() {
+		Waybill request = reassignRequest(7721L);
+
+		assertTrue(service.reassignWithoutDeptCheck(request));
+
+		assertEquals(7721L, capturedWaybill().getDriverId());
+		verify(driverService, never()).resolveDriverIdByMobile(any(), anyString());
+	}
+
+	@Test
+	@DisplayName("调用方只带手机号：按手机号解析出档案 ID 写入")
+	void resolvesDriverIdFromPhone() {
+		when(driverService.resolveDriverIdByMobile(TENANT_ID, DRIVER_PHONE)).thenReturn(RESOLVED_DRIVER_ID);
+
+		assertTrue(service.reassignWithoutDeptCheck(reassignRequest(null)));
+
+		assertEquals(RESOLVED_DRIVER_ID, capturedWaybill().getDriverId());
+	}
+
+	@Test
+	@DisplayName("档案 ID 为 0 或 -1（无主哨兵）：按手机号重新解析")
+	void resolvesWhenDriverIdIsSentinel() throws Exception {
+		when(driverService.resolveDriverIdByMobile(TENANT_ID, DRIVER_PHONE)).thenReturn(RESOLVED_DRIVER_ID);
+
+		assertTrue(service.reassignWithoutDeptCheck(reassignRequest(0L)));
+		assertEquals(RESOLVED_DRIVER_ID, capturedWaybill().getDriverId());
+
+		setUpAgain();
+		assertTrue(service.reassignWithoutDeptCheck(reassignRequest(-1L)));
+		assertEquals(RESOLVED_DRIVER_ID, capturedWaybill().getDriverId());
+	}
+
+	@Test
+	@DisplayName("解析不到档案（承运商司机）：派单照常成功，归属留空")
+	void allowsReassignWithoutResolvedProfile() {
+		when(driverService.resolveDriverIdByMobile(TENANT_ID, DRIVER_PHONE)).thenReturn(null);
+
+		assertTrue(service.reassignWithoutDeptCheck(reassignRequest(null)));
+
+		assertNull(capturedWaybill().getDriverId());
+	}
+
+	@Test
+	@DisplayName("解析不到档案：落空时留一条脱敏 WARN，派单照常成功")
+	void unresolvedProfileLogsMaskedWarning() {
+		when(driverService.resolveDriverIdByMobile(TENANT_ID, DRIVER_PHONE)).thenReturn(null);
+		try (LogCapture logs = LogCapture.open(WaybillServiceImpl.class)) {
+			assertTrue(service.reassignWithoutDeptCheck(reassignRequest(null)));
+
+			String warning = logs.events().stream()
+				.filter(event -> event.getLevel() == Level.WARN)
+				.map(ILoggingEvent::getFormattedMessage)
+				.filter(message -> message.contains("司机档案"))
+				.findFirst()
+				.orElseThrow(() -> new AssertionError("解析失败必须留 WARN，实际日志：" + logs.messages()));
+			assertTrue(warning.contains("138****8000"), "WARN 里的号码必须脱敏，实际：" + warning);
+			assertFalse(warning.contains(DRIVER_PHONE), "WARN 里不能出现完整号码，实际：" + warning);
+			assertTrue(warning.contains("YD-20261027-001"), "WARN 要带业务标识（运单号），实际：" + warning);
+		}
+	}
+
+	// ------------------------------------------------------------ 夹具
+
+	private void setUpAgain() throws Exception {
+		waybillMapper = mock(WaybillMapper.class);
+		service = new WaybillServiceImpl();
+		inject("baseMapper", waybillMapper);
+		inject("driverService", driverService);
+		inject("processConfigService", processConfigService());
+		when(waybillMapper.selectById(WAYBILL_ID)).thenReturn(pendingWaybill());
+		when(waybillMapper.updateById(any(Waybill.class))).thenReturn(1);
+	}
+
+	private IProcessConfigService processConfigService() {
+		IProcessConfigService processConfigService = mock(IProcessConfigService.class);
+		when(processConfigService.listByIds(any())).thenReturn(Collections.emptyList());
+		return processConfigService;
+	}
+
+	private Waybill pendingWaybill() {
+		Waybill waybill = new Waybill();
+		waybill.setId(WAYBILL_ID);
+		waybill.setIsDeleted(0);
+		waybill.setTenantId(TENANT_ID);
+		waybill.setWaybillNo("YD-20261027-001");
+		waybill.setBusinessStatus("pending");
+		waybill.setTransportType("road");
+		waybill.setDriverName("张三");
+		waybill.setDriverPhone("13900139000");
+		waybill.setVehicleNo("桂A12345");
+		return waybill;
+	}
+
+	private Waybill reassignRequest(Long driverId) {
+		Waybill request = new Waybill();
+		request.setId(WAYBILL_ID);
+		request.setDriverId(driverId);
+		request.setDriverName("李四");
+		request.setDriverPhone(DRIVER_PHONE);
+		request.setVehicleNo("桂A88888");
+		return request;
+	}
+
+	private Waybill capturedWaybill() {
+		ArgumentCaptor<Waybill> captor = ArgumentCaptor.forClass(Waybill.class);
+		verify(waybillMapper, org.mockito.Mockito.atLeastOnce()).updateById(captor.capture());
+		return captor.getValue();
+	}
+
+	private void inject(String field, Object value) throws Exception {
+		Class<?> type = service.getClass();
+		while (type != null) {
+			try {
+				Field declared = type.getDeclaredField(field);
+				declared.setAccessible(true);
+				declared.set(service, value);
+				return;
+			} catch (NoSuchFieldException ignored) {
+				type = type.getSuperclass();
+			}
+		}
+		throw new IllegalStateException("未找到字段：" + field);
+	}
+
+}

blade-service/blade-transport/src/test/java/org/springblade/transport/support/DriverIdBackfillSqlTest.java

@@ -0,0 +1,289 @@
+package org.springblade.transport.support;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+/**
+ * 存量司机档案 ID 回填脚本的文本护栏。
+ * <p>
+ * 仓库里没有连库的测试基座，回填脚本的正确性只能靠「读脚本、断言不变量」来守。
+ * 这里守的是「改脚本时最容易写坏、写坏了又不会报错」的几条：
+ * <ul>
+ *   <li>只填 {@code driver_id IS NULL} 的行 —— 手滑把条件放宽成 {@code <= 0} 就会覆盖
+ *       {@code -1}（无主哨兵）和已经派给别人的单。</li>
+ *   <li>{@code driver_id = -1} 必须有一道显式排除 —— 只靠 {@code IS NULL} 挡住是隐式的，
+ *       后人看不出「-1 不能动」是需求，容易在重构时丢掉。</li>
+ *   <li>跨表比较必须显式 {@code COLLATE} —— 运单/配载单侧是 {@code utf8mb4_0900_ai_ci}，
+ *       司机档案侧是 {@code utf8mb4_general_ci}，漏了就在执行时抛
+ *       {@code ERROR 1267 Illegal mix of collations}，而这只有真跑库才会暴露。</li>
+ *   <li>不许 {@code SET driver_phone} / {@code SET update_time} —— 手机号是派单时的号码快照，
+ *       回填是「补归属」不是「改快照」；{@code update_time} 一改，业务上就分不清这张单是不是
+ *       真的被人动过。</li>
+ *   <li>唯一命中（{@code COUNT(*) = 1}）与可重复执行（{@code IF NOT EXISTS} / {@code INSERT IGNORE}
+ *       / {@code IS NULL} 兜底）—— 同号多档案时填空会把单挂错人，重复跑必须零变更。</li>
+ * </ul>
+ * 这些断言只在脚本文本层面成立，不证明数据结果正确；数据结果由脚本第 2 节校验负责。
+ */
+class DriverIdBackfillSqlTest {
+
+	/**
+	 * 每个用例跑两张表：运单一份、配载单一份，规则完全相同。
+	 */
+	@ParameterizedTest(name = "{0}")
+	@CsvSource({
+		"blade_waybill_driver_id_backfill_20261028.sql, blade_waybill",
+		"blade_loading_manage_driver_id_backfill_20261028.sql, blade_loading_manage"
+	})
+	@DisplayName("只更新 driver_id 为 NULL 的行")
+	void onlyFillsNullDriverId(String fileName, String table) {
+		List<String> updates = updateStatements(script(fileName));
+		assertFalse(updates.isEmpty(), fileName + " 里找不到 UPDATE 语句：回填脚本必须真的写 driver_id");
+
+		for (String update : updates) {
+			String where = whereClause(update).toUpperCase();
+			assertTrue(where.contains("DRIVER_ID IS NULL"),
+				table + " 的 UPDATE 缺少 driver_id IS NULL："
+					+ "条件一放宽就会覆盖 -1（无主哨兵）与已派单的行。原文：" + squeeze(update));
+			assertTrue(setClause(update).toUpperCase().contains("DRIVER_ID"),
+				table + " 的 UPDATE 没有写 driver_id：" + squeeze(update));
+		}
+	}
+
+	@ParameterizedTest(name = "{0}")
+	@CsvSource({
+		"blade_waybill_driver_id_backfill_20261028.sql, blade_waybill",
+		"blade_loading_manage_driver_id_backfill_20261028.sql, blade_loading_manage"
+	})
+	@DisplayName("driver_id = -1 的哨兵行有一道显式排除")
+	void keepsSentinelRowsUntouched(String fileName, String table) {
+		List<String> updates = updateStatements(script(fileName));
+		assertFalse(updates.isEmpty(), fileName + " 里找不到 UPDATE 语句");
+
+		for (String update : updates) {
+			String where = whereClause(update);
+			assertTrue(where.contains("-1"),
+				table + " 的 UPDATE 没有出现 -1 保护：哨兵行会被回填覆盖。原文：" + squeeze(update));
+			assertTrue(where.toUpperCase().contains("IS NOT TRUE") || where.toUpperCase().contains("NOT ("),
+				table + " 的 UPDATE 里 -1 只是一笔带过（例如 driver_id <> -1），"
+					+ "对 NULL 行的比较结果是 NULL、条件不成立，要填的行会被整批漏掉。原文：" + squeeze(update));
+		}
+	}
+
+	@ParameterizedTest(name = "{0}")
+	@CsvSource({
+		"blade_waybill_driver_id_backfill_20261028.sql, blade_waybill",
+		"blade_loading_manage_driver_id_backfill_20261028.sql, blade_loading_manage"
+	})
+	@DisplayName("跨表比较手机号与租户时显式 COLLATE")
+	void comparesAcrossTablesWithExplicitCollate(String fileName, String table) {
+		for (String line : body(fileName).split("\\R")) {
+			String trimmed = line.trim();
+			if (trimmed.isEmpty() || !trimmed.contains("=")) {
+				continue;
+			}
+			boolean tenantComparison = countOf(trimmed, ".tenant_id") >= 2;
+			boolean mobileComparison = trimmed.contains(".mobile") && trimmed.contains("driver_phone");
+			if (!tenantComparison && !mobileComparison) {
+				continue;
+			}
+			assertTrue(trimmed.toUpperCase().contains("COLLATE"),
+				table + " 的跨表比较没有显式 COLLATE（会抛 ERROR 1267 Illegal mix of collations）：" + trimmed);
+		}
+	}
+
+	@ParameterizedTest(name = "{0}")
+	@CsvSource({
+		"blade_waybill_driver_id_backfill_20261028.sql, blade_waybill",
+		"blade_loading_manage_driver_id_backfill_20261028.sql, blade_loading_manage"
+	})
+	@DisplayName("不改写 driver_phone 快照")
+	void neverRewritesPhoneSnapshot(String fileName, String table) {
+		for (String update : updateStatements(script(fileName))) {
+			assertFalse(setClause(update).toUpperCase().contains("DRIVER_PHONE"),
+				table + " 的 UPDATE 改写了 driver_phone：手机号是派单时的号码快照，回填只补归属。原文：" + squeeze(update));
+		}
+	}
+
+	@ParameterizedTest(name = "{0}")
+	@CsvSource({
+		"blade_waybill_driver_id_backfill_20261028.sql, blade_waybill",
+		"blade_loading_manage_driver_id_backfill_20261028.sql, blade_loading_manage"
+	})
+	@DisplayName("不改写 update_time")
+	void neverRewritesUpdateTime(String fileName, String table) {
+		for (String update : updateStatements(script(fileName))) {
+			assertFalse(setClause(update).toUpperCase().contains("UPDATE_TIME"),
+				table + " 的 UPDATE 改写了 update_time：回填不是业务动作，改了就看不出单据是否真被人动过。原文：" + squeeze(update));
+		}
+	}
+
+	@ParameterizedTest(name = "{0}")
+	@CsvSource({
+		"blade_waybill_driver_id_backfill_20261028.sql, blade_waybill",
+		"blade_loading_manage_driver_id_backfill_20261028.sql, blade_loading_manage"
+	})
+	@DisplayName("同号多档案不填：命中映射要求唯一")
+	void requiresUniqueMobileMatch(String fileName, String table) {
+		String body = body(fileName);
+		assertTrue(Pattern.compile("(?i)HAVING\\s+COUNT\\(\\*\\)\\s*=\\s*1").matcher(body).find(),
+			table + " 的回填映射没有 HAVING COUNT(*) = 1：同号多档案时会把单挂到其中一条档案上");
+		assertTrue(Pattern.compile("(?i)COUNT\\(DISTINCT\\s+d\\.id\\)\\s*>\\s*1").matcher(body).find(),
+			table + " 没有同号多档案的冲突清单：跳过多少、为什么跳过必须可复核");
+	}
+
+	@ParameterizedTest(name = "{0}")
+	@CsvSource({
+		"blade_waybill_driver_id_backfill_20261028.sql, blade_waybill",
+		"blade_loading_manage_driver_id_backfill_20261028.sql, blade_loading_manage"
+	})
+	@DisplayName("可重复执行：存档表与命中映射都带重复执行保护")
+	void isRerunnable(String fileName, String table) {
+		String body = body(fileName);
+		assertTrue(Pattern.compile("(?i)CREATE\\s+TABLE\\s+IF\\s+NOT\\s+EXISTS").matcher(body).find(),
+			table + " 的存档表没有 IF NOT EXISTS：第二次执行会报 1050 Table already exists，跑不完");
+		assertTrue(Pattern.compile("(?i)INSERT\\s+IGNORE").matcher(body).find(),
+			table + " 的命中映射没有 INSERT IGNORE：第二次执行会撞主键，跑不完");
+
+		String insert = statement(body, "INSERT IGNORE");
+		assertFalse(insert.isEmpty(), table + " 的 INSERT IGNORE 不是一条完整语句");
+		assertTrue(insert.toUpperCase().contains("DRIVER_ID IS NULL"),
+			table + " 的命中映射没有 driver_id IS NULL 兜底：重复执行会给已经填过的行反复建映射");
+		assertTrue(body.contains("ROW_COUNT()"),
+			table + " 的分批循环没有 ROW_COUNT() 退出条件：会死循环或只跑第一批");
+	}
+
+	@ParameterizedTest(name = "{0}")
+	@CsvSource({
+		"blade_waybill_driver_id_backfill_20261028.sql, blade_waybill",
+		"blade_loading_manage_driver_id_backfill_20261028.sql, blade_loading_manage"
+	})
+	@DisplayName("分批执行：循环里带 LIMIT 的批次大小")
+	void batchesInBoundedChunks(String fileName, String table) {
+		String body = body(fileName);
+		assertTrue(body.contains("REPEAT") || body.contains("WHILE"),
+			table + " 的回填没有分批循环：一次性 UPDATE 全表会长时间锁行");
+		assertTrue(Pattern.compile("(?i)LIMIT\\s+(\\d+|v_\\w+)").matcher(body).find(),
+			table + " 的 LIMIT 后面不是批次大小的数字或变量：不是真正的分批");
+	}
+
+	@ParameterizedTest(name = "{0}")
+	@CsvSource({
+		"blade_waybill_driver_id_backfill_20261028.sql, blade_waybill",
+		"blade_loading_manage_driver_id_backfill_20261028.sql, blade_loading_manage"
+	})
+	@DisplayName("脚本按目录惯例分了 0 存档 / 1 订正 / 2 校验 / 3 回退")
+	void hasRequiredSections(String fileName, String table) {
+		String script = script(fileName);
+		assertTrue(script.contains("-- 0. 存档"), table + " 缺 -- 0. 存档 段");
+		assertTrue(script.contains("-- 1. 订正"), table + " 缺 -- 1. 订正 段");
+		assertTrue(script.contains("-- 2. 校验"), table + " 缺 -- 2. 校验 段");
+		assertTrue(script.contains("-- 3. 回退"), table + " 缺 -- 3. 回退 段");
+	}
+
+	@ParameterizedTest(name = "{0}")
+	@CsvSource({
+		"blade_waybill_driver_id_backfill_20261028.sql, blade_waybill",
+		"blade_loading_manage_driver_id_backfill_20261028.sql, blade_loading_manage"
+	})
+	@DisplayName("取数与写入全在 SQL 内：不经过 JSON 中转")
+	void keepsSnowflakeIdsInsideSql(String fileName, String table) {
+		String body = body(fileName).toUpperCase();
+		assertFalse(body.contains("JSON_"),
+			table + " 的脚本用了 JSON 函数中转：19 位雪花 ID 过 JSON 会丢精度，取数与写入必须在 SQL 内完成");
+	}
+
+	private static String script(String fileName) {
+		Path path = locate(fileName);
+		try {
+			return Files.readString(path, StandardCharsets.UTF_8);
+		} catch (IOException exception) {
+			throw new UncheckedIOException("读不了回填脚本：" + path, exception);
+		}
+	}
+
+	private static Path locate(String fileName) {
+		List<Path> candidates = List.of(
+			Path.of("..", "..", "doc", "sql", "transport", fileName),
+			Path.of("doc", "sql", "transport", fileName));
+		List<String> tried = new ArrayList<>();
+		for (Path candidate : candidates) {
+			if (Files.isRegularFile(candidate)) {
+				return candidate;
+			}
+			tried.add(candidate.toAbsolutePath().normalize().toString());
+		}
+		fail("找不到回填脚本 " + fileName + "。surefire 的工作目录是模块目录（blade-service/blade-transport），"
+			+ "脚本应在 ../../doc/sql/transport/ 下。已尝试：" + String.join("；", tried));
+		return null;
+	}
+
+	private static List<String> updateStatements(String script) {
+		List<String> updates = new ArrayList<>();
+		Matcher matcher = Pattern.compile("(?is)\\bUPDATE\\b.*?;").matcher(stripComments(script));
+		while (matcher.find()) {
+			updates.add(matcher.group());
+		}
+		return updates;
+	}
+
+	private static String statement(String body, String prefix) {
+		Matcher matcher = Pattern.compile("(?is)\\b" + Pattern.quote(prefix) + "\\b.*?;").matcher(body);
+		return matcher.find() ? matcher.group() : "";
+	}
+
+	private static String setClause(String update) {
+		String upper = update.toUpperCase();
+		int set = upper.indexOf(" SET ");
+		if (set < 0) {
+			fail("UPDATE 里没有 SET：" + squeeze(update));
+		}
+		int where = upper.indexOf(" WHERE ", set);
+		return where < 0 ? update.substring(set) : update.substring(set, where);
+	}
+
+	private static String whereClause(String update) {
+		int where = update.toUpperCase().indexOf(" WHERE ");
+		if (where < 0) {
+			fail("UPDATE 里没有 WHERE：" + squeeze(update));
+		}
+		return update.substring(where);
+	}
+
+	private static String body(String fileName) {
+		return stripComments(script(fileName));
+	}
+
+	private static String stripComments(String script) {
+		return script.replaceAll("(?s)/\\*.*?\\*/", " ").replaceAll("--[^\\r\\n]*", " ");
+	}
+
+	private static int countOf(String text, String needle) {
+		int count = 0;
+		int index = text.indexOf(needle);
+		while (index >= 0) {
+			count++;
+			index = text.indexOf(needle, index + needle.length());
+		}
+		return count;
+	}
+
+	private static String squeeze(String sql) {
+		return sql.replaceAll("\\s+", " ").trim();
+	}
+
+}

blade-service/blade-transport/src/test/java/org/springblade/transport/support/LogCapture.java

@@ -0,0 +1,48 @@
+package org.springblade.transport.support;
+
+import ch.qos.logback.classic.Logger;
+import ch.qos.logback.classic.spi.ILoggingEvent;
+import ch.qos.logback.core.read.ListAppender;
+import org.slf4j.LoggerFactory;
+
+import java.util.List;
+
+/**
+ * 抓取某个类的日志输出（logback ListAppender）。
+ * <p>
+ * 「解析失败时留一条脱敏 WARN」这类要求只看返回值验不出来，必须断言真实日志正文。
+ */
+public final class LogCapture implements AutoCloseable {
+
+	private final Logger logger;
+	private final ListAppender<ILoggingEvent> appender;
+
+	private LogCapture(Logger logger, ListAppender<ILoggingEvent> appender) {
+		this.logger = logger;
+		this.appender = appender;
+	}
+
+	public static LogCapture open(Class<?> loggerType) {
+		Logger logger = (Logger) LoggerFactory.getLogger(loggerType);
+		ListAppender<ILoggingEvent> appender = new ListAppender<>();
+		appender.start();
+		logger.addAppender(appender);
+		return new LogCapture(logger, appender);
+	}
+
+	/** 已按占位符填充好的日志正文，按发生顺序 */
+	public List<String> messages() {
+		return appender.list.stream().map(ILoggingEvent::getFormattedMessage).toList();
+	}
+
+	public List<ILoggingEvent> events() {
+		return List.copyOf(appender.list);
+	}
+
+	@Override
+	public void close() {
+		logger.detachAppender(appender);
+		appender.stop();
+	}
+
+}

doc/sql/transport/blade_loading_manage_20260804.sql

@@ -21,6 +21,7 @@ CREATE TABLE IF NOT EXISTS `blade_loading_manage` (
   `trailer_vehicle_no` varchar(100) DEFAULT NULL COMMENT '挂车车牌号',
   `driver_name` varchar(100) DEFAULT NULL COMMENT '司机',
   `driver_phone` varchar(50) DEFAULT NULL COMMENT '联系电话',
+  `driver_id` bigint(20) DEFAULT NULL COMMENT '司机ID',
   `escort_name` varchar(100) DEFAULT NULL COMMENT '押运人',
   `escort_phone` varchar(50) DEFAULT NULL COMMENT '押运人手机号',
   `carrier_type` varchar(50) DEFAULT NULL COMMENT '承运类型',
@@ -50,7 +51,8 @@ CREATE TABLE IF NOT EXISTS `blade_loading_manage` (
   UNIQUE KEY `uk_loading_manage_no` (`loading_no`) USING BTREE,
   KEY `idx_loading_manage_carrier_contract_id` (`carrier_contract_id`) USING BTREE,
   KEY `idx_loading_manage_dept` (`dept_id`) USING BTREE,
-  KEY `idx_loading_manage_create_time` (`create_time`) USING BTREE
+  KEY `idx_loading_manage_create_time` (`create_time`) USING BTREE,
+  KEY `idx_loading_manage_tenant_driver_id` (`tenant_id`, `driver_id`) USING BTREE
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='配载管理';
 
 INSERT IGNORE INTO `blade_menu` (`id`, `parent_id`, `code`, `name`, `alias`, `path`, `source`, `sort`, `category`, `action`, `is_open`, `component`, `remark`, `is_deleted`) VALUES

doc/sql/transport/blade_loading_manage_driver_id_20261028.sql

@@ -0,0 +1,80 @@
+-- ============================================================
+-- blade_loading_manage_driver_id_20261028.sql
+-- ============================================================
+-- 运单/配载单写入司机档案 ID，把「归属」与「手机号快照」解耦：
+--   blade_loading_manage.driver_id  配载单当前司机的司机档案 ID（blade_transport_driver.id）
+--   blade_waybill.driver_id         已有列（本脚本只补索引），派单/配载/导入时写入
+-- 归属判据：driver_id > 0 才算有主；0、-1 与 NULL 一律等同「无主」（承运商司机、未登录过小程序的司机）。
+-- 历史数据不回填：手机号二次放号后按号反查会张冠李戴，旧单统一按无主处理，等下一次派单/配载再写入。
+-- 本脚本只做结构升级，不改任何业务数据；以下结构变更可重复执行。
+
+-- ------------------------------------------------------------
+-- 0. 存档
+-- ------------------------------------------------------------
+-- 本脚本无数据订正，无需备份表。
+
+-- ------------------------------------------------------------
+-- 1. 结构变更
+-- ------------------------------------------------------------
+-- ① blade_loading_manage.driver_id
+SET @ddl_sql = (
+  SELECT IF(COUNT(*) = 0,
+    'ALTER TABLE `blade_loading_manage` ADD COLUMN `driver_id` bigint(20) DEFAULT NULL COMMENT ''司机ID'' AFTER `driver_phone`',
+    'SELECT 1')
+  FROM information_schema.COLUMNS
+  WHERE TABLE_SCHEMA = DATABASE()
+    AND TABLE_NAME = 'blade_loading_manage'
+    AND COLUMN_NAME = 'driver_id'
+);
+PREPARE ddl_stmt FROM @ddl_sql;
+EXECUTE ddl_stmt;
+DEALLOCATE PREPARE ddl_stmt;
+
+-- ② blade_loading_manage 按租户 + 司机归属检索（司机端/归属巡检）
+SET @ddl_sql = (
+  SELECT IF(COUNT(*) = 0,
+    'ALTER TABLE `blade_loading_manage` ADD KEY `idx_loading_manage_tenant_driver_id` (`tenant_id`, `driver_id`) USING BTREE',
+    'SELECT 1')
+  FROM information_schema.STATISTICS
+  WHERE TABLE_SCHEMA = DATABASE()
+    AND TABLE_NAME = 'blade_loading_manage'
+    AND INDEX_NAME = 'idx_loading_manage_tenant_driver_id'
+);
+PREPARE ddl_stmt FROM @ddl_sql;
+EXECUTE ddl_stmt;
+DEALLOCATE PREPARE ddl_stmt;
+
+-- ③ blade_waybill 按租户 + 司机归属检索（列已存在，只补索引）
+SET @ddl_sql = (
+  SELECT IF(COUNT(*) = 0,
+    'ALTER TABLE `blade_waybill` ADD KEY `idx_waybill_tenant_driver_id` (`tenant_id`, `driver_id`) USING BTREE',
+    'SELECT 1')
+  FROM information_schema.STATISTICS
+  WHERE TABLE_SCHEMA = DATABASE()
+    AND TABLE_NAME = 'blade_waybill'
+    AND INDEX_NAME = 'idx_waybill_tenant_driver_id'
+);
+PREPARE ddl_stmt FROM @ddl_sql;
+EXECUTE ddl_stmt;
+DEALLOCATE PREPARE ddl_stmt;
+
+-- ------------------------------------------------------------
+-- 2. 校验
+-- ------------------------------------------------------------
+-- 列存在（期望 1 行）
+-- SELECT COUNT(*) FROM information_schema.COLUMNS
+--  WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = 'blade_loading_manage' AND COLUMN_NAME = 'driver_id';
+-- 索引存在（期望 2 行）
+-- SELECT TABLE_NAME, INDEX_NAME, COLUMN_NAME FROM information_schema.STATISTICS
+--  WHERE TABLE_SCHEMA = DATABASE()
+--    AND INDEX_NAME IN ('idx_loading_manage_tenant_driver_id', 'idx_waybill_tenant_driver_id')
+--  ORDER BY TABLE_NAME, SEQ_IN_INDEX;
+-- 归属分布（历史单 driver_id 应为空）
+-- SELECT COUNT(*) AS total, SUM(driver_id IS NOT NULL AND driver_id > 0) AS owned FROM blade_waybill;
+
+-- ------------------------------------------------------------
+-- 3. 回退
+-- ------------------------------------------------------------
+-- ALTER TABLE `blade_waybill` DROP INDEX `idx_waybill_tenant_driver_id`;
+-- ALTER TABLE `blade_loading_manage` DROP INDEX `idx_loading_manage_tenant_driver_id`;
+-- ALTER TABLE `blade_loading_manage` DROP COLUMN `driver_id`;

doc/sql/transport/blade_loading_manage_driver_id_backfill_20261028.sql

@@ -0,0 +1,239 @@
+-- ============================================================
+-- blade_loading_manage_driver_id_backfill_20261028.sql
+-- ============================================================
+-- 存量配载单补司机档案 ID：把「归属」从手机号快照切到 blade_transport_driver.id
+-- 写业务数据。第 0 节建存档表，第 1 节分批回填，第 2 节校验（只读，执行后必看），第 3 节回退。可重复执行。
+--
+-- 为什么要订正：
+--   票 01 之后配载单的归属键是 driver_id（blade_transport_driver.id），driver_phone 只是配载时的号码快照。
+--   存量配载单全部只有号码、没有 driver_id（票 01 才加的列），司机端按档案 ID 查配载单会一张都查不到；
+--   按号码反查又会踩二次放号与改号，所以才需要先按「唯一命中」把能确定的补齐。
+--   本脚本只处理「号码在本租户内唯一命中一条未删除档案」的配载单，其余留在原样、进清单等人工处置。
+--
+-- 判定与边界（严格按票面口径，不扩大）：
+--   ① 只动 driver_id IS NULL 的行。driver_id = -1 是「无主」哨兵，正数表示已有归属，两者一行都不动；
+--      第 1 节的 WHERE 里另加了一道显式排除（(driver_id = -1) IS NOT TRUE），
+--      防止后人把条件放宽成 driver_id <= 0 时把哨兵一起覆盖。
+--   ② 唯一命中：同租户内、is_deleted = 0、mobile 与 driver_phone 相等的档案恰好 1 条。
+--      命中 0 条 → 进「无法匹配」清单；命中 ≥2 条 → 进「冲突」清单。两类都跳过，不猜。
+--      逻辑删除的档案不参与命中：档案删了以后重跑脚本，不能把这些单挂到废弃档案上。
+--   ③ 手机号为空、空白、含 * 的跳过（* 是脱敏占位，不是真号码）。
+--   ④ driver_phone、update_time 与其它任何列都不改，只写 driver_id。
+--   ⑤ 逻辑删除的配载单同样回填：票面口径只有 driver_id IS NULL，不额外收窄范围；
+--      这些单不会回到列表，回填对它们无副作用。
+--   ⑥ 跨表比较显式 COLLATE：blade_loading_manage.driver_phone / tenant_id 是 utf8mb4_0900_ai_ci，
+--      blade_transport_driver.mobile / tenant_id 与存档表都是 utf8mb4_general_ci；
+--      不显式 COLLATE 会抛 ERROR 1267 Illegal mix of collations，只有真跑库才会暴露。
+--      第 2.4 节拿存档表比 driver_phone 同样要带 COLLATE utf8mb4_0900_ai_ci。
+--   ⑦ 取数与写入全在 SQL 内完成，不经 JSON / 客户端中转：19 位雪花 ID 过 JSON 会丢精度。
+--   ⑧ 分批执行（默认每批 500 行），每批独立提交，中断后重跑从剩余 NULL 行继续。
+--
+-- 范围说明：与运单脚本同一口径，只做「手机号 → 档案唯一命中」这一条规则；其余留给人工处置。
+-- 幂等：命中映射先落存档表；重复执行时映射新增 0 行、回填更新 0 行，结果不变（第 2.2 节校验）。
+-- 执行方式（脚本里有 DELIMITER 与存储过程，按分号切句的 GUI 客户端会切错）：
+--   mysql -h127.0.0.1 -uroot -p transport < blade_loading_manage_driver_id_backfill_20261028.sql
+
+-- ------------------------------------------------------------
+-- 0. 存档（必须在订正之前执行；重复执行不会覆盖已有存档）
+-- ------------------------------------------------------------
+-- 存档表同时是第 1 节的「命中映射」：一行 = 一个待回填的配载单 + 它唯一命中的档案 ID。
+-- 回填前先把映射定下来：回填只按映射写，跑之前就能看出「打算填谁」，回退也按它还原。
+CREATE TABLE IF NOT EXISTS blade_loading_manage_driver_id_bak_20261028 (
+  loading_id bigint NOT NULL COMMENT '配载单ID',
+  driver_id_before bigint DEFAULT NULL COMMENT '回填前的司机ID（本脚本只处理 NULL）',
+  driver_id_after bigint DEFAULT NULL COMMENT '回填写入的司机档案ID（blade_transport_driver.id）',
+  driver_phone varchar(50) COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '回填前的手机号快照，用来证明没有被改写',
+  update_time_before datetime DEFAULT NULL COMMENT '回填前的更新时间，用来证明没有被改写',
+  PRIMARY KEY (loading_id),
+  KEY idx_driver_id_after (driver_id_after)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='20261028 配载单司机档案ID回填存档';
+
+-- 命中映射：只收「号码唯一命中一条未删除档案」的 NULL 行。
+-- INSERT IGNORE + WHERE driver_id IS NULL：第二次执行不会重复建映射，已经填过的行不会再进映射。
+INSERT IGNORE INTO blade_loading_manage_driver_id_bak_20261028 (loading_id, driver_id_before, driver_id_after, driver_phone, update_time_before)
+SELECT matched.biz_id, NULL, matched.driver_id, matched.driver_phone, matched.update_time
+  FROM (
+        SELECT w.id AS biz_id,
+               MIN(d.id) AS driver_id,
+               w.driver_phone AS driver_phone,
+               w.update_time AS update_time
+          FROM blade_loading_manage w
+          JOIN blade_transport_driver d
+            ON d.tenant_id COLLATE utf8mb4_0900_ai_ci = w.tenant_id
+           AND d.mobile COLLATE utf8mb4_0900_ai_ci = w.driver_phone
+           AND d.is_deleted = 0
+         WHERE w.driver_id IS NULL
+           AND (w.driver_id = -1) IS NOT TRUE
+           AND w.driver_phone IS NOT NULL
+           AND TRIM(w.driver_phone) <> ''
+           AND w.driver_phone NOT LIKE '%*%'
+         GROUP BY w.id, w.driver_phone, w.update_time
+        HAVING COUNT(*) = 1
+       ) matched;
+
+-- ------------------------------------------------------------
+-- 1. 订正（分批回填，默认每批 500 行）
+-- ------------------------------------------------------------
+-- 循环退出条件是「这一批没有更新任何行」，所以重复执行时第一批就是 0 行，脚本空转结束。
+-- 每批单独提交（不开长事务）：大表上不会长时间持锁，中断后重跑从剩余 NULL 行继续。
+DELIMITER $$
+DROP PROCEDURE IF EXISTS backfill_blade_loading_manage_driver_id_20261028$$
+CREATE PROCEDURE backfill_blade_loading_manage_driver_id_20261028(IN p_batch_size INT)
+BEGIN
+  DECLARE v_batch_size INT DEFAULT 500;
+  DECLARE v_affected INT DEFAULT 0;
+
+  IF p_batch_size IS NOT NULL AND p_batch_size > 0 THEN
+    SET v_batch_size = p_batch_size;
+  END IF;
+
+  CREATE TEMPORARY TABLE IF NOT EXISTS tmp_loading_manage_driver_id_20261028 (
+    loading_id bigint NOT NULL,
+    PRIMARY KEY (loading_id)
+  ) ENGINE = InnoDB;
+
+  REPEAT
+    -- 取批：只取还空着的行，填过的行不再入批，所以每一批都在推进，不会原地打转
+    DELETE FROM tmp_loading_manage_driver_id_20261028;
+
+    INSERT INTO tmp_loading_manage_driver_id_20261028 (loading_id)
+    SELECT b.loading_id
+      FROM blade_loading_manage_driver_id_bak_20261028 b
+      JOIN blade_loading_manage w ON w.id = b.loading_id
+     WHERE w.driver_id IS NULL
+     ORDER BY b.loading_id
+     LIMIT v_batch_size;
+
+    UPDATE blade_loading_manage w
+      JOIN blade_loading_manage_driver_id_bak_20261028 b ON b.loading_id = w.id
+      JOIN tmp_loading_manage_driver_id_20261028 t ON t.loading_id = w.id
+       SET w.driver_id = b.driver_id_after
+     WHERE w.driver_id IS NULL
+       AND (w.driver_id = -1) IS NOT TRUE
+       AND b.driver_id_after IS NOT NULL;
+
+    SET v_affected = ROW_COUNT();
+  UNTIL v_affected = 0 END REPEAT;
+
+  DROP TEMPORARY TABLE IF EXISTS tmp_loading_manage_driver_id_20261028;
+END$$
+DELIMITER ;
+
+CALL backfill_blade_loading_manage_driver_id_20261028(500);
+DROP PROCEDURE IF EXISTS backfill_blade_loading_manage_driver_id_20261028;
+
+-- ------------------------------------------------------------
+-- 2. 校验（执行后必看；本节只有 SELECT，不动数据）
+-- ------------------------------------------------------------
+-- 2.1 规模：存档多少行、还剩多少 NULL 行、正数归属多少行（跑前跑后各查一次）
+--   remaining_null_rows 只会减少「本次命中」的那部分；差额应当等于第 2.7 节的命中行数。
+SELECT COUNT(*) AS archived_rows FROM blade_loading_manage_driver_id_bak_20261028;
+SELECT COUNT(*) AS remaining_null_rows FROM blade_loading_manage WHERE driver_id IS NULL;
+SELECT SUM(driver_id > 0) AS owned_rows,
+       SUM(driver_id = -1) AS sentinel_rows,
+       SUM(driver_id IS NULL) AS null_rows
+  FROM blade_loading_manage;
+
+-- 2.2 哨兵不变：跑前跑后各执行一次，四列必须完全相同（-1 一行都不能动）
+SELECT COUNT(*) AS sentinel_rows,
+       SUM(id) AS sentinel_id_sum,
+       MIN(id) AS min_id,
+       MAX(id) AS max_id
+  FROM blade_loading_manage
+ WHERE driver_id = -1;
+
+-- 2.3 写入正确：本次映射的行，driver_id 必须等于映射值（期望 0 行）
+SELECT COUNT(*) AS wrong_driver_id
+  FROM blade_loading_manage_driver_id_bak_20261028 b
+  JOIN blade_loading_manage w ON w.id = b.loading_id
+ WHERE NOT (w.driver_id <=> b.driver_id_after);
+
+-- 2.4 快照没有被改写：本次映射的行，driver_phone 与 update_time 必须与存档逐行一致（期望 0 行）
+SELECT COUNT(*) AS snapshot_rewritten
+  FROM blade_loading_manage_driver_id_bak_20261028 b
+  JOIN blade_loading_manage w ON w.id = b.loading_id
+ WHERE NOT (w.driver_phone <=> b.driver_phone COLLATE utf8mb4_0900_ai_ci)
+    OR NOT (w.update_time <=> b.update_time_before);
+
+-- 2.5 冲突清单：同号多档案，这些行被跳过（期望 0 行；有输出就是「为什么没填」的答案）
+SELECT w.driver_phone AS conflicting_phone,
+       COUNT(DISTINCT w.id) AS pending_rows,
+       COUNT(DISTINCT d.id) AS driver_profiles,
+       GROUP_CONCAT(DISTINCT d.id ORDER BY d.id) AS driver_profile_ids
+  FROM blade_loading_manage w
+  JOIN blade_transport_driver d
+    ON d.tenant_id COLLATE utf8mb4_0900_ai_ci = w.tenant_id
+   AND d.mobile COLLATE utf8mb4_0900_ai_ci = w.driver_phone
+   AND d.is_deleted = 0
+ WHERE w.driver_id IS NULL
+   AND (w.driver_id = -1) IS NOT TRUE
+   AND w.driver_phone IS NOT NULL
+   AND TRIM(w.driver_phone) <> ''
+   AND w.driver_phone NOT LIKE '%*%'
+ GROUP BY w.driver_phone
+HAVING COUNT(DISTINCT d.id) > 1;
+
+-- 2.6 无法匹配清单：号码在本租户内命中 0 条档案，这些行按规则跳过（等人工处置，脚本不猜）
+SELECT w.driver_phone AS unmatched_phone,
+       COUNT(*) AS pending_rows
+  FROM blade_loading_manage w
+ WHERE w.driver_id IS NULL
+   AND (w.driver_id = -1) IS NOT TRUE
+   AND w.driver_phone IS NOT NULL
+   AND TRIM(w.driver_phone) <> ''
+   AND w.driver_phone NOT LIKE '%*%'
+   AND NOT EXISTS (
+         SELECT 1
+           FROM blade_transport_driver d
+          WHERE d.tenant_id COLLATE utf8mb4_0900_ai_ci = w.tenant_id
+            AND d.mobile COLLATE utf8mb4_0900_ai_ci = w.driver_phone
+            AND d.is_deleted = 0)
+ GROUP BY w.driver_phone
+ ORDER BY pending_rows DESC, unmatched_phone;
+
+-- 2.7 逐司机对照：按手机号可见单量 vs 按档案 ID 可见单量
+--   by_phone        = 号码快照等于该档案号码的单量（旧口径，改号/二次放号会串）
+--   by_driver_id    = 档案 ID 等于该档案的单量（新口径）
+--   phone_only_null = 号码对上、但归属还空着的单（本次应被回填的那部分）
+--   phone_only_sentinel = 号码对上、但归属被标成 -1 无主的单（回填不碰，需要人工确认）
+--   phone_only_other_owner = 号码对上、却已归属另一条档案的单（改号/换司机后号码被复用）
+--   id_only_phone_differs = 已归属该档案、但号码快照不是该档案当前号码的单（改号后的历史快照）
+SELECT d.id AS driver_id,
+       d.driver_name,
+       d.mobile,
+       (SELECT COUNT(*) FROM blade_loading_manage w WHERE w.driver_id = d.id) AS by_driver_id,
+       (SELECT COUNT(*) FROM blade_loading_manage w
+         WHERE w.tenant_id COLLATE utf8mb4_0900_ai_ci = d.tenant_id
+           AND w.driver_phone COLLATE utf8mb4_0900_ai_ci = d.mobile) AS by_phone,
+       (SELECT COUNT(*) FROM blade_loading_manage w
+         WHERE w.tenant_id COLLATE utf8mb4_0900_ai_ci = d.tenant_id
+           AND w.driver_phone COLLATE utf8mb4_0900_ai_ci = d.mobile
+           AND w.driver_id IS NULL) AS phone_only_null,
+       (SELECT COUNT(*) FROM blade_loading_manage w
+         WHERE w.tenant_id COLLATE utf8mb4_0900_ai_ci = d.tenant_id
+           AND w.driver_phone COLLATE utf8mb4_0900_ai_ci = d.mobile
+           AND w.driver_id = -1) AS phone_only_sentinel,
+       (SELECT COUNT(*) FROM blade_loading_manage w
+         WHERE w.tenant_id COLLATE utf8mb4_0900_ai_ci = d.tenant_id
+           AND w.driver_phone COLLATE utf8mb4_0900_ai_ci = d.mobile
+           AND w.driver_id > 0
+           AND w.driver_id <> d.id) AS phone_only_other_owner,
+       (SELECT COUNT(*) FROM blade_loading_manage w
+         WHERE w.driver_id = d.id
+           AND (w.driver_phone IS NULL
+                OR NOT (w.driver_phone COLLATE utf8mb4_0900_ai_ci = d.mobile))) AS id_only_phone_differs
+  FROM blade_transport_driver d
+ WHERE d.is_deleted = 0
+ ORDER BY by_phone DESC, by_driver_id DESC, driver_id;
+
+-- ------------------------------------------------------------
+-- 3. 回退（仅在需要撤销本次回填时手工执行）
+-- ------------------------------------------------------------
+-- 按存档表把本次写入的行还原成 NULL。只还原「当前值仍等于本次写入值」的行：
+-- 回填之后又被人改派过的单不会被冲掉。
+-- UPDATE blade_loading_manage w
+--   JOIN blade_loading_manage_driver_id_bak_20261028 b ON b.loading_id = w.id
+--    SET w.driver_id = b.driver_id_before
+--  WHERE w.driver_id <=> b.driver_id_after;
+-- 回退只碰 driver_id，不碰 driver_phone / update_time。备份表确认不再需要时再删：
+-- DROP TABLE blade_loading_manage_driver_id_bak_20261028;

doc/sql/transport/blade_tms_business.sql

@@ -300,7 +300,8 @@ CREATE TABLE `blade_waybill` (
   KEY `idx_waybill_dept` (`dept_id`) USING BTREE,
   KEY `idx_waybill_plan_id` (`plan_id`) USING BTREE,
   KEY `idx_waybill_carrier_contract_id` (`carrier_contract_id`) USING BTREE,
-  KEY `idx_waybill_create_time` (`create_time`) USING BTREE
+  KEY `idx_waybill_create_time` (`create_time`) USING BTREE,
+  KEY `idx_waybill_tenant_driver_id` (`tenant_id`,`driver_id`) USING BTREE
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='运单管理';
 
 -- ----------------------------
@@ -330,6 +331,7 @@ CREATE TABLE `blade_loading_manage` (
   `trailer_vehicle_no` varchar(100) DEFAULT NULL COMMENT '挂车车牌号',
   `driver_name` varchar(100) DEFAULT NULL COMMENT '司机',
   `driver_phone` varchar(50) DEFAULT NULL COMMENT '联系电话',
+  `driver_id` bigint(20) DEFAULT NULL COMMENT '司机ID',
   `escort_name` varchar(100) DEFAULT NULL COMMENT '押运人',
   `escort_phone` varchar(50) DEFAULT NULL COMMENT '押运人手机号',
   `carrier_type` varchar(50) DEFAULT NULL COMMENT '承运类型',
@@ -359,7 +361,8 @@ CREATE TABLE `blade_loading_manage` (
   UNIQUE KEY `uk_loading_manage_no` (`loading_no`) USING BTREE,
   KEY `idx_loading_manage_carrier_contract_id` (`carrier_contract_id`) USING BTREE,
   KEY `idx_loading_manage_dept` (`dept_id`) USING BTREE,
-  KEY `idx_loading_manage_create_time` (`create_time`) USING BTREE
+  KEY `idx_loading_manage_create_time` (`create_time`) USING BTREE,
+  KEY `idx_loading_manage_tenant_driver_id` (`tenant_id`,`driver_id`) USING BTREE
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='配载管理';
 
 -- ----------------------------

doc/sql/transport/blade_waybill_driver_id_backfill_20261028.sql

@@ -0,0 +1,242 @@
+-- ============================================================
+-- blade_waybill_driver_id_backfill_20261028.sql
+-- ============================================================
+-- 存量运单补司机档案 ID：把「归属」从手机号快照切到 blade_transport_driver.id
+-- 写业务数据。第 0 节建存档表，第 1 节分批回填，第 2 节校验（只读，执行后必看），第 3 节回退。可重复执行。
+--
+-- 为什么要订正：
+--   票 01 之后运单的归属键是 driver_id（blade_transport_driver.id），driver_phone 只是派单时的号码快照。
+--   存量运单大多只有号码、没有 driver_id，司机端按档案 ID 查单会整批漏掉它们；
+--   按号码反查又会踩二次放号与改号（本机库实测：黄宇富档案已改号 15577122721，
+--   名下 92 张单仍写着旧号 17587421208，其中 20 张 driver_id 为空、5 张能从接单司机推出来，
+--   剩下 15 张号码已经对不上任何档案——本脚本不猜，它们会出现在第 2.6 节清单里）。
+--   本脚本只处理「号码在本租户内唯一命中一条未删除档案」的运单，其余留在原样、进清单等人工处置。
+--
+-- 判定与边界（严格按票面口径，不扩大）：
+--   ① 只动 driver_id IS NULL 的行。driver_id = -1 是「无主」哨兵，正数表示已有归属，两者一行都不动；
+--      第 1 节的 WHERE 里另加了一道显式排除（(driver_id = -1) IS NOT TRUE），
+--      防止后人把条件放宽成 driver_id <= 0 时把哨兵一起覆盖。
+--   ② 唯一命中：同租户内、is_deleted = 0、mobile 与 driver_phone 相等的档案恰好 1 条。
+--      命中 0 条 → 进「无法匹配」清单；命中 ≥2 条 → 进「冲突」清单。两类都跳过，不猜。
+--      逻辑删除的档案不参与命中：档案删了以后重跑脚本，不能把这些单挂到废弃档案上。
+--   ③ 手机号为空、空白、含 * 的跳过（* 是脱敏占位，不是真号码）。
+--   ④ driver_phone、update_time 与其它任何列都不改，只写 driver_id。
+--   ⑤ 逻辑删除的运单同样回填：票面口径只有 driver_id IS NULL，不额外收窄范围；
+--      这些单不会回到列表，回填对它们无副作用。
+--   ⑥ 跨表比较显式 COLLATE：blade_waybill.driver_phone / tenant_id 是 utf8mb4_0900_ai_ci，
+--      blade_transport_driver.mobile / tenant_id 与存档表都是 utf8mb4_general_ci；
+--      不显式 COLLATE 会抛 ERROR 1267 Illegal mix of collations，只有真跑库才会暴露。
+--      第 2.4 节拿存档表比 driver_phone 同样要带 COLLATE utf8mb4_0900_ai_ci。
+--   ⑦ 取数与写入全在 SQL 内完成，不经 JSON / 客户端中转：19 位雪花 ID 过 JSON 会丢精度。
+--   ⑧ 分批执行（默认每批 500 行），每批独立提交，中断后重跑从剩余 NULL 行继续。
+--
+-- 范围说明：本脚本只做「手机号 → 档案唯一命中」这一条规则。
+--   不引入 driver_accept_driver_id 推断，也不按姓名/历史号码猜归属：这些属于人工处置，在票面范围外。
+-- 幂等：命中映射先落存档表；重复执行时映射新增 0 行、回填更新 0 行，结果不变（第 2.2 节校验）。
+-- 执行方式（脚本里有 DELIMITER 与存储过程，按分号切句的 GUI 客户端会切错）：
+--   mysql -h127.0.0.1 -uroot -p transport < blade_waybill_driver_id_backfill_20261028.sql
+
+-- ------------------------------------------------------------
+-- 0. 存档（必须在订正之前执行；重复执行不会覆盖已有存档）
+-- ------------------------------------------------------------
+-- 存档表同时是第 1 节的「命中映射」：一行 = 一个待回填的运单 + 它唯一命中的档案 ID。
+-- 回填前先把映射定下来：回填只按映射写，跑之前就能看出「打算填谁」，回退也按它还原。
+CREATE TABLE IF NOT EXISTS blade_waybill_driver_id_bak_20261028 (
+  waybill_id bigint NOT NULL COMMENT '运单ID',
+  driver_id_before bigint DEFAULT NULL COMMENT '回填前的司机ID（本脚本只处理 NULL）',
+  driver_id_after bigint DEFAULT NULL COMMENT '回填写入的司机档案ID（blade_transport_driver.id）',
+  driver_phone varchar(50) COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '回填前的手机号快照，用来证明没有被改写',
+  update_time_before datetime DEFAULT NULL COMMENT '回填前的更新时间，用来证明没有被改写',
+  PRIMARY KEY (waybill_id),
+  KEY idx_driver_id_after (driver_id_after)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='20261028 运单司机档案ID回填存档';
+
+-- 命中映射：只收「号码唯一命中一条未删除档案」的 NULL 行。
+-- INSERT IGNORE + WHERE driver_id IS NULL：第二次执行不会重复建映射，已经填过的行不会再进映射。
+INSERT IGNORE INTO blade_waybill_driver_id_bak_20261028 (waybill_id, driver_id_before, driver_id_after, driver_phone, update_time_before)
+SELECT matched.biz_id, NULL, matched.driver_id, matched.driver_phone, matched.update_time
+  FROM (
+        SELECT w.id AS biz_id,
+               MIN(d.id) AS driver_id,
+               w.driver_phone AS driver_phone,
+               w.update_time AS update_time
+          FROM blade_waybill w
+          JOIN blade_transport_driver d
+            ON d.tenant_id COLLATE utf8mb4_0900_ai_ci = w.tenant_id
+           AND d.mobile COLLATE utf8mb4_0900_ai_ci = w.driver_phone
+           AND d.is_deleted = 0
+         WHERE w.driver_id IS NULL
+           AND (w.driver_id = -1) IS NOT TRUE
+           AND w.driver_phone IS NOT NULL
+           AND TRIM(w.driver_phone) <> ''
+           AND w.driver_phone NOT LIKE '%*%'
+         GROUP BY w.id, w.driver_phone, w.update_time
+        HAVING COUNT(*) = 1
+       ) matched;
+
+-- ------------------------------------------------------------
+-- 1. 订正（分批回填，默认每批 500 行）
+-- ------------------------------------------------------------
+-- 循环退出条件是「这一批没有更新任何行」，所以重复执行时第一批就是 0 行，脚本空转结束。
+-- 每批单独提交（不开长事务）：大表上不会长时间持锁，中断后重跑从剩余 NULL 行继续。
+DELIMITER $$
+DROP PROCEDURE IF EXISTS backfill_blade_waybill_driver_id_20261028$$
+CREATE PROCEDURE backfill_blade_waybill_driver_id_20261028(IN p_batch_size INT)
+BEGIN
+  DECLARE v_batch_size INT DEFAULT 500;
+  DECLARE v_affected INT DEFAULT 0;
+
+  IF p_batch_size IS NOT NULL AND p_batch_size > 0 THEN
+    SET v_batch_size = p_batch_size;
+  END IF;
+
+  CREATE TEMPORARY TABLE IF NOT EXISTS tmp_waybill_driver_id_20261028 (
+    waybill_id bigint NOT NULL,
+    PRIMARY KEY (waybill_id)
+  ) ENGINE = InnoDB;
+
+  REPEAT
+    -- 取批：只取还空着的行，填过的行不再入批，所以每一批都在推进，不会原地打转
+    DELETE FROM tmp_waybill_driver_id_20261028;
+
+    INSERT INTO tmp_waybill_driver_id_20261028 (waybill_id)
+    SELECT b.waybill_id
+      FROM blade_waybill_driver_id_bak_20261028 b
+      JOIN blade_waybill w ON w.id = b.waybill_id
+     WHERE w.driver_id IS NULL
+     ORDER BY b.waybill_id
+     LIMIT v_batch_size;
+
+    UPDATE blade_waybill w
+      JOIN blade_waybill_driver_id_bak_20261028 b ON b.waybill_id = w.id
+      JOIN tmp_waybill_driver_id_20261028 t ON t.waybill_id = w.id
+       SET w.driver_id = b.driver_id_after
+     WHERE w.driver_id IS NULL
+       AND (w.driver_id = -1) IS NOT TRUE
+       AND b.driver_id_after IS NOT NULL;
+
+    SET v_affected = ROW_COUNT();
+  UNTIL v_affected = 0 END REPEAT;
+
+  DROP TEMPORARY TABLE IF EXISTS tmp_waybill_driver_id_20261028;
+END$$
+DELIMITER ;
+
+CALL backfill_blade_waybill_driver_id_20261028(500);
+DROP PROCEDURE IF EXISTS backfill_blade_waybill_driver_id_20261028;
+
+-- ------------------------------------------------------------
+-- 2. 校验（执行后必看；本节只有 SELECT，不动数据）
+-- ------------------------------------------------------------
+-- 2.1 规模：存档多少行、还剩多少 NULL 行、正数归属多少行（跑前跑后各查一次）
+--   remaining_null_rows 只会减少「本次命中」的那部分；差额应当等于第 2.7 节的命中行数。
+SELECT COUNT(*) AS archived_rows FROM blade_waybill_driver_id_bak_20261028;
+SELECT COUNT(*) AS remaining_null_rows FROM blade_waybill WHERE driver_id IS NULL;
+SELECT SUM(driver_id > 0) AS owned_rows,
+       SUM(driver_id = -1) AS sentinel_rows,
+       SUM(driver_id IS NULL) AS null_rows
+  FROM blade_waybill;
+
+-- 2.2 哨兵不变：跑前跑后各执行一次，四列必须完全相同（-1 一行都不能动）
+SELECT COUNT(*) AS sentinel_rows,
+       SUM(id) AS sentinel_id_sum,
+       MIN(id) AS min_id,
+       MAX(id) AS max_id
+  FROM blade_waybill
+ WHERE driver_id = -1;
+
+-- 2.3 写入正确：本次映射的行，driver_id 必须等于映射值（期望 0 行）
+SELECT COUNT(*) AS wrong_driver_id
+  FROM blade_waybill_driver_id_bak_20261028 b
+  JOIN blade_waybill w ON w.id = b.waybill_id
+ WHERE NOT (w.driver_id <=> b.driver_id_after);
+
+-- 2.4 快照没有被改写：本次映射的行，driver_phone 与 update_time 必须与存档逐行一致（期望 0 行）
+SELECT COUNT(*) AS snapshot_rewritten
+  FROM blade_waybill_driver_id_bak_20261028 b
+  JOIN blade_waybill w ON w.id = b.waybill_id
+ WHERE NOT (w.driver_phone <=> b.driver_phone COLLATE utf8mb4_0900_ai_ci)
+    OR NOT (w.update_time <=> b.update_time_before);
+
+-- 2.5 冲突清单：同号多档案，这些行被跳过（期望 0 行；有输出就是「为什么没填」的答案）
+SELECT w.driver_phone AS conflicting_phone,
+       COUNT(DISTINCT w.id) AS pending_rows,
+       COUNT(DISTINCT d.id) AS driver_profiles,
+       GROUP_CONCAT(DISTINCT d.id ORDER BY d.id) AS driver_profile_ids
+  FROM blade_waybill w
+  JOIN blade_transport_driver d
+    ON d.tenant_id COLLATE utf8mb4_0900_ai_ci = w.tenant_id
+   AND d.mobile COLLATE utf8mb4_0900_ai_ci = w.driver_phone
+   AND d.is_deleted = 0
+ WHERE w.driver_id IS NULL
+   AND (w.driver_id = -1) IS NOT TRUE
+   AND w.driver_phone IS NOT NULL
+   AND TRIM(w.driver_phone) <> ''
+   AND w.driver_phone NOT LIKE '%*%'
+ GROUP BY w.driver_phone
+HAVING COUNT(DISTINCT d.id) > 1;
+
+-- 2.6 无法匹配清单：号码在本租户内命中 0 条档案，这些行按规则跳过（等人工处置，脚本不猜）
+SELECT w.driver_phone AS unmatched_phone,
+       COUNT(*) AS pending_rows
+  FROM blade_waybill w
+ WHERE w.driver_id IS NULL
+   AND (w.driver_id = -1) IS NOT TRUE
+   AND w.driver_phone IS NOT NULL
+   AND TRIM(w.driver_phone) <> ''
+   AND w.driver_phone NOT LIKE '%*%'
+   AND NOT EXISTS (
+         SELECT 1
+           FROM blade_transport_driver d
+          WHERE d.tenant_id COLLATE utf8mb4_0900_ai_ci = w.tenant_id
+            AND d.mobile COLLATE utf8mb4_0900_ai_ci = w.driver_phone
+            AND d.is_deleted = 0)
+ GROUP BY w.driver_phone
+ ORDER BY pending_rows DESC, unmatched_phone;
+
+-- 2.7 逐司机对照：按手机号可见单量 vs 按档案 ID 可见单量
+--   by_phone        = 号码快照等于该档案号码的单量（旧口径，改号/二次放号会串）
+--   by_driver_id    = 档案 ID 等于该档案的单量（新口径）
+--   phone_only_null = 号码对上、但归属还空着的单（本次应被回填的那部分）
+--   phone_only_sentinel = 号码对上、但归属被标成 -1 无主的单（回填不碰，需要人工确认）
+--   phone_only_other_owner = 号码对上、却已归属另一条档案的单（改号/换司机后号码被复用）
+--   id_only_phone_differs = 已归属该档案、但号码快照不是该档案当前号码的单（改号后的历史快照）
+SELECT d.id AS driver_id,
+       d.driver_name,
+       d.mobile,
+       (SELECT COUNT(*) FROM blade_waybill w WHERE w.driver_id = d.id) AS by_driver_id,
+       (SELECT COUNT(*) FROM blade_waybill w
+         WHERE w.tenant_id COLLATE utf8mb4_0900_ai_ci = d.tenant_id
+           AND w.driver_phone COLLATE utf8mb4_0900_ai_ci = d.mobile) AS by_phone,
+       (SELECT COUNT(*) FROM blade_waybill w
+         WHERE w.tenant_id COLLATE utf8mb4_0900_ai_ci = d.tenant_id
+           AND w.driver_phone COLLATE utf8mb4_0900_ai_ci = d.mobile
+           AND w.driver_id IS NULL) AS phone_only_null,
+       (SELECT COUNT(*) FROM blade_waybill w
+         WHERE w.tenant_id COLLATE utf8mb4_0900_ai_ci = d.tenant_id
+           AND w.driver_phone COLLATE utf8mb4_0900_ai_ci = d.mobile
+           AND w.driver_id = -1) AS phone_only_sentinel,
+       (SELECT COUNT(*) FROM blade_waybill w
+         WHERE w.tenant_id COLLATE utf8mb4_0900_ai_ci = d.tenant_id
+           AND w.driver_phone COLLATE utf8mb4_0900_ai_ci = d.mobile
+           AND w.driver_id > 0
+           AND w.driver_id <> d.id) AS phone_only_other_owner,
+       (SELECT COUNT(*) FROM blade_waybill w
+         WHERE w.driver_id = d.id
+           AND (w.driver_phone IS NULL
+                OR NOT (w.driver_phone COLLATE utf8mb4_0900_ai_ci = d.mobile))) AS id_only_phone_differs
+  FROM blade_transport_driver d
+ WHERE d.is_deleted = 0
+ ORDER BY by_phone DESC, by_driver_id DESC, driver_id;
+
+-- ------------------------------------------------------------
+-- 3. 回退（仅在需要撤销本次回填时手工执行）
+-- ------------------------------------------------------------
+-- 按存档表把本次写入的行还原成 NULL。只还原「当前值仍等于本次写入值」的行：
+-- 回填之后又被人改派过的单不会被冲掉。
+-- UPDATE blade_waybill w
+--   JOIN blade_waybill_driver_id_bak_20261028 b ON b.waybill_id = w.id
+--    SET w.driver_id = b.driver_id_before
+--  WHERE w.driver_id <=> b.driver_id_after;
+-- 回退只碰 driver_id，不碰 driver_phone / update_time。备份表确认不再需要时再删：
+-- DROP TABLE blade_waybill_driver_id_bak_20261028;