优化

lastleg-service/AGENTS.md

@@ -20,6 +20,7 @@
 | 尾程订单、明细、状态历史 | `entity/LastlegOrder.java`、`LastlegOrderDetail.java`、`LastlegOrderStatusHistory.java` 及对应 Mapper |
 | 独立尾程入仓单快照 | `entity/LastlegInboundOrder.java`、`mapper/LastlegInboundOrderMapper.java`；按客户与来源入仓标识冻结 inboundCode、来源/根订单及目的仓，不以尾程订单行代替入仓单聚合 |
 | 内部令牌保护 | `security/InternalServiceTokenGuard.java` |
+| IAM 海外安全投影与实时校验 | 内部入口 `security/controller/LastlegSecurityController.java`，固定 `/internal/lastleg/security/v1/events`、`/validate` 且复用 `InternalServiceTokenGuard`；投影/校验 `security/service/`，DTO `security/dto/`，表固定 `ll_security_event_inbox`、`ll_security_projection`；MySQL 投影缺失、落后或不可用一律 fail-closed，Redis 仅为提交后可重建镜像；业务切片不得直接依赖投影内部类，边界由 `SecurityProjectionArchitectureTest` 与 Node 合同锁定 |
 | 入仓计划分页、转换与详情 | `inboundplan/controller/InboundPlanController.java`、`inboundplan/dto/InboundPlanRequests.java`、`InboundPlanListResponse.java`、`inboundplan/mapper/InboundPlanQueryMapper.java`、`inboundplan/service/InboundPlanService.java` |
 | 托盘分配算法 | `inboundplan/service/PalletAllocator.java` |
 | FBA 预约创建、详情与编辑 | `InboundPlanController.java` 的 `/fba-appointments/**`、`inboundplan/service/InboundFbaAppointmentService.java`、`BatchFbaAppointmentRequest.java`、`UpdateFbaAppointmentRequest.java` |
@@ -62,6 +63,7 @@
 | 一件代发与废弃 | `ll_dropship_*`、`ll_cargo_discard_*` | 托盘/箱唛库存、流水和废弃审批 |
 | 采购、卡车与本土散板 | `ll_overseas_procurement_*`、`ll_us_truck_*`、`ll_local_looseboard_*` | 海外采购、美国卡车运输及本土散板订单 |
 | 通用资料 | `ll_overseas_quote*`、`ll_monthly_exchange_rate*`、`ll_vehicle` | 海外仓报价、月度汇率及车辆档案；不保存车辆派送履约历史 |
+| 海外安全投影 | `ll_security_event_inbox`、`ll_security_projection` | IAM 安全事件可靠收件箱与 Lastleg 本地授权投影；只允许内部服务入口访问，不作为 loading、shipping、inbound 等业务模型 |
 
 - 新增或修改表时，表 `COMMENT` 和每个普通字段的 `COMMENT` 必须填写准确的中文业务含义，不得只写英文、字段名或类型名。
 - `SchemaChineseCommentContractTest` 自动扫描全部 `ll_` 表，无需维护表名白名单；新增字段必须同步更新基线 SQL、建表增量和存量备注迁移，增量脚本的 `ADD/MODIFY COLUMN` 不得丢失中文备注。
@@ -76,6 +78,9 @@
 - 整个事件消费在一个事务内完成；任意订单失败时不得留下部分订单。
 - 相同事件重复投递返回既有结果，不重新生成单号或插入明细。来源入仓单唯一约束是最终防线。
 - 内部接口先执行常量时间令牌校验；缺失或错误令牌不得进入消费事务。
+- IAM 安全事件只能进入 `/internal/lastleg/security/v1/events`；通用 `/internal/lastleg/events` 只白名单接收装柜完成与实际船节点事件，禁止把 IAM 事件交给 `LoadingCompletedConsumer`。
+- Lastleg 安全投影只接受 `ACTIVE`/`DISABLED` 两态安全语义；客户建档和审核的 `PROFILE_REQUIRED`/`PENDING`/`REJECTED`/`ARCHIVED` 由 IAM 在发布前统一折叠为 `DISABLED`，Lastleg 不兼容或解释国内工作流状态。
+- 开发基线只为国内固定 `authUserId=1000001`、`tenantId=0` 的 `platform_admin` 写 USER/AUTHORIZATION version=0 投影；使用 `INSERT IGNORE`，后续 IAM version>=1 事件单调覆盖。不得扩大为历史账号运行时补齐或缺失投影默认放行。
 - PDA 入仓任务完成前必须先通过 `/unload-photos` 保存非空且不重复的卸柜照片文件 ID；照片上传时间由服务端记录，预计报空时间固定为照片上传时间加两天。完成入仓时，库存入账、计划/任务状态推进与 `OVERSEAS_CONTAINER_UNLOADED` V1 Outbox 必须处于同一事务；事件绑定来源头程货柜身份，不得从前端请求拼装或回查头程数据库。
 - 海外 PDA 柜号签收只允许平台 `WAREHOUSE_PICKER` 使用 `lastleg:pda:operate`；PDA 不接收 `customerId`，候选跨客户读取，选柜时从柜内计划唯一解析并冻结真实客户。未完成会话按平台操作账号和柜号分别全局唯一，后续照片、扫码、实收、库存与完成操作只使用会话客户范围；平台管理员和客户账号不得进入该作业入口。
 
@@ -94,6 +99,7 @@
 ## 修改与验证
 
 - 移动包、拆分端口/适配器或引入新的跨子域依赖时，先核对内部模块化基线并运行 `node --test scripts/analyze-lastleg-dependencies.test.mjs`；确需更新依赖基线时必须说明稳定边界变化，不能把临时循环依赖登记为长期豁免。
+- 安全投影边界变更同时运行 `SecurityProjectionArchitectureTest` 与 `LastlegSecurityContractTest`；`security/controller|dto|service` 只允许依赖本子域和根 `InternalServiceTokenGuard`，其他 Lastleg 业务包不得直接依赖这些投影内部包。
 - 表字段、注释和索引同步维护基线 SQL 与统一增量 SQL；生产/存量库只执行增量脚本。
 - 事件契约变化同时检查 `common-event-contract` 版本、Event Bridge 消费方和旧 Payload 哈希兼容。
 - 定向验证：`mvn -pl lastleg -am test`。

lastleg-service/pom.xml

@@ -19,6 +19,7 @@
         <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-actuator</artifactId></dependency>
         <dependency><groupId>com.mysql</groupId><artifactId>mysql-connector-j</artifactId><scope>runtime</scope></dependency>
         <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency>
+        <dependency><groupId>com.tngtech.archunit</groupId><artifactId>archunit</artifactId><scope>test</scope></dependency>
     </dependencies>
     <build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build>
 </project>

lastleg-service/scripts/analyze-lastleg-dependencies.mjs

@@ -12,6 +12,7 @@ const sourceRoots = {
 const internalPrefix = 'com.baiyue.lastleg.';
 
 const sliceRules = [
+  ['security-projection', /(?:^|\.)security\.(?:controller|dto|service)(?:\.|$)/],
   ['dispatch-delivery', /(?:^|\.)(?:dispatch|delivery|outbound)(?:\.|$)/],
   ['relabel-transfer-discard', /(?:^|\.)(?:relabel|transfer|discard)(?:\.|$)/],
   ['inbound-pda', /(?:^|\.)(?:inboundplan|palletops|pda)(?:\.|$)/],

lastleg-service/scripts/analyze-lastleg-dependencies.test.mjs

@@ -74,3 +74,25 @@ test('vehicle application only depends inward and stays free of adapter framewor
     && edge.target.startsWith('com.baiyue.lastleg.') && !edge.target.startsWith(prefix));
   assert.deepEqual(outwardDependencies, []);
 });
+
+test('security projection stays isolated from Lastleg business slices', () => {
+  const report = analyze();
+  const projectionClasses = report.classes.filter(entry => entry.slice === 'security-projection');
+  const projectionNames = new Set(projectionClasses.map(entry => entry.fqcn));
+  assert.deepEqual(projectionClasses.map(entry => entry.fqcn).sort(), [
+    'com.baiyue.lastleg.security.controller.LastlegSecurityController',
+    'com.baiyue.lastleg.security.dto.LastlegSecurityDtos',
+    'com.baiyue.lastleg.security.service.LastlegSecurityProjectionRedisMirror',
+    'com.baiyue.lastleg.security.service.LastlegSecurityProjectionService',
+    'com.baiyue.lastleg.security.service.LastlegSecurityValidationService',
+    'com.baiyue.lastleg.security.service.SecurityProjectionMonotonicity',
+  ]);
+  assert.deepEqual(report.sliceEdges.filter(edge => edge.source === 'security-projection'), [
+    { source: 'security-projection', target: 'shared-technical', count: 1 },
+  ]);
+  assert.deepEqual(report.sliceEdges.filter(edge => edge.target === 'security-projection'), []);
+  assert.equal(report.sliceSccs.some(component => component.includes('security-projection')), false);
+  const businessConsumers = report.classDependencies.filter(edge => projectionNames.has(edge.target)
+    && !projectionNames.has(edge.source));
+  assert.deepEqual(businessConsumers, []);
+});

lastleg-service/src/main/java/com/baiyue/lastleg/security/controller/LastlegSecurityController.java

@@ -0,0 +1,53 @@
+package com.baiyue.lastleg.security.controller;
+
+import com.baiyue.common.core.api.ApiResponse;
+import com.baiyue.common.event.EventEnvelope;
+import com.baiyue.lastleg.security.InternalServiceTokenGuard;
+import com.baiyue.lastleg.security.dto.LastlegSecurityDtos.Acknowledgement;
+import com.baiyue.lastleg.security.dto.LastlegSecurityDtos.ValidationRequest;
+import com.baiyue.lastleg.security.dto.LastlegSecurityDtos.ValidationResponse;
+import com.baiyue.lastleg.security.service.LastlegSecurityProjectionService;
+import com.baiyue.lastleg.security.service.LastlegSecurityValidationService;
+import io.swagger.v3.oas.annotations.Hidden;
+import jakarta.validation.Valid;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestHeader;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.time.Instant;
+
+@Hidden
+@RestController
+@RequestMapping("/internal/lastleg/security/v1")
+public class LastlegSecurityController {
+    private final InternalServiceTokenGuard tokenGuard;
+    private final LastlegSecurityProjectionService projections;
+    private final LastlegSecurityValidationService validations;
+
+    public LastlegSecurityController(InternalServiceTokenGuard tokenGuard,
+                                     LastlegSecurityProjectionService projections,
+                                     LastlegSecurityValidationService validations) {
+        this.tokenGuard = tokenGuard;
+        this.projections = projections;
+        this.validations = validations;
+    }
+
+    @PostMapping("/events")
+    public ApiResponse<Acknowledgement> receive(
+            @RequestHeader(value = "X-Internal-Service-Token", required = false) String token,
+            @RequestBody EventEnvelope envelope) {
+        tokenGuard.verify(token);
+        var result = projections.consume(envelope);
+        return ApiResponse.success(new Acknowledgement(envelope.eventId(), result.result(), Instant.now()));
+    }
+
+    @PostMapping("/validate")
+    public ApiResponse<ValidationResponse> validate(
+            @RequestHeader(value = "X-Internal-Service-Token", required = false) String token,
+            @Valid @RequestBody ValidationRequest request) {
+        tokenGuard.verify(token);
+        return ApiResponse.success(validations.validate(request));
+    }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/security/dto/LastlegSecurityDtos.java

@@ -0,0 +1,31 @@
+package com.baiyue.lastleg.security.dto;
+
+import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.NotNull;
+
+import java.time.Instant;
+
+public final class LastlegSecurityDtos {
+    private LastlegSecurityDtos() { }
+
+    public record Acknowledgement(String eventId, String result, Instant receivedAt) { }
+
+    public record ValidationRequest(@NotNull @Min(1) Long userId,
+                                    @NotNull @Min(0) Long tenantId,
+                                    @NotNull @Min(0) Long permissionVersion) { }
+
+    public record ValidationResponse(boolean valid, FailureReason failureReason) {
+        public static ValidationResponse accepted() { return new ValidationResponse(true, null); }
+        public static ValidationResponse rejected(FailureReason reason) {
+            return new ValidationResponse(false, reason);
+        }
+    }
+
+    public enum FailureReason {
+        SECURITY_PROJECTION_MISSING,
+        SECURITY_PROJECTION_NOT_READY,
+        USER_DISABLED,
+        TENANT_DISABLED,
+        PERMISSION_VERSION_STALE
+    }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/security/service/LastlegSecurityProjectionRedisMirror.java

@@ -0,0 +1,36 @@
+package com.baiyue.lastleg.security.service;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.data.redis.core.StringRedisTemplate;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.event.TransactionPhase;
+import org.springframework.transaction.event.TransactionalEventListener;
+
+/** 非授权真相的可重建 Redis 镜像；失败不影响已提交的 MySQL 投影。 */
+@Component
+@Slf4j
+public class LastlegSecurityProjectionRedisMirror {
+    private final StringRedisTemplate redis;
+    private final ObjectMapper objectMapper;
+    @Value("${baiyue.security.permission-snapshot-key-prefix:baiyue:permission-snapshot}")
+    private String keyPrefix;
+
+    public LastlegSecurityProjectionRedisMirror(StringRedisTemplate redis, ObjectMapper objectMapper) {
+        this.redis = redis;
+        this.objectMapper = objectMapper;
+    }
+
+    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
+    public void mirror(LastlegSecurityProjectionService.ProjectionChanged event) {
+        var value = event.projection();
+        try {
+            redis.opsForValue().set(keyPrefix + ':' + value.aggregateType() + ':' + value.aggregateId(),
+                    objectMapper.writeValueAsString(value));
+        } catch (Exception exception) {
+            log.warn("海外安全投影 Redis 镜像写入失败 aggregateType={}, aggregateId={}",
+                    value.aggregateType(), value.aggregateId());
+        }
+    }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/security/service/LastlegSecurityProjectionService.java

@@ -0,0 +1,188 @@
+package com.baiyue.lastleg.security.service;
+
+import com.baiyue.common.core.api.ResultCode;
+import com.baiyue.common.core.exception.BizException;
+import com.baiyue.common.event.EventEnvelope;
+import com.baiyue.common.event.EventPayloadCanonicalizer;
+import com.baiyue.common.event.EventPayloadHash;
+import com.baiyue.common.event.EventTypes;
+import com.baiyue.common.event.IamSecurityEventsV1;
+import com.baiyue.common.event.RegionCode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.dao.DuplicateKeyException;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.Instant;
+import java.util.List;
+import java.util.Locale;
+import java.util.Objects;
+
+@Service
+public class LastlegSecurityProjectionService {
+    private static final List<String> TYPES = List.of(EventTypes.IAM_USER_STATUS_CHANGED,
+            EventTypes.IAM_TENANT_STATUS_CHANGED, EventTypes.IAM_PERMISSION_VERSION_CHANGED);
+    private final JdbcTemplate jdbc;
+    private final ObjectMapper objectMapper;
+    private final ApplicationEventPublisher events;
+
+    public LastlegSecurityProjectionService(JdbcTemplate jdbc, ObjectMapper objectMapper,
+                                             ApplicationEventPublisher events) {
+        this.jdbc = jdbc;
+        this.objectMapper = objectMapper;
+        this.events = events;
+    }
+
+    @Transactional
+    public ConsumeResult consume(EventEnvelope envelope) {
+        envelope.requireValid();
+        requireSecurityEnvelope(envelope);
+        String payloadHash = validatedStorageHash(envelope);
+        String payloadJson = envelope.payload().toString();
+        try {
+            jdbc.update("INSERT INTO ll_security_event_inbox(event_id,event_type,payload_hash,payload_json,status,received_at) "
+                    + "VALUES (?,?,?,?, 'RECEIVED', NOW(3))", envelope.eventId(), envelope.eventType(),
+                    payloadHash, payloadJson);
+        } catch (DuplicateKeyException duplicate) {
+            InboxRow existing = jdbc.queryForObject(
+                    "SELECT event_type,payload_hash,status FROM ll_security_event_inbox "
+                            + "WHERE event_id=? FOR UPDATE",
+                    (rs, row) -> new InboxRow(rs.getString(1), rs.getString(2), rs.getString(3)),
+                    envelope.eventId());
+            if (existing == null || !Objects.equals(existing.eventType(), envelope.eventType())
+                    || existing.payloadHash() == null
+                    || !existing.payloadHash().equalsIgnoreCase(payloadHash)) {
+                throw new BizException(ResultCode.CONFLICT, "相同 eventId 的 payloadHash 冲突");
+            }
+            if ("PROCESSED".equals(existing.status())) return new ConsumeResult("DUPLICATE", null);
+        }
+
+        ProjectionInput input = input(envelope, payloadHash);
+        ProjectionRow current = findForUpdate(input.aggregateType(), input.aggregateId());
+        SecurityProjectionMonotonicity.Decision decision = SecurityProjectionMonotonicity.decide(
+                current == null ? null : current.aggregateVersion(), current == null ? null : current.payloadHash(),
+                input.aggregateVersion(), input.payloadHash());
+        String result = decision.name();
+        if (decision == SecurityProjectionMonotonicity.Decision.APPLY) {
+            upsert(input);
+            result = "APPLIED";
+            events.publishEvent(new ProjectionChanged(input));
+        }
+        jdbc.update("UPDATE ll_security_event_inbox SET status='PROCESSED',result=?,processed_at=NOW(3) "
+                + "WHERE event_id=?", result, envelope.eventId());
+        return new ConsumeResult(result, input);
+    }
+
+    private void requireSecurityEnvelope(EventEnvelope envelope) {
+        if (!TYPES.contains(envelope.eventType()) || envelope.eventVersion() != IamSecurityEventsV1.VERSION
+                || envelope.sourceRegion() != RegionCode.CN || envelope.targetRegion() != RegionCode.OVERSEAS) {
+            throw new BizException(ResultCode.BAD_REQUEST, "仅接受 CN→OVERSEAS IAM V1 安全事件");
+        }
+    }
+
+    static String validatedStorageHash(EventEnvelope envelope) {
+        if (!EventPayloadHash.matches(EventPayloadCanonicalizer.canonicalize(envelope.payload()),
+                envelope.payloadHash())) {
+            throw new BizException(ResultCode.BAD_REQUEST, "payloadHash 与 IAM 安全事件负载不一致");
+        }
+        // 表内只保存固定 64 位摘要；信封传输契约仍保留 sha256: 前缀。
+        return envelope.payloadHash().substring("sha256:".length()).toLowerCase(Locale.ROOT);
+    }
+
+    private ProjectionInput input(EventEnvelope envelope, String payloadHash) {
+        try {
+            return switch (envelope.eventType()) {
+                case EventTypes.IAM_USER_STATUS_CHANGED -> {
+                    var value = objectMapper.treeToValue(envelope.payload(),
+                            IamSecurityEventsV1.UserStatusChanged.class);
+                    requireIdentity(envelope, "USER", value.authUserId(), value.tenantId());
+                    requirePayload(value.status(), value.changedAt(), value.permissionVersion(),
+                            envelope.aggregateVersion());
+                    requireStatus(value.status());
+                    yield new ProjectionInput("USER", String.valueOf(value.authUserId()), value.tenantId(),
+                            value.status(), value.permissionVersion(), envelope.aggregateVersion(),
+                            payloadHash, envelope.eventId(), value.changedAt());
+                }
+                case EventTypes.IAM_TENANT_STATUS_CHANGED -> {
+                    var value = objectMapper.treeToValue(envelope.payload(),
+                            IamSecurityEventsV1.TenantStatusChanged.class);
+                    requireIdentity(envelope, "TENANT", value.tenantId(), value.tenantId());
+                    requirePayload(value.status(), value.changedAt(), envelope.aggregateVersion(),
+                            envelope.aggregateVersion());
+                    requireStatus(value.status());
+                    yield new ProjectionInput("TENANT", String.valueOf(value.tenantId()), value.tenantId(),
+                            value.status(), null, envelope.aggregateVersion(), payloadHash,
+                            envelope.eventId(), value.changedAt());
+                }
+                case EventTypes.IAM_PERMISSION_VERSION_CHANGED -> {
+                    var value = objectMapper.treeToValue(envelope.payload(),
+                            IamSecurityEventsV1.PermissionVersionChanged.class);
+                    requireIdentity(envelope, "AUTHORIZATION", value.authUserId(), value.tenantId());
+                    requirePayload(value.appCode(), value.changedAt(), value.permissionVersion(),
+                            envelope.aggregateVersion());
+                    yield new ProjectionInput("AUTHORIZATION", String.valueOf(value.authUserId()), value.tenantId(),
+                            null, value.permissionVersion(), envelope.aggregateVersion(), payloadHash,
+                            envelope.eventId(), value.changedAt());
+                }
+                default -> throw new IllegalArgumentException("unsupported type");
+            };
+        } catch (BizException exception) {
+            throw exception;
+        } catch (Exception exception) {
+            throw new BizException(ResultCode.BAD_REQUEST, "IAM 安全事件 payload 无效");
+        }
+    }
+
+    private static void requireIdentity(EventEnvelope envelope, String aggregateType,
+                                        long aggregateId, long tenantId) {
+        if (!aggregateType.equals(envelope.aggregateType())
+                || !String.valueOf(aggregateId).equals(envelope.aggregateId())
+                || !String.valueOf(tenantId).equals(envelope.tenantId())) {
+            throw new BizException(ResultCode.CONFLICT, "IAM 安全事件信封与 payload 身份不一致");
+        }
+    }
+
+    private static void requirePayload(String requiredText, Instant changedAt,
+                                       long payloadVersion, long aggregateVersion) {
+        if (requiredText == null || requiredText.isBlank() || changedAt == null
+                || payloadVersion != aggregateVersion) {
+            throw new BizException(ResultCode.CONFLICT, "IAM 安全事件 payload 版本或必填字段无效");
+        }
+    }
+
+    private static void requireStatus(String status) {
+        if (!"ACTIVE".equals(status) && !"DISABLED".equals(status)) {
+            throw new BizException(ResultCode.BAD_REQUEST, "IAM 安全状态仅允许 ACTIVE 或 DISABLED");
+        }
+    }
+
+    private ProjectionRow findForUpdate(String type, String id) {
+        List<ProjectionRow> rows = jdbc.query(
+                "SELECT aggregate_version,payload_hash FROM ll_security_projection "
+                        + "WHERE aggregate_type=? AND aggregate_id=? FOR UPDATE",
+                (rs, row) -> new ProjectionRow(rs.getLong(1), rs.getString(2)), type, id);
+        return rows.isEmpty() ? null : rows.get(0);
+    }
+
+    private void upsert(ProjectionInput value) {
+        jdbc.update("INSERT INTO ll_security_projection(aggregate_type,aggregate_id,tenant_id,security_status,"
+                        + "permission_version,aggregate_version,payload_hash,last_event_id,changed_at,updated_at) "
+                        + "VALUES (?,?,?,?,?,?,?,?,?,NOW(3)) ON DUPLICATE KEY UPDATE tenant_id=VALUES(tenant_id),"
+                        + "security_status=VALUES(security_status),permission_version=VALUES(permission_version),"
+                        + "aggregate_version=VALUES(aggregate_version),payload_hash=VALUES(payload_hash),"
+                        + "last_event_id=VALUES(last_event_id),changed_at=VALUES(changed_at),updated_at=NOW(3)",
+                value.aggregateType(), value.aggregateId(), value.tenantId(), value.status(),
+                value.permissionVersion(), value.aggregateVersion(), value.payloadHash(), value.eventId(),
+                value.changedAt());
+    }
+
+    private record InboxRow(String eventType, String payloadHash, String status) { }
+    private record ProjectionRow(long aggregateVersion, String payloadHash) { }
+    public record ConsumeResult(String result, ProjectionInput projection) { }
+    public record ProjectionChanged(ProjectionInput projection) { }
+    public record ProjectionInput(String aggregateType, String aggregateId, long tenantId, String status,
+                                  Long permissionVersion, long aggregateVersion, String payloadHash,
+                                  String eventId, Instant changedAt) { }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/security/service/LastlegSecurityValidationService.java

@@ -0,0 +1,60 @@
+package com.baiyue.lastleg.security.service;
+
+import com.baiyue.lastleg.security.dto.LastlegSecurityDtos.FailureReason;
+import com.baiyue.lastleg.security.dto.LastlegSecurityDtos.ValidationRequest;
+import com.baiyue.lastleg.security.dto.LastlegSecurityDtos.ValidationResponse;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+@Service
+public class LastlegSecurityValidationService {
+    private final JdbcTemplate jdbc;
+
+    public LastlegSecurityValidationService(JdbcTemplate jdbc) {
+        this.jdbc = jdbc;
+    }
+
+    public ValidationResponse validate(ValidationRequest request) {
+        String userStatus = status("USER", String.valueOf(request.userId()), request.tenantId());
+        if (userStatus == null) {
+            return ValidationResponse.rejected(FailureReason.SECURITY_PROJECTION_MISSING);
+        }
+        if (!"ACTIVE".equals(userStatus)) {
+            return ValidationResponse.rejected(FailureReason.USER_DISABLED);
+        }
+        if (request.tenantId() > 0) {
+            String tenantStatus = status("TENANT", String.valueOf(request.tenantId()), request.tenantId());
+            if (tenantStatus == null) {
+                return ValidationResponse.rejected(FailureReason.SECURITY_PROJECTION_MISSING);
+            }
+            if (!"ACTIVE".equals(tenantStatus)) {
+                return ValidationResponse.rejected(FailureReason.TENANT_DISABLED);
+            }
+        }
+        List<Long> projectedVersions = jdbc.query(
+                "SELECT MAX(permission_version) FROM ll_security_projection "
+                        + "WHERE aggregate_id=? AND tenant_id=? "
+                        + "AND aggregate_type IN ('USER','AUTHORIZATION') HAVING COUNT(permission_version)>0",
+                (rs, row) -> rs.getLong(1), String.valueOf(request.userId()), request.tenantId());
+        if (projectedVersions.isEmpty()) {
+            return ValidationResponse.rejected(FailureReason.SECURITY_PROJECTION_MISSING);
+        }
+        long projectedVersion = projectedVersions.get(0);
+        if (request.permissionVersion() < projectedVersion) {
+            return ValidationResponse.rejected(FailureReason.PERMISSION_VERSION_STALE);
+        }
+        if (request.permissionVersion() > projectedVersion) {
+            return ValidationResponse.rejected(FailureReason.SECURITY_PROJECTION_NOT_READY);
+        }
+        return ValidationResponse.accepted();
+    }
+
+    private String status(String type, String id, long tenantId) {
+        List<String> values = jdbc.query("SELECT security_status FROM ll_security_projection "
+                        + "WHERE aggregate_type=? AND aggregate_id=? AND tenant_id=?",
+                (rs, row) -> rs.getString(1), type, id, tenantId);
+        return values.isEmpty() ? null : values.get(0);
+    }
+}

lastleg-service/src/main/java/com/baiyue/lastleg/security/service/SecurityProjectionMonotonicity.java

@@ -0,0 +1,19 @@
+package com.baiyue.lastleg.security.service;
+
+import com.baiyue.common.core.api.ResultCode;
+import com.baiyue.common.core.exception.BizException;
+
+import java.util.Objects;
+
+final class SecurityProjectionMonotonicity {
+    private SecurityProjectionMonotonicity() { }
+
+    static Decision decide(Long currentVersion, String currentHash, long incomingVersion, String incomingHash) {
+        if (currentVersion == null || incomingVersion > currentVersion) return Decision.APPLY;
+        if (incomingVersion < currentVersion) return Decision.STALE;
+        if (Objects.equals(currentHash, incomingHash)) return Decision.DUPLICATE_VERSION;
+        throw new BizException(ResultCode.CONFLICT, "相同聚合版本的安全事件 payloadHash 冲突");
+    }
+
+    enum Decision { APPLY, STALE, DUPLICATE_VERSION }
+}

lastleg-service/src/main/resources/application.yml

@@ -70,7 +70,7 @@ baiyue:
       lease-seconds: ${FIRSTLEG_OUTBOX_RELAY_LEASE_SECONDS:60}
       retry-seconds: ${FIRSTLEG_OUTBOX_RELAY_RETRY_SECONDS:30}
   security:
-    internal-service-token: ${INTERNAL_SERVICE_TOKEN:phase1-local-internal-token-at-least-32-bytes}
+    internal-service-token: ${INTERNAL_SERVICE_TOKEN:}
     jwt-mode: jwks
     session-mode: claims
     issuer: ${JWT_ISSUER:auth-service}

lastleg-service/src/main/resources/db/lastleg.sql

@@ -1624,3 +1624,42 @@ CREATE TABLE IF NOT EXISTS ll_local_looseboard_operation (
   UNIQUE KEY uk_ll_local_looseboard_operation_key(customer_id,order_id,idempotency_key),
   KEY idx_ll_local_looseboard_operation_order(customer_id,order_id,created_at)
 ) ENGINE=InnoDB COMMENT='本土散板订单幂等操作账';
+
+CREATE TABLE IF NOT EXISTS ll_security_event_inbox (
+  event_id VARCHAR(64) NOT NULL COMMENT '跨区安全事件ID',
+  event_type VARCHAR(96) NOT NULL COMMENT 'IAM安全事件类型',
+  payload_hash CHAR(64) NOT NULL COMMENT '规范化载荷SHA-256哈希',
+  payload_json JSON NOT NULL COMMENT '冻结事件载荷JSON',
+  status VARCHAR(16) NOT NULL COMMENT '消费状态：RECEIVED或PROCESSED',
+  result VARCHAR(32) NULL COMMENT '处理结果：APPLIED、STALE、DUPLICATE或DUPLICATE_VERSION',
+  received_at DATETIME(3) NOT NULL COMMENT '接收时间',
+  processed_at DATETIME(3) NULL COMMENT '处理完成时间',
+  PRIMARY KEY (event_id),
+  KEY idx_security_inbox_type_time (event_type,received_at)
+) ENGINE=InnoDB COMMENT='海外IAM安全事件消费者收件箱';
+
+CREATE TABLE IF NOT EXISTS ll_security_projection (
+  aggregate_type VARCHAR(32) NOT NULL COMMENT '聚合类型：USER、TENANT或AUTHORIZATION',
+  aggregate_id VARCHAR(64) NOT NULL COMMENT '用户或客户聚合ID',
+  tenant_id BIGINT NOT NULL COMMENT '平台0或客户ID',
+  security_status VARCHAR(24) NULL COMMENT '当前安全状态：ACTIVE或DISABLED',
+  permission_version BIGINT NULL COMMENT '当前单调权限版本',
+  aggregate_version BIGINT NOT NULL COMMENT '事件聚合单调版本',
+  payload_hash CHAR(64) NOT NULL COMMENT '当前版本载荷哈希',
+  last_event_id VARCHAR(64) NOT NULL COMMENT '最后应用的事件ID',
+  changed_at DATETIME(3) NOT NULL COMMENT '国内IAM事实发生时间',
+  updated_at DATETIME(3) NOT NULL COMMENT '投影更新时间',
+  PRIMARY KEY (aggregate_type,aggregate_id),
+  KEY idx_security_projection_tenant (tenant_id),
+  KEY idx_security_projection_permission (aggregate_id,permission_version)
+) ENGINE=InnoDB COMMENT='海外IAM安全状态与权限版本投影';
+
+-- 开发基线固定管理员；后续真实 IAM 事件从 aggregate_version=1 单调覆盖该 version=0 投影。
+INSERT IGNORE INTO ll_security_projection (
+  aggregate_type,aggregate_id,tenant_id,security_status,permission_version,aggregate_version,
+  payload_hash,last_event_id,changed_at,updated_at
+) VALUES
+  ('USER','1000001',0,'ACTIVE',0,0,SHA2('lastleg-baseline:platform_admin:USER:0',256),
+   'baseline-platform-admin-user-v0','1970-01-01 00:00:00.000','1970-01-01 00:00:00.000'),
+  ('AUTHORIZATION','1000001',0,NULL,0,0,SHA2('lastleg-baseline:platform_admin:AUTHORIZATION:0',256),
+   'baseline-platform-admin-authorization-v0','1970-01-01 00:00:00.000','1970-01-01 00:00:00.000');

lastleg-service/src/test/java/com/baiyue/lastleg/security/InternalServiceTokenGuardTest.java

@@ -9,4 +9,10 @@ class InternalServiceTokenGuardTest {
         assertEquals(401,assertThrows(ResponseStatusException.class,()->guard.verify("wrong")).getStatusCode().value());
         assertEquals(401,assertThrows(ResponseStatusException.class,()->guard.verify(null)).getStatusCode().value());
     }
+
+    @Test void missingServerConfigurationFailsClosed() {
+        InternalServiceTokenGuard guard = new InternalServiceTokenGuard("");
+        assertEquals(503, assertThrows(ResponseStatusException.class,
+                () -> guard.verify("any-token")).getStatusCode().value());
+    }
 }

lastleg-service/src/test/java/com/baiyue/lastleg/security/LastlegSecurityContractTest.java

@@ -0,0 +1,75 @@
+package com.baiyue.lastleg.security;
+
+import org.junit.jupiter.api.Test;
+
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class LastlegSecurityContractTest {
+    @Test void securityProjectionLivesInLastlegDatabaseWithReliableInbox() throws Exception {
+        String baseline = read("lastleg-service/src/main/resources/db/lastleg.sql");
+        String migration = read("deploy/sql/海外区域统一增量-MySQL8.sql");
+        String authSeed = read("auth/src/main/resources/db/phase1-admin-accounts.sql");
+        String service = read("lastleg-service/src/main/java/com/baiyue/lastleg/security/service/LastlegSecurityProjectionService.java");
+        String validation = read("lastleg-service/src/main/java/com/baiyue/lastleg/security/service/LastlegSecurityValidationService.java");
+        String validationDto = read("lastleg-service/src/main/java/com/baiyue/lastleg/security/dto/LastlegSecurityDtos.java");
+        String mirror = read("lastleg-service/src/main/java/com/baiyue/lastleg/security/service/LastlegSecurityProjectionRedisMirror.java");
+        assertThat(baseline).contains("CREATE TABLE IF NOT EXISTS ll_security_event_inbox",
+                "PRIMARY KEY (event_id)", "payload_hash CHAR(64)",
+                "CREATE TABLE IF NOT EXISTS ll_security_projection",
+                "PRIMARY KEY (aggregate_type,aggregate_id)", "aggregate_version BIGINT",
+                "permission_version BIGINT");
+        for (String sql : new String[]{baseline, migration}) {
+            assertThat(sql).contains("('USER','1000001',0,'ACTIVE',0,0",
+                    "('AUTHORIZATION','1000001',0,NULL,0,0",
+                    "baseline-platform-admin-user-v0",
+                    "baseline-platform-admin-authorization-v0")
+                    .doesNotContain("baseline-merchant-admin");
+        }
+        assertThat(authSeed).contains("(1000001, 'platform_admin'", "default_tenant_id",
+                "default_app_code");
+        assertThat(migration).contains("USE baiyue_lastleg;", "table_schema='baiyue_lastleg'")
+                .doesNotContain("CREATE DATABASE IF NOT EXISTS baiyue_overseas_security",
+                        "USE baiyue_overseas_security;", "CREATE TABLE IF NOT EXISTS overseas_security_event_inbox",
+                        "CREATE TABLE IF NOT EXISTS overseas_security_projection");
+        assertThat(service).contains("SecurityProjectionMonotonicity.decide", "Decision.APPLY");
+        assertThat(service).contains("EventPayloadHash.matches", "validatedStorageHash")
+                .doesNotContain("LoadingCompletedConsumer");
+        assertThat(mirror).contains("TransactionPhase.AFTER_COMMIT", "Redis 镜像写入失败");
+        assertThat(validation).contains("SELECT MAX(permission_version)", "tenant_id=?",
+                "SECURITY_PROJECTION_MISSING", "SECURITY_PROJECTION_NOT_READY", "USER_DISABLED",
+                "TENANT_DISABLED", "PERMISSION_VERSION_STALE");
+        assertThat(validationDto).contains("Long userId", "Long tenantId", "Long permissionVersion")
+                .doesNotContain("Long tokenVersion");
+    }
+
+    @Test void genericLastlegEventEndpointWhitelistsBusinessEventsOnly() throws Exception {
+        String controller = read("lastleg-service/src/main/java/com/baiyue/lastleg/controller/LastlegOrderController.java");
+        assertThat(controller).contains("FIRST_LEG_CONTAINER_SHIPPING_NODE_RECORDED",
+                "FIRST_LEG_LOADING_PLAN_COMPLETED", "Lastleg 不消费该事件类型")
+                .doesNotContain("IAM_USER_STATUS_CHANGED", "IAM_TENANT_STATUS_CHANGED",
+                        "IAM_PERMISSION_VERSION_CHANGED");
+    }
+
+    @Test void internalControllerUsesLastlegOwnedPathsAndExistingTokenGuard() throws Exception {
+        String controller = read("lastleg-service/src/main/java/com/baiyue/lastleg/security/controller/LastlegSecurityController.java");
+        String guard = read("lastleg-service/src/main/java/com/baiyue/lastleg/security/InternalServiceTokenGuard.java");
+        String application = read("lastleg-service/src/main/resources/application.yml");
+        assertThat(controller).contains("@RequestMapping(\"/internal/lastleg/security/v1\")",
+                "@PostMapping(\"/events\")", "@PostMapping(\"/validate\")",
+                "com.baiyue.lastleg.security.InternalServiceTokenGuard")
+                .doesNotContain("/internal/overseas-security/v1");
+        assertThat(guard).contains("MessageDigest.isEqual", "SERVICE_UNAVAILABLE", "UNAUTHORIZED");
+        assertThat(application).contains("internal-service-token: ${INTERNAL_SERVICE_TOKEN:}")
+                .doesNotContain("phase1-local-internal-token");
+    }
+
+    private static String read(String relative) throws Exception {
+        Path path = Path.of(relative);
+        if (!Files.exists(path)) path = Path.of("..").resolve(relative);
+        return Files.readString(path, StandardCharsets.UTF_8);
+    }
+}

lastleg-service/src/test/java/com/baiyue/lastleg/security/SecurityProjectionArchitectureTest.java

@@ -0,0 +1,49 @@
+package com.baiyue.lastleg.security;
+
+import com.tngtech.archunit.core.domain.JavaClasses;
+import com.tngtech.archunit.core.importer.ClassFileImporter;
+import com.tngtech.archunit.core.importer.ImportOption;
+import org.junit.jupiter.api.Test;
+
+import static com.tngtech.archunit.core.domain.JavaClass.Predicates.resideInAPackage;
+import static com.tngtech.archunit.core.domain.JavaClass.Predicates.resideOutsideOfPackage;
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes;
+import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;
+
+class SecurityProjectionArchitectureTest {
+    private static final String LASTLEG = "com.baiyue.lastleg..";
+    private static final String CONTROLLER = "com.baiyue.lastleg.security.controller..";
+    private static final String DTO = "com.baiyue.lastleg.security.dto..";
+    private static final String SERVICE = "com.baiyue.lastleg.security.service..";
+
+    private static final JavaClasses PRODUCTION_CLASSES = new ClassFileImporter()
+        .withImportOption(ImportOption.Predefined.DO_NOT_INCLUDE_TESTS)
+        .withImportOption(ImportOption.Predefined.DO_NOT_INCLUDE_JARS)
+        .importPackages("com.baiyue.lastleg");
+
+    @Test
+    void projectionInternalsDoNotDependOnLastlegBusinessSlices() {
+        classes().that().resideInAnyPackage(CONTROLLER, DTO, SERVICE)
+            .should().onlyDependOnClassesThat(
+                resideOutsideOfPackage(LASTLEG)
+                    .or(resideInAPackage(CONTROLLER))
+                    .or(resideInAPackage(DTO))
+                    .or(resideInAPackage(SERVICE))
+                    .or(resideInAPackage("com.baiyue.lastleg.security")))
+            .check(PRODUCTION_CLASSES);
+    }
+
+    @Test
+    void businessSlicesDoNotDependOnProjectionInternals() {
+        noClasses().that().resideOutsideOfPackages(CONTROLLER, DTO, SERVICE)
+            .should().dependOnClassesThat().resideInAnyPackage(CONTROLLER, DTO, SERVICE)
+            .check(PRODUCTION_CLASSES);
+    }
+
+    @Test
+    void dtoAndServicesStayIndependentFromInternalWebAdapter() {
+        noClasses().that().resideInAnyPackage(DTO, SERVICE)
+            .should().dependOnClassesThat().resideInAPackage(CONTROLLER)
+            .check(PRODUCTION_CLASSES);
+    }
+}

lastleg-service/src/test/java/com/baiyue/lastleg/security/service/LastlegSecurityProjectionTransportTest.java

@@ -0,0 +1,54 @@
+package com.baiyue.lastleg.security.service;
+
+import com.baiyue.common.core.exception.BizException;
+import com.baiyue.common.event.EventEnvelope;
+import com.baiyue.common.event.EventPayloadCanonicalizer;
+import com.baiyue.common.event.EventPayloadHash;
+import com.baiyue.common.event.EventTypes;
+import com.baiyue.common.event.IamSecurityEventsV1;
+import com.baiyue.common.event.RegionCode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.jupiter.api.Test;
+
+import java.time.Instant;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class LastlegSecurityProjectionTransportTest {
+    private final ObjectMapper objectMapper = new ObjectMapper().findAndRegisterModules();
+
+    @Test
+    void validatesEnvelopeHashAndStoresTheSixtyFourCharacterDigest() {
+        EventEnvelope envelope = envelope();
+
+        String stored = LastlegSecurityProjectionService.validatedStorageHash(envelope);
+
+        assertThat(stored).hasSize(64).doesNotStartWith("sha256:");
+        assertThat(envelope.payloadHash()).isEqualTo("sha256:" + stored);
+    }
+
+    @Test
+    void rejectsTamperedPayloadBeforeInboxMutation() {
+        EventEnvelope source = envelope();
+        EventEnvelope tampered = new EventEnvelope(source.eventId(), source.eventType(), source.eventVersion(),
+            source.occurredAt(), source.sourceRegion(), source.targetRegion(), source.tenantId(),
+            source.aggregateType(), source.aggregateId(), source.aggregateVersion(), source.handoverVersion(),
+            source.traceId(), source.correlationId(), source.causationId(), source.payload(),
+            "sha256:" + "0".repeat(64));
+
+        assertThatThrownBy(() -> LastlegSecurityProjectionService.validatedStorageHash(tampered))
+            .isInstanceOf(BizException.class).hasMessageContaining("payloadHash");
+    }
+
+    private EventEnvelope envelope() {
+        var value = new IamSecurityEventsV1.PermissionVersionChanged(
+            101L, 0L, "PLATFORM", 3L, "contract", Instant.parse("2026-08-25T07:00:00Z"));
+        var payload = objectMapper.valueToTree(value);
+        return new EventEnvelope("00000000-0000-4000-8000-000000000091",
+            EventTypes.IAM_PERMISSION_VERSION_CHANGED, IamSecurityEventsV1.VERSION,
+            Instant.parse("2026-08-25T07:00:00Z"), RegionCode.CN, RegionCode.OVERSEAS, "0",
+            "AUTHORIZATION", "101", 3L, null, "trace-12345678", "correlation-12345678",
+            null, payload, EventPayloadHash.sha256(EventPayloadCanonicalizer.canonicalize(payload)));
+    }
+}

lastleg-service/src/test/java/com/baiyue/lastleg/security/service/LastlegSecurityValidationServiceTest.java

@@ -0,0 +1,67 @@
+package com.baiyue.lastleg.security.service;
+
+import com.baiyue.lastleg.security.dto.LastlegSecurityDtos.FailureReason;
+import com.baiyue.lastleg.security.dto.LastlegSecurityDtos.ValidationRequest;
+import org.junit.jupiter.api.Test;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.RowMapper;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+
+class LastlegSecurityValidationServiceTest {
+    private final JdbcTemplate jdbc = mock(JdbcTemplate.class);
+    private final LastlegSecurityValidationService service = new LastlegSecurityValidationService(jdbc);
+
+    @Test void disabledUserFailsClosed() {
+        doReturn(List.of("DISABLED")).when(jdbc)
+                .query(anyString(), any(RowMapper.class), any(Object[].class));
+        assertThat(service.validate(new ValidationRequest(42L, 0L, 8L)).failureReason())
+                .isEqualTo(FailureReason.USER_DISABLED);
+    }
+
+    @Test void disabledCustomerFailsClosed() {
+        doReturn(List.of("ACTIVE"), List.of("DISABLED")).when(jdbc)
+                .query(anyString(), any(RowMapper.class), any(Object[].class));
+        assertThat(service.validate(new ValidationRequest(42L, 100L, 8L)).failureReason())
+                .isEqualTo(FailureReason.TENANT_DISABLED);
+    }
+
+    @Test void missingUserProjectionFailsClosed() {
+        doReturn(List.of()).when(jdbc)
+                .query(anyString(), any(RowMapper.class), any(Object[].class));
+        assertThat(service.validate(new ValidationRequest(42L, 0L, 8L)).failureReason())
+                .isEqualTo(FailureReason.SECURITY_PROJECTION_MISSING);
+    }
+
+    @Test void customerProjectionIsMandatoryButPlatformTenantDoesNotNeedOne() {
+        doReturn(List.of("ACTIVE"), List.of(), List.of("ACTIVE"), List.of(8L)).when(jdbc)
+                .query(anyString(), any(RowMapper.class), any(Object[].class));
+        assertThat(service.validate(new ValidationRequest(42L, 100L, 8L)).failureReason())
+                .isEqualTo(FailureReason.SECURITY_PROJECTION_MISSING);
+        assertThat(service.validate(new ValidationRequest(42L, 0L, 8L)).valid()).isTrue();
+    }
+
+    @Test void permissionVersionMustExactlyMatchReliableProjection() {
+        doReturn(List.of("ACTIVE"), List.of(9L), List.of("ACTIVE"), List.of(9L),
+                List.of("ACTIVE"), List.of(9L)).when(jdbc)
+                .query(anyString(), any(RowMapper.class), any(Object[].class));
+        assertThat(service.validate(new ValidationRequest(42L, 0L, 8L)).failureReason())
+                .isEqualTo(FailureReason.PERMISSION_VERSION_STALE);
+        assertThat(service.validate(new ValidationRequest(42L, 0L, 10L)).failureReason())
+                .isEqualTo(FailureReason.SECURITY_PROJECTION_NOT_READY);
+        assertThat(service.validate(new ValidationRequest(42L, 0L, 9L)).valid()).isTrue();
+    }
+
+    @Test void missingPermissionProjectionFailsClosed() {
+        doReturn(List.of("ACTIVE"), List.of()).when(jdbc)
+                .query(anyString(), any(RowMapper.class), any(Object[].class));
+        assertThat(service.validate(new ValidationRequest(42L, 0L, 9L)).failureReason())
+                .isEqualTo(FailureReason.SECURITY_PROJECTION_MISSING);
+    }
+}

lastleg-service/src/test/java/com/baiyue/lastleg/security/service/SecurityProjectionMonotonicityTest.java

@@ -0,0 +1,28 @@
+package com.baiyue.lastleg.security.service;
+
+import com.baiyue.common.core.exception.BizException;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class SecurityProjectionMonotonicityTest {
+    @Test void appliesFirstAndNewerVersions() {
+        assertThat(SecurityProjectionMonotonicity.decide(null, null, 1, "hash-1"))
+                .isEqualTo(SecurityProjectionMonotonicity.Decision.APPLY);
+        assertThat(SecurityProjectionMonotonicity.decide(1L, "hash-1", 2, "hash-2"))
+                .isEqualTo(SecurityProjectionMonotonicity.Decision.APPLY);
+    }
+
+    @Test void ignoresOlderAndSameHashVersions() {
+        assertThat(SecurityProjectionMonotonicity.decide(3L, "hash-3", 2, "hash-2"))
+                .isEqualTo(SecurityProjectionMonotonicity.Decision.STALE);
+        assertThat(SecurityProjectionMonotonicity.decide(3L, "hash-3", 3, "hash-3"))
+                .isEqualTo(SecurityProjectionMonotonicity.Decision.DUPLICATE_VERSION);
+    }
+
+    @Test void rejectsSameVersionWithDifferentHash() {
+        assertThatThrownBy(() -> SecurityProjectionMonotonicity.decide(3L, "hash-a", 3, "hash-b"))
+                .isInstanceOf(BizException.class).hasMessageContaining("payloadHash 冲突");
+    }
+}

lastleg-service/src/test/resources/architecture/lastleg-slice-dependencies.json

@@ -23,6 +23,7 @@
     "relabel-transfer-discard->inventory",
     "relabel-transfer-discard->shared-technical",
     "relabel-transfer-discard->tailleg-handoff",
+    "security-projection->shared-technical",
     "tailleg-handoff->dropship",
     "tailleg-handoff->inbound-pda",
     "tailleg-handoff->inventory",
@@ -35,7 +36,13 @@
     "com.baiyue.lastleg.masterdata.vehicle.adapter.out.persistence.VehicleRecord": "src/main/java/com/baiyue/lastleg/masterdata/vehicle/adapter/out/persistence/VehicleRecord.java",
     "com.baiyue.lastleg.masterdata.vehicle.application.VehicleApplicationService": "src/main/java/com/baiyue/lastleg/masterdata/vehicle/application/VehicleApplicationService.java",
     "com.baiyue.lastleg.masterdata.vehicle.application.model.VehicleModels": "src/main/java/com/baiyue/lastleg/masterdata/vehicle/application/model/VehicleModels.java",
-    "com.baiyue.lastleg.masterdata.vehicle.application.port.out.VehicleRepository": "src/main/java/com/baiyue/lastleg/masterdata/vehicle/application/port/out/VehicleRepository.java"
+    "com.baiyue.lastleg.masterdata.vehicle.application.port.out.VehicleRepository": "src/main/java/com/baiyue/lastleg/masterdata/vehicle/application/port/out/VehicleRepository.java",
+    "com.baiyue.lastleg.security.controller.LastlegSecurityController": "src/main/java/com/baiyue/lastleg/security/controller/LastlegSecurityController.java",
+    "com.baiyue.lastleg.security.dto.LastlegSecurityDtos": "src/main/java/com/baiyue/lastleg/security/dto/LastlegSecurityDtos.java",
+    "com.baiyue.lastleg.security.service.LastlegSecurityProjectionRedisMirror": "src/main/java/com/baiyue/lastleg/security/service/LastlegSecurityProjectionRedisMirror.java",
+    "com.baiyue.lastleg.security.service.LastlegSecurityProjectionService": "src/main/java/com/baiyue/lastleg/security/service/LastlegSecurityProjectionService.java",
+    "com.baiyue.lastleg.security.service.LastlegSecurityValidationService": "src/main/java/com/baiyue/lastleg/security/service/LastlegSecurityValidationService.java",
+    "com.baiyue.lastleg.security.service.SecurityProjectionMonotonicity": "src/main/java/com/baiyue/lastleg/security/service/SecurityProjectionMonotonicity.java"
   },
   "applicationDependencyRule": {
     "packagePrefix": "com.baiyue.lastleg.masterdata.vehicle.application",
@@ -49,6 +56,10 @@
     ]
   },
   "sliceSpecificRules": {
+    "security-projection": {
+      "allowedOutgoing": ["shared-technical"],
+      "allowedIncoming": []
+    },
     "overseas-master-data": {
       "allowedOutgoing": ["shared-technical"],
       "allowedIncoming": ["procurement-trucking-looseboard"]